可以包含不同类型的对象，可以增减元素，可以跟其他的列表结合或者把一个列表拆分，用[]来定义的 eg:aList=[123,'abc',4.56,['inner','list'],7-9j]
1.list(str):将str转换成list类型，str可以使字符串也可以是元组类型 2.aList.append('test'):追加元素到列表中去 3.del aList[1]:删除列表中下标为1的元素 del aList:删除整个列表 4.cmp(list1,list2):比较两个列表的大小 5.len(list):返回列表元素个数 6.sorted(list):使用字典序对列表中元素进行排序 7.reversed(list):倒置列表中的元素位置 8.list.count(obj):返回对象obj在list中出现的次数 9.list.extend(seq):把序列seq的内容添加到list中10.list.insert(index,obj):在索引量为index的地方插入obj对象 11.list.pop(index=-1):删除并返回指定位置的对象，默认是最后一个对象 12.list.remove(obj):从list中删除obj对象
可以包含不同类型的对象，但是是不可变的，不可以在增减元素，用()来定义 eg:aTuple=(123,'abc',4.56,['inner','list'],7-9j)
1.tuple(obj):将对象obj转换成tuple对象，obj可以是任意字符串或者列表 2.适用于列表的del,cmp,len,max,min方法也适用于tuple，但是由于元祖是不可变的，替换、添加、排序等不可实现
&键值对，用{}来定义 eg:aDict={'name':'cynthia','age':18}
1.dict1=dict((['x',1],['y',2])):dict()创建字典 2.dict1={}.fromkeys(('x','y'),-1):fromkeys()创建一个默认字典，字典中元素具有相同的值 3.dict1.keys():获取字典的键值列表 4.dict1.has_key('x'):判断字典中是否有&x'键值，返回bool型 5.dict.get(key,default):返回键值key的值，若是key不存在，返回default的值 6.dict.items():返回键值对列表值 7.dict.values():返回字典中所有值的列表 8.dict.update(dict2):将dict2的键值对列表添加到字典dict中去 9.dict.pop(key)：返回键值key的value 10.setdefault():类似get方法，能够获得给定key的value，此外setdefault还能在自动重不含有给定key的情况下设定相应的key-value 11.clear():清除字典中所有的项。原地操作，无返回(或说返回值为None） 12.copy():返回具有相同key-value的新字典，为浅复制(shallow copy)
set() 可变集合
frozenset()& 不可变集合
&方法（所有的集合方法）：s.issubset(t)& 如果s是t的子集,返回True，否则返回Falses.issuperset(t)& 如果s是t的超集,返回True，否则返回Falses.union(t)&& 返回一个新集合, 该集合是s和t的并集s.intersection(t)& 返回一个新集合, 该集合是s和t的交集s.difference(t)& 返回一个新集合, 该集合是s的成员, 但不是t的成员, 即返回s不同于t的元素s.symmetric_defference(t)& 返回所有s和t独有的(非共同拥有)元素集合s.copy()& 返回一个s的浅拷贝, 效率比工厂要好&方法（仅适用于可变集合）：以下方法参数必须是可哈希的s.update(t)：用t中的元素修改s，即s现在包含s或t的成员s.intersection_update(t)：s中的成员是共同属于s和t的元素s.difference_update(t)：s中的成员是属于s但不包含在t中的元素s.symmetric_difference_update(t)：s中的成员更新为那些包含在s或t中，但不是s和t共有的元素s.add(obj)：在集合s中添加对象objs.remove(obj)：从集合s中删除对象obj，如果obj不是集合s中的元素（obj not in s）,将引发keyError错误s.discard(obj)：如果obj是集合s中的元素，从集合s中删除对象objs.pop()：删除集合s中得任意一个对象，并返回它s.clear()：删除集合s中的所有元素
阅读(...) 评论()Python入门教程03列表,元祖,集合,字典
这是python入门教程的第三篇的内容，会具体介绍在Python中常用的四种数据结构，分别是列表,元祖,集合,字典，这些内容在之后是很常用的，所以要对每一种数据结构都要有所理解。
关于行间距的问题，我今天重新看了一下，好像代码那里行间距已经是最小了，没有办法再调整了，用手机看的话会有些大，如果要更好的阅读效果的话，可以点击阅读原文，在网站上浏览，效果会好一些。
python列表,元祖,集合,字典
这一篇我们会讲python中常用的四种数据结构,列表,元祖,集合,字典
· List []
· Tuple ()
· dict {key:value}
animals = [‘tiger’,’bear’,’lion’]
末尾增加-append
调用append方法向列表末尾添加元素
animals.append(‘horse’)
[‘tiger’,’bear’,’lion’,’horse’]
我们可以通过索引来访问列表中的每个元素,第一个元素的索引是０,最后一个元素的索引是-1
animals[0]
animals[-1]
我们可以使用len获取列表长度
len(animals)
任意位置添加–insert
上面我们讲了append是向列表的末尾进行添加，下面我们讲得insert可以向列表任意位置进行添加
animals.insert(1,’eagle’)
[‘tiger’, ‘eagle’, ‘bear’, ‘lion’, ‘horse’]
删除任意指定值
我们使用remove删除指定的值
animals.remove(‘tiger’)
[‘eagle’, ‘bear’, ‘lion’, ‘horse’]
注意:如果tiger出现多次，只有第一个tiger会被删除
按索引删除关键字
del animals[1]
[‘eagle’, ‘lion’, ‘horse’]
我们要记住列表是有序的，这个可以与其他数据结构进行比较，所以我们可以对有序的列表进行反转
animals.reverse()
[‘horse’, ‘lion’, ‘eagle’]
列表的合并
animals.extend([‘tiger’,’bear’])
[‘horse’, ‘lion’, ‘eagle’, ‘tiger’, ‘bear’]
animals.index(‘lion’)#返回索引
animals.count(‘lion’)#返回出现次数
‘lion’ inanimls#返回布尔类型
animals[0] = ‘horses’
[‘horses’, ‘lion’, ‘eagle’, ‘tiger’, ‘bear’]
pop返回列表的最后一个元素，在返回这个元素的同时也会删除这个元素,若传入一个参数pop(i)则将第i个元素弹出
for i inrange(len(animals)):
animal = animals.pop()
print(animal) #把整个列表倒叙输出
animals #此时列表是空的
animals.append(‘tiger’)#我们可以往里面添加值
[‘tiger’]
list1 = [1,2,3]
[1, 2, 3, 1, 2, 3, 1, 2, 3]#列表重复三次
元祖 Tuple
元祖是一种特殊的列表，不同点是元祖一旦创建就不能修改，上述修改列表内容的操作例如sort(),append()等对元祖都不在适用。
在编写程序的时候，元祖比列表更安全，如果是只读数据，尽可能使用元祖。
animals = (‘tiger’,’lion’,’bear’)
如果创建的元祖只有一个元素，需要在元素后面跟一个逗号
animals =(‘tiger’)
type(animals)#可以看到这里是str类型
animals =(‘tiger’,)
type(animals)
(‘tiger’,)
集合是一个无序不重复的数据集，对比列表，首先是无序的，不可以使用索引来进行访问，另一个特点是不能有重复的数据
集合支持数学上的一些运算,例如:union(并集),intersection(交集),difference(补集)
集合的创建
集合的创建使用set函数或者{},注意空集合的创建只能使用set函数，使用{}创建的是一个空的字典。
animals ={‘tiger’,’bear’,’lion’,’eagle’,’tiger’}
{‘bear’,’eagle’, ‘lion’, ‘tiger’} #可以看到重复的元素已经被去除
animals =set([‘tiger’,’bear’,’lion’,’eagle’,’tiger’])
type(animals)
{‘bear’, ‘eagle’, ‘lion’, ‘tiger’} #可以看到重复的元素已经被去除
查看元素是否在集合中
‘tiger’ in animals
‘tigers’in animals
‘tigers’not in animals #注意这里是 not in
集合的增删
animals.add(‘horse’)
{‘bear’, ‘eagle’, ‘horse’, ‘lion’, ‘tiger’}
animals.remove(‘horse’)
{‘bear’, ‘eagle’, ‘lion’, ‘tiger’}
集合子集的概念
set1 ={1,2,3}
set2 ={2,3}
set2 inset1
False #思考这是为什么
set2 &=set1
集合的运算
set1 = {1,2,3,4}
set2 ={3,4,5,6}
· | 操作，存在 set1 中或 set2 中的元素，等效于 union 操作
{1,2,3,4,5,6}
set1.union(set2)
{1,2,3,4,5,6}
· & 操作，返回即在 set1 又在 set2 的元素
· - 返回在 set1 不在 set2 的元素
· ^ 操作，返回只存在两个集合中的元素
字典是无序的键值对集合。字典中的每一个元素都是一个key和一个value的组合，key值在字典中必须是唯一的，因此很方便的从字典中使用key来获取其对应的value的值
字典的创建
animals = {1:’tiger’,2:’lion’,3:’horse’}
animals[1]
字典中value的获取
如果key不存在，那么dict[key]会抛出错误，有时候为了避免错误的出现，我们会使用get()函数来获取key对应的value，如果这个key不存在，那么就默认返回None
animals.get(1)
animals.get(4,’default’)
‘default’ #key不存在的时候，返回默认值
animals[4]=’eagle’ #只需要为字典中key进行赋值
{1: ‘tiger’, 2: ‘lion’, 3: ‘horse’, 4: ‘eagle’}
del animals[4]
{1: ‘tiger’, 2: ‘lion’, 3: ‘horse’}
获取keys和values
list(animals.keys())
list(animals.values())
[‘tiger’, ‘lion’, ‘horse’]
for valuein animals.values():
print(value)
赋值与浅拷贝与深拷贝
col = [‘red’,’blue’,’green’]
col_new =col
col_new.append(‘black’)
[‘red’, ‘blue’, ‘green’, ‘black’]
[‘red’, ‘blue’, ‘green’, ‘black’] #这个是赋值
id_row =[id(ele) for ele in col]
id_new =[id(ele) for ele in col_new]
我们可以看到上面两个是一样的
下面说一下深拷贝，浅拷感兴趣可以看一下
importcopy
col =[‘red’,’blue’,’green’]
col_new =copy.deepcopy(col)
col_new.append(‘black’)
[‘red’, ‘blue’, ‘green’, ‘black’]
[‘red’, ‘blue’, ‘green’]
大家要温故知新呀，Python学习是要自己上手实践的，多把代码敲一下。
责任编辑：
声明：该文观点仅代表作者本人，搜狐号系信息发布平台，搜狐仅提供信息存储空间服务。
今日搜狐热点Access denied | www.bkjia.com used Cloudflare to restrict access
Please enable cookies.
What happened?
The owner of this website (www.bkjia.com) has banned your access based on your browser's signature (42a3d15c652176be-ua98).Python基础-列表及列表解析小结 - Python - 伯乐在线
& Python基础-列表及列表解析小结
列表及列表解析
发现要到2013了，这两个月，离职入职，忙七忙八的，博文少了好多，笔记到是一大堆。
最近开始整理书签，微博收藏以及笔记梳理
采用删的方式，就是在evernote中新建一片，然后捞对应的笔记，一点点总结梳理，删除原有的笔记，发现这样效率高些（原来是在原有笔记之上直接修改总结，发现有用的信息其实并不多，效率有点低）
相对而言比较全和有用，会持续优化。
2013，发完这个系列的博客之后，将会整个博客迁移到自己的博客（刚开始写…），后续将同步吧，不过csdn可能会慢一些，自己blog会更自由些。后续将会是python&框架,linux后台开发，Go等等其他。
不扯了，看正题
以下是对列表笔记梳理的第一个版本，仅供参考
资料来源于书籍，网络，个人练习等等
#author:wklken
#version: 1.0
#author:wklken#version: 1.0#date: #history:&&2012-12-30&&created
列表是Python中使用最频繁的数据类型【可以说没有之一】
关键词：有序，可变
&一组有序项目的集合
&可变的数据类型【可进行增删改查】
&列表中可以包含任何数据类型，也可包含另一个列表【可任意组合嵌套】
&列表是以方括号“ []”包围的数据集合，不同成员以“ ,”分隔
&列表可通过序号访问其中成员
&一组有序项目的集合&可变的数据类型【可进行增删改查】&列表中可以包含任何数据类型，也可包含另一个列表【可任意组合嵌套】&列表是以方括号“ []”包围的数据集合，不同成员以“ ,”分隔&列表可通过序号访问其中成员
查看帮助 : help(list)
常见的列表操作
l = [1, 2, 3, 4]
l = [1, 'a', [2,3] ]
l = list('hello')
#得到 ['h', 'e', 'l', 'l', 'o']
l = list(range(4))
#[0, 1, 2, 3]
l = '1,2,3,4,5'.split(',')
#['1', '2', '3', '4', '5']
l = []&&&&#空列表l = [1, 2, 3, 4]l = [1, 'a', [2,3] ]l = list('hello')&&&& #得到 ['h', 'e', 'l', 'l', 'o']l = list(range(4))&& #[0, 1, 2, 3]l = '1,2,3,4,5'.split(',')&&#['1', '2', '3', '4', '5']
内建函数list(a_sequence) 可以将一个序列转为列表
通过下标访问
&&&l = [1, 2, 3, 4]
&&&l = [1, 2, 3, 4]&&&l[0]&&#1
A.新加入一个元素append
append方法添加。它在原列表末尾添加一个 item， item类型可以是任意的
l = [1, 2, 3]
l.append('hello')
#得到 [1, 2, 3, 'hello']
l.append(['hello'])
#得到 [1, 2, 3, 'hello', ['hello']]
l = [1, 2, 3]l.append('hello')&& #得到 [1, 2, 3, 'hello']l.append(['hello'])&& #得到 [1, 2, 3, 'hello', ['hello']]
B.插入一个元素insert
l1 = [1, 2, 3]
l1.insert(1,9)
#[1, 9, 2, 3]
l1 = [1, 2, 3]l1.insert(1,9)&&&&#[1, 9, 2, 3]
C.两个列表相加
l1 = [1, 2, 3]
l3 = l1 + [4, 5, 6]
#这种方式,l1不变，二者返回新的列表，当列表很长时，会消耗大量内存
l1 = [1, 2, 3]l3 = l1 + [4, 5, 6]&&#这种方式,l1不变，二者返回新的列表，当列表很长时，会消耗大量内存
第二种(必须接收一个参数，且是另一个列表)
l1.extend([4, 5, 6])
#直接扩增l1
l1.extend([4, 5, 6])&&#直接扩增l1
等价的做法
l1 += [4,5,6]
l1 += [4,5,6]
s.append(x)
same as s[len(s):len(s)] = [x] 在列表尾部追加单个对象x。使用多个参数会引起异常。
s.extend(x)
same as s[len(s):len(s)] = x将列表L中的表项添加到列表中。返回None。
s.insert(i, x)
same as s[i:i] = [x] 在索引为i的元素前插入对象x。如list.insert(0,x)在第一项前插入对象。返回None。
A.按item的索引或切片删除
l1 = [1, 2, 3, 4, 5, 6]
#得到[2, 3, 4, 5, 6]
del l1[0:2]
#得到[4, 5, 6]
l1 = [1, 2, 3, 4, 5, 6]del l1[0]&& #得到[2, 3, 4, 5, 6]del l1[0:2]&&#得到[4, 5, 6]
B.按item的值进行删除
l1 = [1,2,3,1,2]
l1.remove(1)
#得到[2,3,1,2]
l1 = [1,2,3,1,2]l1.remove(1)&&#得到[2,3,1,2]
若是remove对应值查无，将跑ValueError
C.删除某个位置并返回该位置值
pop若是不传位置参数，默认删除列表最后一个元素
l1 = [1, 2, 3, 4, 5]
a = l1.pop(1)
b = l1.pop()
l1 = [1, 2, 3, 4, 5]a = l1.pop(1)&& #a=2b = l1.pop()&& #a=5
s.pop([i])
same as x = s[i]; del s[i]; return x删除列表中索引为x的表项，并返回该表项的值。若未指定索引，pop返回列表最后一项。
s.remove(x)
same as del s[s.index(x)] 删除列表中匹配对象x的第一个元素。匹配元素时产生异常。返回None。
del s[i:j]
same as s[i:j] = []
对指定索引进行赋值操作
A.某个元素
l1 = [1, 2, 3, 4]
#[0,2,3,4]
l1 = [1, 2, 3, 4]l1[0] = 0&& #[0,2,3,4]
B.某一段元素
l1= [1,2,3,4]
l1[0:2] = [7,8,9]
#[7,8,9,3,4]
l1[:] = []
l1= [1,2,3,4]l1[0:2] = [7,8,9]&&#[7,8,9,3,4]&l1[:] = []&& #清空了
item i of s is replaced by x
s[i:j] = t
slice of s from i to j is replaced by the contents of the iterable t
5.切片和索引
A.索引l[i]
l1 = [1,2,3,4,5]
#5，负数的索引从尾部开始计数,最后一个元素为-1
l1 = [1,2,3,4,5]l1[0]&&#1l1[-1]&&#5，负数的索引从尾部开始计数,最后一个元素为-1
B.切片l[i:j:k]
i,j,k可选，冒号必须的 i不指定默认0，j不指定默认序列尾，k不指定默认1
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
取区间[i,j) ，左闭右开
#同上，可省略第一位
#[3, 4, 5, 6, 7, 8, 9, 10, 11]
#[3, 4, 5, 6, 7, 8, 9, 10]
#同l1，相当于复制一份
#步长2，[1, 3, 5, 7, 9, 11]
#[1, 3, 5, 7]
l1[7:0:-2]
#[8, 6, 4, 2]
注意步长为负、理解起来相当于从7到1，倒序步长2
12345678910
l1 =&&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]l1[0:2]&& #[1, 2],&& 取区间[i,j) ，左闭右开l1[:2]&&&& #同上，可省略第一位l1[2:]&&&& #[3, 4, 5, 6, 7, 8, 9, 10, 11]l1[2:-1]&& #[3, 4, 5, 6, 7, 8, 9, 10]l1[:]&&&&&& #同l1，相当于复制一份&l1[::2]&& #步长2，[1, 3, 5, 7, 9, 11]l1[0:7:2]&&#[1, 3, 5, 7]l1[7:0:-2]&&#[8, 6, 4, 2]&& 注意步长为负、理解起来相当于从7到1，倒序步长2
A.原地排list.sort()
l1 = [5,3,2,1,4,6]
#得到[1,2,3,4,5,6]
l1 = [5,3,2,1,4,6]l1.sort()&& #得到[1,2,3,4,5,6]&& 默认升序
sort可接受参数
cmp，比较函数，接受两个参数,小于时返回负，大于返回正，相等返回0
key，指定排序键
reverse，指定是否反序
cmp，比较函数，接受两个参数,小于时返回负，大于返回正，相等返回0key，指定排序键reverse，指定是否反序
列表的比较操作 , 隐式调用cmp 方法 , 比较规则是逐个扫描元素 , 进行比较, 如果可以比较 , 比较, 如果相等扫描下一个元素 , 如果不相等返回结果 , 如果两个元素类型不可以比较 , 就比较两个对象的 id()值 .. 如果一直相等 ,直到一个列表扫描结束 , 那么返回较长的列表较大
&&& l1 = [(1,99),(3,97),(2,98),(4,96)]
&&& l1.sort(key=lambda x: x[1])
[(4, 96), (3, 97), (2, 98), (1, 99)]
&&& l1.sort(key=lambda x: x[1], reverse=True)
[(1, 99), (2, 98), (3, 97), (4, 96)]
&&& l1 = [(1,99),(3,97),(2,98),(4,96)]&&& l1.sort(key=lambda x: x[1])&&& l1[(4, 96), (3, 97), (2, 98), (1, 99)]&&& l1.sort(key=lambda x: x[1], reverse=True)&&& l1[(1, 99), (2, 98), (3, 97), (4, 96)]
B.sorted函数
sorted(l1) #返回l1的有序序列，l1不变
sorted(l,key=str.lower,reverse=True)
sorted(l,key=str.lower,reverse=True)
l1.reverse()
l1.reverse()&&#l1反序
reversed(l1)
#返回一个iterator
reversed(l1)&& #返回一个iterator
l[::-1]可以达到一样的效果，但是这个是返回一个新的列表
sort sorted 区别
在原 list 上排序，不返回排序后的 list
sorted: 不改变原 list ，返回排序后的 list
sort:&&&& 在原 list 上排序，不返回排序后的 listsorted: 不改变原 list ，返回排序后的 list
s.reverse()
reverses the items of s in place颠倒列表元素的顺序。
s.sort([cmp[, key[, reverse]]])
sort the items of s in place对列表排序，返回none。bisect模块可用于排序列表项的添加和删除。
查找和统计
A.包含判断in ,not in
= [1, 2, 3, 4]
1 not in l1 #False
l1&&= [1, 2, 3, 4]1 in l1&&#True1 not in l1 #False
B.查询位置索引index
l1 = [1, 2, 3, 4]
l1.index(1)
&&& l1.index(5)
#特别注意，当值不存在于列表，用index将抛ValueError
Traceback (most recent call last):
File "&pyshell#44&", line 1, in &module&
l1.index(5)
ValueError: 5 is not in list
l1 = [1, 2, 3, 4]l1.index(1)&&&&#0&&& l1.index(5)&&&&#特别注意，当值不存在于列表，用index将抛ValueError&Traceback (most recent call last):&&File "&pyshell#44&", line 1, in &module&&&&&l1.index(5)ValueError: 5 is not in list
C.统计一个元素的出现次数
l1 = [1, 2, 3, 4, 1]
l1.count(1)
l1 = [1, 2, 3, 4, 1]l1.count(1)&&&&#2
s.count(x)
return number of i’s for which s[i] == x返回对象x在列表中出现的次数。
s.index(x[, i[, j]])
return smallest k such that s[k] == x and i &= k & j返回列表中匹配对象x的第一个列表项的索引。无匹配元素时产生异常。
l1 = [1, 2, 3, 4, 5]
for i in l1:
l1 = [1, 2, 3, 4, 5]for i in l1:&&&& print i
B.需要索引位置
l1 = [1, 2, 3, 4, 5]
for index,value in enumerate(l1):
print index,value
l1 = [1, 2, 3, 4, 5]for index,value in enumerate(l1):&&&& print index,value
9.其他操作
l1 = [1, 2]
#[1,2,1,2,1,2]
len(l)&& #列表长度l*3 重复l1 = [1, 2]l1*3&& #[1,2,1,2,1,2]
l1[:] = []
l1 = []l1[:] = []del l1[:]
l2 = l1[:]
l2 = l1[:]
注意：在操作list时，如果是涉及原地修改的操作，例如append,insert等，返回值是None
要防止出现这种语法 l1 = l1.append(‘a’) ，如果这样，你将得到None…….
定义和说明
&Python 的强大特性之一是其对 list 的解析，它提供一种紧凑的方法，可以通过对 list 中的每个元素应用一个函数，从而将一个 list 映射为另一个 list。
&列表解析，又叫列表推导式( list comprehension)
&列表解析比 for 更精简，运行更快，特别是对于较大的数据集合
&列表解析可以替代绝大多数需要用到 map和 filter的场合
&Python 的强大特性之一是其对 list 的解析，它提供一种紧凑的方法，可以通过对 list 中的每个元素应用一个函数，从而将一个 list 映射为另一个 list。&列表解析，又叫列表推导式( list comprehension)&列表解析比 for 更精简，运行更快，特别是对于较大的数据集合&列表解析可以替代绝大多数需要用到 map和 filter的场合
列表推导式提供了一个创建链表的简单途径，无需使用 map() ， filter() 以及 lambda 。以定义方式得到列表通常要比使用构造函数创建这些列表更清晰。每一个列表推导式包括在一个 for 语句之后的表达式，零或多个 for 或 if 语句。返回值是由 for 或 if 子句之后的表达式得到的元素组成的列表。如果想要得到一个元组，必须要加上括号。
基本列表解析
&&& [x for x in range(5)]
# [0, 1, 2, 3, 4]
l1 = [1,2,3,4]
[ x*2 for x in l1]
#[2,4,6,8]
&&& [x for x in range(5)]&& # [0, 1, 2, 3, 4]l1 = [1,2,3,4][ x*2 for x in l1]&& #[2,4,6,8]
[ '%s = %s' for (k, v) in a_map.items()]
[ '%s = %s' for (k, v) in a_map.items()]
&&& l1 = [1,2,3,4]
&&& l2 = [1,2,3,4]
&&& [x+y for x in l1 for y in l2]
[2, 3, 4, 5, 3, 4, 5, 6, 4, 5, 6, 7, 5, 6, 7, 8]
&&& l1 = [1,2,3,4]&&& l2 = [1,2,3,4]&&& [x+y for x in l1 for y in l2][2, 3, 4, 5, 3, 4, 5, 6, 4, 5, 6, 7, 5, 6, 7, 8]
可以调用函数
[ func(x) for x in l1]
#等价于map
[ func(x) for x in l1]&&#等价于map
注意，列表解析不会改变原有列表的值，会创建新的list
条件列表解析
[ x for x in range(100) if x%2 ==0 ]
[ x for x in range(100) if x%2 ==0 ]
嵌套列表解析
mat = [ [1, 2, 3],[4, 5, 6], [7, 8, 9]]
mat = [ [1, 2, 3],[4, 5, 6], [7, 8, 9]]
[ [row[i] for row in mat] for i in (0,1,2)] #[[1, 4, 7], [2, 5, 8], [3, 6, 9]]
[ [row[i] for row in mat] for i in (0,1,2)] #[[1, 4, 7], [2, 5, 8], [3, 6, 9]]
1.根据索引取元素时，需要进行边界检查 IndexError
切片取，不需要，超过边界不会异常
2.在迭代中修改列表
注意，不安全，不建议这么干
for i in l1[:]:
l1.insert()……
3.多个list合成一个
['a','b',.....],['a','b'.....]['a','b'.....]
['a','b',.....],['a','b'.....]['a','b'.....]
['a','b',.....,'a','b'.....'a','b'.....]
['a','b',.....,'a','b'.....'a','b'.....]
&&& sum ([[ 'a', 'b' ],['a' , 'b'],[ 'a' ,'b' ]], [])
['a' , 'b' , 'a', 'b' , 'a' , 'b']
&&& list (itertools .chain([ 'a' ,'b' ],[ 'a', 'b' ],['a' , 'b']))
['a' , 'b' , 'a', 'b' , 'a' , 'b']
&&& sum ([[ 'a', 'b' ],['a' , 'b'],[ 'a' ,'b' ]], [])['a' , 'b' , 'a', 'b' , 'a' , 'b']&&& list (itertools .chain([ 'a' ,'b' ],[ 'a', 'b' ],['a' , 'b']))['a' , 'b' , 'a', 'b' , 'a' , 'b']
4.关于堆栈和队列
通过上面的操作，可以发现，很轻易可以拿列表当做堆栈或者队列使用
当然，他们有自己的模块，可以查相关库
5.序列相关模块
array 一种受限制可变序列类型，要求所有元素必须是相同类型
copy 提供浅拷贝和深拷贝的能力
operator 包含函数调用形式的序列操作符，如 operator.concat(m,n) 相当于m+n
re 正则表达式
types 包含Python 支持的所有类型
collections 高性能容器数据类型
二维数组初始化陷阱
对一维数组，可以这么做
lst =[0]*3
lst =[0]*3
但是对二维数组，不成立
&&& lst_2d =[[0]*3]*3
&&& lst_2d
[[0,0,0],[0,0,0],[0,0,0]]
&&& lst_2d[0][0]=5
&&& lst_2d
[[5,0,0],[5,0,0],[5,0,0]]
&&& lst_2d =[[0]*3]*3&&& lst_2d[[0,0,0],[0,0,0],[0,0,0]]&&& lst_2d[0][0]=5&&& lst_2d[[5,0,0],[5,0,0],[5,0,0]]
二维数组，可以这么做
&&& lst_2d = [[0] * 3 for i in xrange(3)]
&&& lst_2d
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
&&& lst_2d[0][0] = 5
&&& lst_2d
[[5, 0, 0], [0, 0, 0], [0, 0, 0]]
&&& lst_2d = [[0] * 3 for i in xrange(3)]&&& lst_2d[[0, 0, 0], [0, 0, 0], [0, 0, 0]]&&& lst_2d[0][0] = 5&&& lst_2d[[5, 0, 0], [0, 0, 0], [0, 0, 0]]
Gighub: https://github.com/wklken
Blog: http://wklken.sinaapp.com/
打赏支持我写出更多好文章，谢谢！
打赏支持我写出更多好文章，谢谢！
任选一种支付方式
关于作者：
可能感兴趣的话题
关于 Python 频道
Python频道分享 Python 开发技术、相关的行业动态。
新浪微博：
推荐微信号
（加好友请注明来意）
– 好的话题、有启发的回复、值得信赖的圈子
– 分享和发现有价值的内容与观点
– 为IT单身男女服务的征婚传播平台
– 优秀的工具资源导航
– 翻译传播优秀的外文文章
– 国内外的精选文章
– UI,网页，交互和用户体验
– 专注iOS技术分享
– 专注Android技术分享
– JavaScript, HTML5, CSS
– 专注Java技术分享
– 专注Python技术分享
& 2018 伯乐在线