列表是Python中最基本的数据结构，列表是最常用的Python数据类型，列表的数据项不需要具有相同的类型。列表中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。Python有6个序列的内置类型，但最常见的是列表和元组。序列都可以进行的操作包括索引，切片，加，乘，检查成员。此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
一、创建一个列表只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：
list1 = ['physics', 'chemistry', <span style="color: #97, <span style="color: #00];
list2 = [<span style="color: #, <span style="color: #, <span style="color: #, <span style="color: #, <span style="color: # ];
list3 = ["a", "b", "c", "d"];
与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。二、访问列表中的值使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：
#!/usr/bin/python
list1 = ['physics', 'chemistry', <span style="color: #97, <span style="color: #00];
list2 = [<span style="color: #, <span style="color: #, <span style="color: #, <span style="color: #, <span style="color: #, <span style="color: #, <span style="color: # ];
print "list1[0]: ", list1[<span style="color: #]
print "list2[1:5]: ", list2[<span style="color: #:<span style="color: #]
以上实例的输出结果：
list1[<span style="color: #]:& physics
list2[<span style="color: #:<span style="color: #]:& [<span style="color: #, <span style="color: #, <span style="color: #, <span style="color: #]
三、更新列表你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示：
#!/usr/bin/python
list = ['physics', 'chemistry', <span style="color: #97, <span style="color: #00];
print "Value available at index 2 : "
print list[<span style="color: #];
list[<span style="color: #] = <span style="color: #01;
print "New value available at index 2 : "
print list[<span style="color: #];
以上实例的输出结果是：
Value available at index <span style="color: # :
<span style="color: #97
New value available at index <span style="color: # :
<span style="color: #01
使用append()方法来添加列表项
&&& s=['physics','chemistry']
&&& s.append("wangtao")
['physics', 'chemistry', 'wangtao']
四、删除列表元素可以使用 del 语句来删除列表的的元素，如下实例：
#!/usr/bin/python
list1 = ['physics', 'chemistry', <span style="color: #97, <span style="color: #00];
print list1;
del list1[<span style="color: #];
print "After deleting value at index 2 : "
print list1;
&以上实例的输出结果是：
['physics', 'chemistry', <span style="color: #97, <span style="color: #00]
After deleting value at index <span style="color: # :
['physics', 'chemistry', <span style="color: #00]
五、Python列表脚本操作符列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
如下所示：
Python 表达式结果描述
len([1, 2, 3])
[1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
['Hi!'] * 4
['Hi!', 'Hi!', 'Hi!', 'Hi!']
3 in [1, 2, 3]
元素是否存在于列表中
for x in [1, 2, 3]: print x,
六、Python列表截取Python的列表截取与字符串操作类型，如下所示：
L = ['spam', 'Spam', 'SPAM!']
Python 表达式结果描述
读取列表中第三个元素
读取列表中倒数第二个元素
['Spam', 'SPAM!']
从第二个元素开始截取列表
七、Python列表操作的函数和方法列表操作包含以下函数:1、cmp(list1, list2)：比较两个列表的元素 2、len(list)：列表元素个数 3、max(list)：返回列表元素最大值 4、min(list)：返回列表元素最小值 5、list(seq)：将元组转换为列表 列表操作包含以下方法:1、list.append(obj)：在列表末尾添加新的对象2、list.count(obj)：统计某个元素在列表中出现的次数3、list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）4、list.index(obj)：从列表中找出某个值第一个匹配项的索引位置5、list.insert(index, obj)：将对象插入列表6、list.pop(obj=list[-1])：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值7、list.remove(obj)：移除列表中某个值的第一个匹配项8、list.reverse()：反向列表中元素9、list.sort([func])：对原列表进行排序
八、extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
#!/usr/bin/python
aList = [123, 'xyz', 'zara', 'abc', 123];
bList = [2009, 'manni'];
aList.extend(bList)
print "Extended List : ", aL
&以上实验的输出结果：
$ python extend.py
Extended List: [123, 'xyz', 'zara', 'abc', 123, 2009, 'manni']
阅读(...) 评论()在 SegmentFault，解决技术问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
一线的工程师、著名开源项目的作者们，都在这里：
获取验证码
已有账号？
问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
S0=['S1','S2','S3']
def du(S0,P):
for i in range(len(S0)):
def d(S0[i]):
for n in range(len(P)):
if S0[i] in P[n]:
if d(S0[i])==0:
这里我想以 S0[i] 作为 d() 的参数，请问怎样可以实现以带下标的 list 作为函数参数? 或者有什么可以替代的方法？。
这个 d() 函数是要对 S0 中的每个元素进行分析的，我是想做一个简单的多边形拓扑关系的程序，要计算每条边（也就是 S0[i] ）的度，当度大于 2 时把这条边从 S0 里删掉。
这里用 range 而不是直接 for i in list 是因为在另一个list中还要用到相同的下标位置，然后 P 也用 range 是因为 P 里边还有 list。
好像按@yooz_hardy所说的用 enumerate 可以解决我的问题了，还有什么更好的方法或者优化建议欢迎指出。
现在下标的问题已经弄清楚了，但是有关我这个多边形拓扑关系建立的作业又有了别的问题：
A=['S3','S2','S1']
B=['S4','S6','S1']
C=['S2','S5','S4']
D=['S3','S6','S5']
N=[A,B,C,D]
#节点表，每个点记录顺时针方向排序的弧段
N0=['A','B','C','D']
#节点的字符表
S1=['A','B']
S2=['C','A']
S3=['D','A']
S4=['B','C']
S5=['C','D']
S6=['B','D']
S=[S1,S2,S3,S4,S5,S6]
#弧段表，每个弧段含有起始点和终点
S0=['S1','S2','S3','S4','S5','S6']
#弧段的字符表
def du(Si,P):
#定义弧段的‘度’，弧段属于一个多边形度就加一
for Pi in P:
if Si in Pi:
for i,Si in enumerate(S0):
for j,Nj in enumerate(N0):
if du(Si,P)==1:
#如果某弧段度等于1，将其从弧段表中删去
S0.remove(Si)
S.remove(S[i])
elif du(Si,P)==2:
#如果某弧段度等于2，将其从节点的弧段排序中删去
N[j].remove(Si)
#建立当前多边形
Ns=S[i][0]
Nc=S[i][1]
while Ns != Nc:
k=N0.index(Nc)
p=N[k].index(Sc)
#寻找当前点字符对应的节点，并在结点表中找到当前边位置
#当前边在表中下一条边的位置
if p1 & len(N[k]):
Sc=N[k][p1]
#把下一条边设为当前边
Pc.append(Sc)
#把新的当前边加入多边形中
n=S0.index(Sc)
Nc=S[n][1]
P.append(Pc)
#起点终点重合时将当前多边形放入多边形组中
问题：1.忽略了左多边形和右多边形，左多边形的新当前点为S[n][1]，右多边形新当前点为S[n][0]，这个可以先做个if看原本的当前点在新的当前弧中的位置，再确定是左还是右2.但是多边形组'P'的结构不知道怎么设置比较好，如果在每个多边形里再分L,R两个分组会不会太复杂（起始边可以默认放在左多边形里）3.节点表和弧段表每个都有对应的字符表，下边运算的时候还要找相应位置进行处理，挺麻烦，有没有什么函数直接把list的子集名变为字符？或者有什么更好的结构？
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
根據目前現有的資訊，下面可能是你可以參考的寫法:
def d(s_item, P):
for p_item in P:
if s_item in p_item:
S0=['S1','S2','S3']
# 處理 S0 中的每一個元素
for s_item in S0:
if d(s_item, P)==0:
# do something...
elif d(s_item, P)==...
# do something...
其他幾位大大已經給了滿多有用的建議，我有另外一個建議是，變數在取名的時候盡量取有意義的名字，這樣看 code 的人會比較快理解你的意思。
P.S. 看你一開始的問題，發現你可能對於 Python 的 function 定義，呼叫 和參數等不是很熟悉，建議一定要趁此機會搞懂，若有任何自己覺得不清楚的地方，可以在這裡盡量問清楚，大家會幫助你的，祝好運!
分享到微博？
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
我要该，理由是：1695人阅读
Python（10）
转载请注明出处
上一篇说的是，今天将从函数（方法）开始进一步的学习
-dictionary
dictionary
键-值（key-value）存储，具有极快的查找速度。为什么反复提起查询速度，因为如果你一个用list只是为了获取里面X元素内容的话性能是相对比较查的，极力推荐“字典”，字典也在第三片文章中有列出，但是这里还是再丰富下他的一些常用方法。
如何获检索dic内的值
dic={'wjj':185,'wmm':175}
print('第6行检索dictionary',dic['wjj'])
第6行检索dictionary 185
判断某个key是否存在于字典中
print('第8行，判断某个key是否在字典里','wdd' in dic)
第8行，判断某个key是否在字典里 False（存在为True，不存在为False）
也可以使用get的方法，并且可以指定返回值
print('第10行，如果没get到就返回自己赋予的值',dic.get('wj1j',3))
第10行，如果没get到就返回自己赋予的值 3
print('第11行，如果没get到就返回None',dic.get('wj1j'))
第11行，如果没get到就返回None None
如何添加某个键值对？
dic.setdefault('wgg',102)
{'wjj': 185, 'wmm': 175, 'wgg': 102}
如何移除某个键值对？
dic.pop('wmm')
print('第16行移除wmm后的效果',dic)
第16行移除wmm后的效果 {'wjj': 185, 'wgg': 102}
和list比较，dict有以下几个特点：
查找和插入的速度极快，不会随着key的增加而增加；
需要占用大量的内存，内存浪费多。
而list相反：
查找和插入的时间随着元素的增加而增加；
占用空间小，浪费内存很少。
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key，类似于list和dict的结合体。
如何创建set？
再次说明，set会自动去重
sets=set([1,1,1,3,6,3])
print('第20行 创建set,重复部分会被去除',sets)
第20行 创建set,重复部分会被去除 {1, 3, 6}
如何向set里添加元素？
再次说明：set是无序的
sets.add('12')
运行第一次结果：
第23行 {1, 3, 6, '12'}
运行多次结果：
第23行 {1, 3, '12', 6}
如何删除某一个元素？
set的remove删除的是以某个键为参数，而非下标
sets.remove(1)
print('第26行',sets)
第26行 {3, '12', 6}
什么是函数？
“函数”是从英文function翻译过来的，其实，function在英文中的意思即是“函数”，也是“功能”。从本质意义上来说，函数就是用来完成一定功能的。这样对函数的概念就很好理解了，所谓函数名就是给该功能起个名字，如果该功能是用来实现数学运算的，就是数学函数。
按照OOP的理论通俗的说，万物皆对象，对象有他的属性和方法。
如，人：身高，体重，长相 等等等都是他的属性。穿增高鞋，使他变高了，这个行为就是他的方法。
Python有许多大妞们已经写好的方法，这里贴一下，以后肯定用的到：
其实我们常用的 print()也是Python给我们写好的方法，不是么？
列举下SDK内写好的函数：
print('第29行 打印最大值',max(1,21,2,3))
print('第30行 绝对值',abs(-10),abs(100))
print('第31行 遍历是否都为真',all([True,True,True]),all([True,False,True]),all([3&2,True,True]))
print('第31行 遍历部分是否为真',any([True,True,True]),any([True,False,True]),any([3&2,True,True]))
第29行 打印最大值 21
第30行 绝对值 10 100
第31行 遍历是否都为真 True False True
第31行 遍历部分是否为真 True True True
数据类型转换
数据类型转换是我们碰到常有的事，例如：用户input一个价格为’123’字符串进来，我们需要把他转成整型或者浮点型才可以进行操作。
如何在Python中判断食神恶魔数据类型的？
print(isinstance(12,str))
简单的数据类型的转换
类型转换,bool 除了0 别的值返回都是 True
print('第35 打印字符串转数字',int('123'))
print('第36 各种类型转换',str(100)+'你好',float('10.34'),int(17.3124), bool(1))
第35 打印字符串转数字 123
第36 各种类型转换 100你好 10.34 17 True
函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：
print('第41行 函数赋值',a(-1,2，3))
第41行 函数赋值 3
在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。
一般格式：
函数名（参数列表）：
def strToInt(str):
intValue=int(str)
return intValue
print('第47行 打印有返回值的自定义函数',strToInt('10086'))
第47行 打印有返回值的自定义函数 10086
如果我的函数没有返回值那怎么办？那没有返回值的函数实质返回了什么？
如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。
def intToBool(intVBal):
print('第52行转数据类型',bool(intVBal))
intToBool(intVBal)
print('第55行 显示返回值',intToBool(intVBal))
第52行转数据类型 True
第52行转数据类型 True
第55行 显示返回值 None
调用函数时，如果参数个数不对，Python解释器会自动检查出来，并抛出TypeError。
但是如果参数类型不对，Python解释器就无法帮我们检查。
但是我们可以先检测出问题，然后手动的抛出异常
def wjj(x):
if not isinstance(x, (int, float)):
raise TypeError('bad type')
if x &= 0:
& wjj('A')
Traceback (most recent call last):
File "&stdin&", line 1, in &module&
File "&stdin&", line 3, in wjj
TypeError: bad type
Python的函数可以返回多个值吗？
可以，看例子
def reMoreVal(x,y):
return x,y
print('第70行 返回多个值',reMoreVal(1,'a'))
第70行 返回多个值 (1, 'a')
Python的函数返回多值其实就是返回一个tuple。
addAll=lambda arg1,arg2,arg3:arg1+arg2+arg3
print(‘第93行打印他们的合’,addAll(2,3,4))
函数参数其实也就是我们传入函数的值，有些函数没有参数，有些函数有一个参数或者多个参数，甚至可以传入None
下面例子就是刚才的2个返回值的函数，他也传入了两个值
def reMoreVal(x,y):
return x,y
那么问题来了，如果我一个方法有好多个参数，但是有些参数是可选项怎么办？
可以使用，默认参数
def printInfo( name, age = 35 ):
print("Name: ", name)
print("Age ", age)
printInfo( age=50, name="miki" )
printInfo( name="miki" )
默认参数降低了函数调用的难度，而一旦需要更复杂的调用时，又可以传递更多的参数来实现。无论是简单调用还是复杂调用，函数只需要定义一个。
使用默认参数必须以name=”miki” 一般的键值对的形式传入
如果，我传入的参数的数值，我自己都不知道怎么办，如传入一个list,tuple等？
可以用可变参数
def printMore(value,*more):
print(value)
for val in more:
print(val,end=' ')
printMore('aaa',1,2,3)
*more就是代表着我们那个不确定值的参数
传入a=[1,2,3]和1,2,3为同一效果
除了传入可变参数之外还可以传入关键字参数，关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict
def people(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)
people('Bob', 35, city='ShangHai')
name: Bob age: 35 other: {'city': 'ShangHai'}
如果要对这些关键字参数进行限制，就要用命名关键字参数
如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：
*后面的参数被视为命名关键字参数。
def people(name, age, *, city, job,gender):
print(name, age, city, job,gender)
命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错
但是如果命名关键字参数有默认值，调用时，可不传入参数
def people(name, age, *, city='Beijing', job):
print(name, age, city, job)
people('wjj', 24, job='teacher')
wjj 24 Beijing teacher
Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。
默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！
要注意定义可变参数和关键字参数的语法：
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict。
使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。
命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。
定义命名的关键字参数不要忘了写分隔符*，否则定义的将是位置参数。
跟以前一样，今天的示例代码已经传到git,运行如下：
源码地址：
麻烦点个赞，谢谢
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：728849次
积分：9678
积分：9678
排名：第1998名
原创：207篇
评论：920条
阅读：1163
文章：15篇
阅读：40587
文章：13篇
阅读：60507
文章：32篇
阅读：161868
文章：11篇
阅读：20473
文章：27篇
阅读：86021
文章：34篇
阅读：136961
(1)(1)(4)(2)(4)(2)(3)(7)(2)(3)(4)(4)(4)(8)(9)(6)(9)(13)(18)(14)(16)(16)(9)(5)(21)(26)(4)(1)(2)在 SegmentFault，解决技术问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
一线的工程师、著名开源项目的作者们，都在这里：
获取验证码
已有账号？
问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
S0=['S1','S2','S3']
def du(S0,P):
for i in range(len(S0)):
def d(S0[i]):
for n in range(len(P)):
if S0[i] in P[n]:
if d(S0[i])==0:
这里我想以 S0[i] 作为 d() 的参数，请问怎样可以实现以带下标的 list 作为函数参数? 或者有什么可以替代的方法？。
这个 d() 函数是要对 S0 中的每个元素进行分析的，我是想做一个简单的多边形拓扑关系的程序，要计算每条边（也就是 S0[i] ）的度，当度大于 2 时把这条边从 S0 里删掉。
这里用 range 而不是直接 for i in list 是因为在另一个list中还要用到相同的下标位置，然后 P 也用 range 是因为 P 里边还有 list。
好像按@yooz_hardy所说的用 enumerate 可以解决我的问题了，还有什么更好的方法或者优化建议欢迎指出。
现在下标的问题已经弄清楚了，但是有关我这个多边形拓扑关系建立的作业又有了别的问题：
A=['S3','S2','S1']
B=['S4','S6','S1']
C=['S2','S5','S4']
D=['S3','S6','S5']
N=[A,B,C,D]
#节点表，每个点记录顺时针方向排序的弧段
N0=['A','B','C','D']
#节点的字符表
S1=['A','B']
S2=['C','A']
S3=['D','A']
S4=['B','C']
S5=['C','D']
S6=['B','D']
S=[S1,S2,S3,S4,S5,S6]
#弧段表，每个弧段含有起始点和终点
S0=['S1','S2','S3','S4','S5','S6']
#弧段的字符表
def du(Si,P):
#定义弧段的‘度’，弧段属于一个多边形度就加一
for Pi in P:
if Si in Pi:
for i,Si in enumerate(S0):
for j,Nj in enumerate(N0):
if du(Si,P)==1:
#如果某弧段度等于1，将其从弧段表中删去
S0.remove(Si)
S.remove(S[i])
elif du(Si,P)==2:
#如果某弧段度等于2，将其从节点的弧段排序中删去
N[j].remove(Si)
#建立当前多边形
Ns=S[i][0]
Nc=S[i][1]
while Ns != Nc:
k=N0.index(Nc)
p=N[k].index(Sc)
#寻找当前点字符对应的节点，并在结点表中找到当前边位置
#当前边在表中下一条边的位置
if p1 & len(N[k]):
Sc=N[k][p1]
#把下一条边设为当前边
Pc.append(Sc)
#把新的当前边加入多边形中
n=S0.index(Sc)
Nc=S[n][1]
P.append(Pc)
#起点终点重合时将当前多边形放入多边形组中
问题：1.忽略了左多边形和右多边形，左多边形的新当前点为S[n][1]，右多边形新当前点为S[n][0]，这个可以先做个if看原本的当前点在新的当前弧中的位置，再确定是左还是右2.但是多边形组'P'的结构不知道怎么设置比较好，如果在每个多边形里再分L,R两个分组会不会太复杂（起始边可以默认放在左多边形里）3.节点表和弧段表每个都有对应的字符表，下边运算的时候还要找相应位置进行处理，挺麻烦，有没有什么函数直接把list的子集名变为字符？或者有什么更好的结构？
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
变量名看得有点懵
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
根據目前現有的資訊，下面可能是你可以參考的寫法:
def d(s_item, P):
for p_item in P:
if s_item in p_item:
S0=['S1','S2','S3']
# 處理 S0 中的每一個元素
for s_item in S0:
if d(s_item, P)==0:
# do something...
elif d(s_item, P)==...
# do something...
其他幾位大大已經給了滿多有用的建議，我有另外一個建議是，變數在取名的時候盡量取有意義的名字，這樣看 code 的人會比較快理解你的意思。
P.S. 看你一開始的問題，發現你可能對於 Python 的 function 定義，呼叫 和參數等不是很熟悉，建議一定要趁此機會搞懂，若有任何自己覺得不清楚的地方，可以在這裡盡量問清楚，大家會幫助你的，祝好運!
分享到微博？
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
我要该，理由是：Python list操作用法总结 - CSDN博客
Python list操作用法总结
这篇文章主要介绍了Python list操作用法,以实例形式较为详细的总结分析了Python中list的各种常见函数的功能与使用方法,需要的朋友可以参考下
本文实例讲述了Python list操作用法。分享给大家供大家参考，具体如下：
List是python中的基本数据结构之一，和Java中的ArrayList有些类似，支持动态的元素的增加。list还支持不同类型的元素在一个列表中，List is an Object。
最基本的创建一个列表的方法
myList = ['a','b','c']
Python list常见操作如下：
sample_list = ['a',1,('a','b')]
Python 列表操作
sample_list = ['a','b',0,1,3]
得到列表中的某一个值
value_start = sample_list[0]
end_value = sample_list[-1]
删除列表的第一个值
del sample_list[0]
在列表中插入一个值
sample_list[0:0] = ['sample value']
得到列表的长度
list_length = len(sample_list)
for element in sample_list:
print(element)
Python 列表高级操作/技巧
产生一个数值递增列表
num_inc_list = range(30)
#will return a list [0,1,2,...,29]
用某个固定值初始化列表
initial_value = 0
list_length = 5
sample_list = [ initial_value for i in range(10)]
sample_list = [initial_value]*list_length
# sample_list ==[0,0,0,0,0]
附：python内置类型
1、list：列表（即动态数组，C++标准库的vector，但可含不同类型的元素于一个list中）
a = [&I&,&you&,&he&,&she&] #元素可为任何类型。
下标：按下标读写，就当作数组处理
以0开始，有负下标的使用
0第一个元素，-1最后一个元素，
-len第一个元 素，len-1最后一个元素
取list的元素数量
len(list)&& #list的长度。实际该方法是调用了此对象的__len__(self)方法。
创建连续的list
L = range(1,5)
#即 L=[1,2,3,4],不含最后一个元素
L = range(1, 10, 2) #即 L=[1, 3, 5, 7, 9]
list的方法
L.append(var)
L.insert(index,var)
L.pop(var)
#返回最后一个元素，并从list中删除之
L.remove(var)
#删除第一次出现的该元素
L.count(var)
#该元素在列表中出现的个数
L.index(var)
#该元素的位置,无则抛异常
L.extend(list) #追加list，即合并list到L上
L.reverse()
list 操作符:,+,*，关键字del
#片段操作符，用于子list的提取
[1,2]+[3,4] #为[1,2,3,4]。同extend()
#为[2,2,2,2]
#删除指定下标的元素
del L[1:3] #删除指定下标范围的元素
list的复制
#L1为L的别名，用C来说就是指针地址相同，对L1操作即对L操作。函数参数就是这样传递的
#L1为L的克隆，即另一个拷贝。
list comprehension
&& [ &expr1& for k in L if &expr2& ]
2、dictionary： 字典（即C++标准库的map）
dict = {'ob1':'computer', 'ob2':'mouse', 'ob3':'printer'}
每一个元素是pair，包含key、value两部分。key是Integer或string类型，value 是任意类型。
键是唯一的，字典只认最后一个赋的键值。
dictionary的方法
D.get(key, 0)
#同dict[key]，多了个没有则返回缺省值，0。[]没有则抛异常
D.has_key(key)
#有该键返回TRUE，否则FALSE
#返回字典键的列表
D.values()
D.update(dict2)
#增加合并字典
D.popitem()
#得到一个pair，并从字典中删除它。已空则抛异常
#清空字典，同del dict
D.cmp(dict1,dict2) #比较字典，(优先级为元素个数、键大小、键值大小)
#第一个大返回1，小返回-1，一样返回0
dictionary的复制
dict1 = dict
dict2=dict.copy()
#克隆，即另一个拷贝。
3、tuple：元组（即常量数组）
tuple = ('a', 'b', 'c', 'd', 'e')
可以用list的 [],:操作符提取元素。就是不能直接修改元素。
4、string： 字符串（即不能修改的字符list）
str = &Hello My friend&
字符串是一个整 体。如果你想直接修改字符串的某一部分，是不可能的。但我们能够读出字符串的某一部分。
子字符串的提取
字符串包含 判断操作符：in，not in
&He& in str
&she& not in str
string模块，还提供了很多方法，如
S.find(substring, [start [,end]]) #可指范围查找子串，返回索引值，否则返回-1
S.rfind(substring,[start [,end]]) #反向查找
S.index(substring,[start [,end]]) #同find，只是找不到产生ValueError异常
S.rindex(substring,[start [,end]])#同上反向查找
S.count(substring,[start [,end]]) #返回找到子串的个数
S.lowercase()
S.capitalize()
#首字母大写
S.swapcase()
#大小写互换
S.split(str, ' ')
#将string转list，以空格切分
S.join(list, ' ')
#将list转string，以空格连接
处理字符串的内置函数
cmp(&my friend&, str)
#字符串比较。第一个大，返回1
max('abcxyz')
#寻找字符串中最大的字符
min('abcxyz')
#寻找字符串中最小的字符
string的转换
oat(str) #变成浮点数，float(&1e-1&) 结果为0.1
#变成整型， int(&12&) 结果为12
int(str,base)
#变成base进制整型数，int(&11&,2) 结果为2
#变成长整型，
long(str,base) #变成base进制长整型，
字符串的格式化（注意其转义字符，大多如C语言的，略）
str_format % (参数列表) #参数列表是以tuple的形式定义的，即不可运行中改变
&&&print &&%s's height is %dcm& % (&My brother&, 180)
&&&&&&&&& #结果显示为 My brother's height is 180cm
list 和 tuple 的相互转化
在python中list也是对象，所以他也有方法和属性，在ptython解释器中 使用help(list)可以查看其文档，部分开放方法如下：
这里以一个实例代码介绍这些方法的具体用法：
# coding=utf-8
# Filename : list.py
# 创建一个list方式
heatList = ['wade','james','bosh','haslem']
tableList = list('123') #list方法接受一个iterable的参数
print 'Miami heat has ',len(heatList),' NBA Stars , they are:'
#遍历list中的元素
for player in heatList:
print player,
#向list添加元素
heatList.append('allen') #方式一：向list结尾添加 参数object
print '\nAfter allen join the team ,they are: '
print heatList
heatList.insert(4,'lewis') #方式二：插入一个元素 参数一：index位置 参数二：object
print 'After lewis join the team, they are:'
print heatList
heatList.extend(tableList) #方式三：扩展列表，参数：iterable参数
print 'After extend a table list,now they are :'
print heatList
#从list删除元素
heatList.remove('1')
#删除方式一：参数object 如有重复元素，只会删除最靠前的
print& Remove '1' ..now '1' is gone\n&,heatList
heatList.pop()
#删除方式二：pop 可选参数index删除指定位置的元素 默认为最后一个元素
print &Pop the last element '3'\n&,heatList
del heatList[6] #删除方式三：可以删除制定元素或者列表切片
print &del '3' at the index 6\n&,heatList
#统计方法 count 参数：具体元素的值
print 'james apears ',heatList.count('wade'),' times'
#in 和 not in
print 'wade in list ? ',('wade' in heatList)
print 'wade not in list ? ',('wade' not in heatList)
#定位 index方法：参数：具体元素的值 可选参数：切片范围
print 'allen in the list ? ',heatList.index('allen')
#下一行代码会报错，因为allen不在前三名里
#print 'allen in the fisrt 3 player ? ',heatList.index('allen',0,3)
#排序和反转代码
print 'When the list is reversed : '
heatList.reverse()
print heatList
print 'When the list is sorted: '
heatList.sort() #sort有三个默认参数 cmp=None,key=None,reverse=False 因此可以制定排序参数以后再讲
print heatList
#list 的分片[start:end] 分片中不包含end位置的元素
print 'elements from 2nd to 3rd ' , heatList[1:3]
希望本文所述对大家Python程序设计有所帮助。
Python求两个list的差集、交集与并集的方法
这篇文章主要介绍了Python求两个list的差集、交集与并集的方法,是Python集合数组操作中常用的技巧,需要的朋友可以参考下
本文实例讲述了Python求两个list的差集、交集与并集的方法。分享给大家供大家参考。具体如下：
list就是指两个数组之间的差集,交集,并集了，这个小学数学时就学过的东西，下面就以实例形式对此加以分析。
一.两个list差集
如有下面两个数组：
a = [1,2,3]
想要的结果是[1]
下面记录一下三种实现方式：
1. 正常的方式
for i in a:
&&& if i not in b:
&&&&&&& ret.append(i)
ret = [ i for i in a if i not in b ]
ret = list(set(a) ^ set(b))
个人更喜欢第三种实现方式
二. 获取两个list 的并集
print list(set(a).union(set(b)))
三. 获取两个 list 的差集
print list(set(b).difference(set(a))) # b中有而a中没有的
Python中列表(list)操作方法汇总
本文实例汇总了Python中关于列表的常用操作方法，供大家参考借鉴。具体方法如下：
一、Python创建列表：
sample_list = ['a',1,('a','b')]
二、Python 列表操作：
假设有如下列表：
sample_list = ['a','b',0,1,3]
1.得到列表中的某一个值：
value_start = sample_list[0]
end_value = sample_list[-1]
2.删除列表的第一个值：
del sample_list[0]
3.在列表中插入一个值：
sample_list[0:0] = ['sample value']
4.得到列表的长度：
list_length = len(sample_list)
5.列表遍历：
for element in sample_list:
print(element)
三、Python 列表高级操作/技巧
1.产生一个数值递增列表：
num_inc_list = range(30)
#will return a list [0,1,2,...,29]
2.用某个固定值初始化列表：
initial_value = 0
list_length = 5
sample_list = [ initial_value for i in range(10)]
sample_list = [initial_value]*list_length
# sample_list ==[0,0,0,0,0]
读者还可以在此基础上继续搜集关于Python列表操作的其他方法，进一步巩固及加深对Python列表操作的认识。
python list 合并连接字符串的方法
python 列表合并字符串，我们一般会用到字符串的join方法来操作。下面通过代码的形式，详细的说下list怎么拼成字符串？
比如下面一个list
binfo = ['lao','wang','python']
我们通过help方法得知，可以用string的join方法来解决。
下面我们通过空格来连接3个单词：
content = & &.join(binfo)
print content
python中对list去重的多种方法
这篇文章主要介绍了python中对list去重的多种方法,本文去重的前提是要保证顺序不变,本文给出了多种实现方法,需要的朋友可以参考下
今天遇到一个问题，在同事随意的提示下，用了 itertools.groupby 这个函数。不过这个东西最终还是没用上。
问题就是对一个list中的新闻id进行去重，去重之后要保证顺序不变。
最简单的思路就是：
ids = [1,2,3,3,4,2,3,4,5,6,1]
news_ids = []
for id in ids:
&&& if id not in news_ids:
&&&&&&& news_ids.append(id)
print news_ids
这样也可行，但是看起来不够爽。
另外一个解决方案就是用set：
ids = [1,4,3,3,4,2,3,4,5,6,1]
ids = list(set(ids))
这样的结果是没有保持原来的顺序。
按照索引再次排序
最后通过这种方式解决：
ids = [1,4,3,3,4,2,3,4,5,6,1]
news_ids = list(set(ids))
news_ids.sort(ids.index)
使用itertools.grouby
文章一开始就提到itertools.grouby, 如果不考虑列表顺序的话可用这个：
ids = [1,4,3,3,4,2,3,4,5,6,1]
ids.sort()
it = itertools.groupby(ids)
for k, g in it:
&&& print k
关于itertools.groupby的原理可以看这里：
网友补充：用reduce
网友reatlk留言给了另外的解决方案。我补充并解释到这里：
In [5]: ids = [1,4,3,3,4,2,3,4,5,6,1]
In [6]: func = lambda x,y:x if y in x else x + [y]
In [7]: reduce(func, [[], ] + ids)
Out[7]: [1, 4, 3, 2, 5, 6]
上面是我在ipython中运行的代码，其中的 lambda x,y:x if y in x else x + [y] 等价于 lambda x,y: y in x and x or x+[y] 。
思路其实就是先把ids变为[[], 1,4,3,......] ,然后在利用reduce的特性。reduce解释参看这里：
Python 列表(List)操作方法详解
这篇文章主要介绍了Python中列表(List)的详解操作方法,包含创建、访问、更新、删除、其它操作等,需要的朋友可以参考下
列表是Python中最基本的数据结构，列表是最常用的Python数据类型，列表的数据项不需要具有相同的类型。列表中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
Python有6个序列的内置类型，但最常见的是列表和元组。序列都可以进行的操作包括索引，切片，加，乘，检查成员。此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
一、创建一个列表
只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：
list1 = ['physics', 'chemistry', ];
list2 = [1, 2, 3, 4, 5 ];
list3 = [&a&, &b&, &c&, &d&];
与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。
二、访问列表中的值
使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：
#!/usr/bin/python
list1 = ['physics', 'chemistry', ];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
print &list1[0]: &, list1[0]
print &list2[1:5]: &, list2[1:5]
以上实例输出结果：
list1[0]:& physics
list2[1:5]:& [2, 3, 4, 5]
三、更新列表
你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示：
#!/usr/bin/python
list = ['physics', 'chemistry', ];
print &Value available at index 2 : &
print list[2];
list[2] = 2001;
print &New value available at index 2 : &
print list[2];
以上实例输出结果：
Value available at index 2 :
New value available at index 2 :
四、删除列表元素
可以使用 del 语句来删除列表的的元素，如下实例：
#!/usr/bin/python
list1 = ['physics', 'chemistry', ];
print list1;
del list1[2];
print &After deleting value at index 2 : &
print list1;
以上实例输出结果：
['physics', 'chemistry', ]
After deleting value at index 2 :
['physics', 'chemistry', 2000]
五、Python列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
如下所示：&
Python 表达式
len([1, 2, 3])
[1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
['Hi!'] * 4
['Hi!', 'Hi!', 'Hi!', 'Hi!']
3 in [1, 2, 3]
元素是否存在于列表中
for x in [1, 2, 3]: print x,
六、Python列表截取
Python的列表截取与字符串操作类型，如下所示：
L = ['spam', 'Spam', 'SPAM!']
Python 表达式
读取列表中第三个元素
读取列表中倒数第二个元素
['Spam', 'SPAM!']
从第二个元素开始截取列表
七、Python列表操作的函数和方法
列表操作包含以下函数:
1、cmp(list1, list2)：比较两个列表的元素&
2、len(list)：列表元素个数&
3、max(list)：返回列表元素最大值&
4、min(list)：返回列表元素最小值&
5、list(seq)：将元组转换为列表&
列表操作包含以下方法:
1、list.append(obj)：在列表末尾添加新的对象
2、list.count(obj)：统计某个元素在列表中出现的次数
3、list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4、list.index(obj)：从列表中找出某个值第一个匹配项的索引位置
5、list.insert(index, obj)：将对象插入列表
6、list.pop(obj=list[-1])：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7、list.remove(obj)：移除列表中某个值的第一个匹配项
8、list.reverse()：反向列表中元素
9、list.sort([func])：对原列表进行排序
本文已收录于以下专栏：
相关文章推荐
1) Linux中主要有哪几种内核锁？
atomic原子锁，spin lock，信号量，读写锁，RCU，mutex
2) Linux中的用户模式和内核模式是什么含意？
User space即运行...
一、tuple也是一个class，是不可变的list类型，不可以增删改。
tup1 = ('physics', 'chemistry', );
tup2 = (1, ...
一、字典的基本操作
1、如何访问字典中的值？
adict[key] 形式返回键key对应的值value，如果key不在字典中会引发一个KeyError。
2、如何检查key是否在字典中？
a、has_...
NumPy是一个关于矩阵运算的库，熟悉Matlab的都应该清楚，这个库就是让python能够进行矩阵话的操作，而不用去写循环操作。下面对numpy中的操作进行总结。
numpy包含两种基本的数据类型...
Requests 是用Python语言编写，基于 urllib，采用 Apache2 Licensed 开源协议的 HTTP 库。它比 urllib 更加方便，可以节约我们大量的工作，完全满足 HTT...
一、tuple也是一个class，是不可变的list类型，不可以增删改。
tup1 = ('physics', 'chemistry', );
tup2 = (1, 2, ...
Python的list是最灵活的数据类型.
由一系列的放在方括号“[]”里的，且用逗号隔开的values组成。
列表内的values不要求是同种类型。
tuple是由一系列的...
今晚终于静下心来下写自己的BLOG关于.net framework 2.0推出“泛型”,学习体会了下当中LIST基本的用法及原理由于之前的版本中，集合CLASS A,CLASS B//实例化A，B类对...
四种类型list tuple dict set
列表list是一种有序的集合，可以随时添加和删除其中的元素
他的最新文章
讲师：宋宝华
讲师：何宇健
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)
