Python语法速查： 2. 列表、元组、字典、集合操做

返回目录

 

 （1）通用序列操做

“序列”表示索引为非负整数的有序对象集合，列表、元组、字符串都属于序列。区别在于：列表是可变的，而元组和字符串是不可变的。序列的通用操做他们均可以用。

操做或方法	简述	举例或说明
s[i]	返回序列第 i 个元素	-1为最后一个元素，-2为最后第二个元素，依此类推
s[i:j:k]	返回第 i 到 j-1 个元素的新序列，k为可选步长	切片规则详见下述
s1 + s2	操做符，将2个序列拼接生成一个新序列	(1,2) + ('a','b')   # 结果为 (1,2,'a','b') 'ab' + 'c'   # 结果为 'abc'
s * n	操做符，将序列s重复n次生成新序列	('a') * 3   # 结果为 ('a', 'a', 'a') 'py' * 3   # 结果为 'pypypy'
in / not in	操做符，检查一个值是否在序列中	'a' in 'abc'   # 结果为 True 'a' not in ['a','b']   # 结果为 False
s.index(x[, i[, j]])	返回序列中第一次出现x的索引值，i,j 为可选范围	'abc'.index('b')  # 结果为 1 'abc'.index('e')  # 找不到，引发ValueError错误
s.count(x)	返回序列中x出现的次数	'abab'.count('a')   # 结果为 2 'abab'.count('e')   # 结果为 0
len(s)	内置函数，返回s中元素个数	len('数123')   # 结果为 5（字符串中汉字算2个元素）

 

 

● s[i:j:k]

切片规则：

（1） 切片左数字必须小于右数字，不然输出为空

（2） 若 i 或 j 缺省，则表示向这个方向取到尽头

（3） 步长默认为1。若步长为负数，则表示从右向左方向取出元素，此时切片左数字必须大于右数字，不然输出为空。

举例：

>>> 'abcde'[1:3]  # 结果为 'bc'
>>> 'abcde'[3:1]  # 结果为 ''
>>> 'abcde'[:3]   # 结果为 'abc'
>>> 'abcde'[-2:]  # 结果为 'de' （含义为从倒数第2个元素开始取到最后一个元素）
>>> 'abcde'[1:-2]  # 结果为 'bc' （含义为从正索引第1个元素('b')取到倒数第2个元素的前一个元素('c')）
>>> 'abcde'[:]    # 结果为 'abcde' （含义为取出全部元素）
>>> 'abcde'[::-1]  # 结果为 'edcba' （含义为从右向左依次取出全部元素）
>>> 'abcde'[::-2]  # 结果为 'eca'
>>> 'abcde'[0:2:-1]  # 结果为 '' （当步长为负数时，切片左数字必须大于右数字，不然输出为空）
>>> 'abcde'[-1:-3:-1]  # 结果为 'ed'
>>> 'abcde'[1::-1]  # 结果为 'ba' （步长为负数表示从右向左取，左数字为1表示从'b'开始取，右数字为空表示向左取到尽头）

返回索引

 

 

 

 

 （2）列表操做

操做或方法	简述	举例或说明
简单操做
s[i] = v	元素赋值	[1,2,3][1]=20   # 结果为 [1,20,3]
s[i:j:k] = t	切片赋值	用法较灵活，详见下述
del s[i]	元素删除	del [1,2,3][1]   # 结果为 [1,3]
del s[i:j:k]	切片删除第 i 到 j-1 个元素，步长为k。切片规则见上。	a=[1,2,3,4,5] del a[1:3]    # 结果为 a=[1,4,5] 也可写成 a[1:3]=[]   # 结果同上
列表专用方法
list([iter])	内置函数，根据入参可迭代对象iter生成一个浅复制列表实例。若入参为字符串，则将其拆分红由个单字符组成的列表。	s=list()   # 生成一个空列表，也可写成 s=[] s=list([1,2,3])   # 生成一个浅复制新列表 s=list('abc')   # 结果为 ['a','b','c']
s.append(x)	将一个新元素x追加到列表末尾	[1,2,3].append(4)   # 结果为 [1,2,3,4]
s.extend(t)	将一个新列表t追加到列表末尾	[1,2,3].extend([4,5])   # 结果为 [1,2,3,4,5]
s.insert(i, x)	在索引 i 处插入元素x，若 i 超出索引范围，则元素x添加到最后。	[1,2,3].insert(-1,4)   # 结果为 [1,2,4,3] [1,2,3].insert(10,5)   # 结果为 [1,2,3,5]
s.pop([i])	返回索引 i 处的元素并从列表中移除它。若省略 i，则返回列表中最后一个元素并移除它。若 i 超出索引范围，则引起IndexError。	[1,2,3].pop(-2)   # 返回2，列表结果为 [1,3] [1,2,3].pop()     # 返回3，列表结果为 [1,2]
s.remove(x)	在列表中搜索x并移除第1个发现的x，若未发现x则引起ValueError。	[1,2,1,2].remove(2)   # 结果为 [1,1,2]
s.reverse()	颠倒列表中全部元素的位置顺序	[1,3,2,4].reverse()   # 结果为 [4,2,3,1]
s.sort(*, key=None, reverse=False)	对s中全部元素按自定义规则进行排序，返回值为空，不会生成新的列表	详见下述
s.index(x[, i[, j]])	返回序列中第一次出现x的索引值（通用序列方法已述，此处仅为索引方便）	详见上面通用序列方法
s.count(x)	返回序列中x出现的次数（通用序列方法已述，此处仅为索引方便）	详见上面通用序列方法

 

 

● s[i:j:k] = t

说明：

分片赋值能够使用与原列表不等长的列表进行赋值，这就使得其用法很是灵活。其赋值规则是：移除等号左边分片划定范围内的元素，并在此位置用等号右边新的列表中的元素替代。

举例：

>>>  [1,2,3,4,5][2:4] = [30,40]  # 结果为 [1,2,30,40,5]  （切片长度等于等号右边列表长度）
>>>  [1,2,3,4,5][2:4] = [30]  # 结果为 [1,2,30,5] （移除原列表中切片的2个元素，并用新的1个元素进行替换）
>>>  [1,2,3,4,5][2:4] = [30,31,32]  # 结果为 [1,2,30,31,32,4,5] （移除原列表中切片的2个元素，并用新的3个元素进行替换）
>>>  [1,2,3,4,5][2:4] = [] # 结果为 [1,2,5] （至关于将切片元素删除）
>>>  [1,2,3,4,5][2:2] = [10,11]  # 结果为 [1,2,10,11,3,4,5] （因为切片[1:1]切不到移除元素，故此句至关于在位置2插入等号右边的列表元素）

返回索引

 

 

 

● s.sort(*,key=None, reverse=False)

说明：

sort()方法会对原列表进行排序，返回值为空，不会生成新的列表。入参key能够指定一个函数对每一个将要被排序的元素进行预处理，使得某些本来不能比较大小的元素，也能进行大小排序（原理和上一篇内置函数sorted()相同）。reverse为True时表示逆向排序。

举例：

>>> [1,3,4,2].sort()  # 结果为 [1,2,3,4]
>>> [1,3,4,2].sort(reverse=True)  # 结果为 [4,3,2,1]
>>> [('b',2),('a',1)].sort(key=lambda x:x[1])  # 结果为 [('a',1),('b',2)]
>>> # 说明：上例中，使用匿名函数lambda对列表元素进行了预处理，将本来的元组('a',1)预处理为：取出元组中后一个元素（即：1），因此可以进行排序。

返回索引

 

 

 

 

 （3）元组操做

元组为不可变序列，故元组只能使用开头所述的通用序列方法，而上面列表的方法元组都不可用。

操做或方法	简述	举例或说明
tuple([iter])	内置函数，生成入参可迭代对象iter的一个浅复制元组实例。	t=tuple()   # 生成一个空元组，也可写成 t=() t=tuple([1,2,3])   # 生成 (1,2,3) t=tuple('abc')   # 生成 ('a','b','c')

 

 

 

 

 （4）字典操做

字典是“映射”类型，它是无序的，不能经过元素位置进行索引，只能经过键值进行索引。

操做或方法	简述	举例或说明
简单操做
d[k] = x	将已定义的字典d中键为k的值设为x，若k不存在，则创建k,v“键值对”	d = {} d['a']=1   # 结果为 d={'a':1}
del d[k]	从字典d中删除d[k]，若键k不存在，则引起KeyError错误	d={'a':1} del d['a']   # 结果为 d={}
k in d	若k是字典d中的键，则返回Tru，不然返回False	'a' in {'a':1}   # 结果为 True
字典专用方法
dict([m])	生成字典实例，有多种初始化方法，详见右例	d=dict()   # 生成一个空字典，同 d={} d=dict({'a':1})   # 浅复制生成字典，d={'a':1} d=dict([('a',1),('b',2)])   # 用元组列表生成字典，d={'a':1,'b':2} d=dict(a=1,b=2)   # 用入参变量名生成字典，d={'a':1,'b':2}
d.clear()	将字典内的全部内容清空	d.clear()   # 结果为 d={}
d.copy()	返回d的一个浅复制副本	d2=d.copy()   # d2为d的一个副本，并不指向d
dict.fromkeys(s [,v])	这是个类方法。建立返回一个新字典并将序列s中的全部元素做为新字典的键，这些键对应的值均为v；若缺省v，则这些值为None。	d=dict.fromkeys(['a','b']) # 结果为 d={'a':None, 'b':None}
d.get(k [,v])	返回d[k]，若找不到键k，则返回v；若找不到键k且未指定v，则返回None	{'a':1}.get('a')   # 结果为 1 {'a':1}.get('b',2)   # 结果为 2
d.items()	返回由d中的“键值对”元组组成的可迭代对象。	{'a':1,'b':2}.items() # 结果为 dict_items([('a',1),('b',2)])
d.keys()	返回由d中的键组成的可迭代对象。	{'a':1,'b':2}.keys() # 结果为 dict_keys(['a','b'])
d.values()	返回有d中的值组成的可迭代对象。	{'a':1,'b':2}.values()   # 结果为 dict_values([1,2])
d.pop(k [,default])	若是找到d[k]，则返回它，并从d中删除它；不然，若提供了default值，则返回这个值，若没有则引起KeyError错误	{'a':1}.pop('a')   # 返回值为 1 {'a':1}.pop('b',2)   # 返回值为 2
d.popitem()	从字典d中随机返回一个“键值对”元组，并把它从d中删除	d={'a':1,'b':2} d.popitem()   # 返回值为('b':2)
d.setdefault(k [,v])	若是找到d[k]，则返回它并没有视v；若没找到，则返回v，并将d[k]设为v	d={'a':1,'b':2} d.setdefault('c',3)   # 返回值为3，而且改变d #结果 d={'a':1,'b':2,'c':3}
d.update(b)	将入参字典b中全部的“键值对”添加到d中，若b与d中有键重复，则原d中的“键值对”被新值覆盖。	d={'a':1,'b':2} d.update({'b':20,'c':3}) # 结果为 d={'a':1,'b':20,'c':3}

 

 

 

 

 （5）集合操做

集合一样也是无序的，分为可变集合（set）和不可变集合（frozenset）两种，可变集合用大括号“{}”表示。

操做或方法	简述	举例或说明
通用集合操做
s.copy()	返回s的一个浅复制副本	s2=s.copy()  # s2为s的一个浅复制副本，并不指向s
s.issubset(t)	若是s是t的一个子集，则返回True	{1}.issubset({1,2})   # 结果为 True
s.issuperset(t)	若是s是t的一个超集，则返回True	{1,2}.issuperset{{1}}   # 结果为 True
s.union(t)	求s和t的并集	{1,2}.union({2,3})   # 结果为 {1,2,3}
s.intersection(t)	求s和t的交集	{1,2}.intersection({2,3})   # 结果为 {1,2,3}
s.isdisjoint(t)	若是s和t没有交集，则返回True	{1,2}.isdisjoint({3})   # 结果为 True
s.difference(t)	求差集s-t	{1,2,3}.difference({1,2})   # 结果为 {3}
s.symmetric_difference(t)	返回全部在s或t中，但又不一样时属于这两个集合中的项的集合（对称差集）	{1,2}.symmetric_difference({2,3}) # 结果为 {1,3}
可变集合专用方法
set([iter])	能够用任何可迭代对象来生成一个集合	s = set()   # 结果为 {}，效果同 s={} s = set([1,2])   # 结果为 {1,2} s = set('abc')   # 结果为 {'a','b','c'} s = set({'a':1})   # 结果为 {'a'}
s.clear()	删除集合s中的全部项	s.clear()   # 结果为 {}
s.add(x)	将x添加到集合s中，若x已在集合中，则无任何效果	{1,2}.add(3)   # 结果为 {1,2,3}
s.discard(x)	从s中删除成员x，若x不在集合中，则无任何效果	{1,2,3}.discard({3})   # 结果为 {1,2}
s.remove(x)	从s中删除成员x，若x不在集合中，则引起KeyError错误	{1,2}.remove({3})   # 结果引起KeyError错误
s.pop()	随机从s中返回一个元素，并将其从s中删除	{1,2,3}.pop()   # 返回值为2，结果为{1,3}
s.update(iter)	将iter中全部对象添加到s中，iter能够是任何可迭代对象	{1}.update([1,2,3])   # 结果为 {1,2,3}
s.intersection_update(t)	将s更新为：s与t的交集	{1,2}.intersection_update({2,3}) # 结果为 {2}
s.dirrerence_update(t)	从s中删除同时也在t中的项	{1,2,3}.difference_update({1}) # 结果为 {2,3}
s.symmetric_difference_update(t)	将s更新为：全部在s或t中，但又不一样时在这两个集合中的项（对称差集）	{1,2}.symmetric_difference_update({2,3}) # 结果为 {1,3}
不可变集合专用方法
frozenset([iter])	能够用任何可迭代对象来生成一个不可变集合	f = frozenset()   # 结果为 frozenset() f = frozenset([1])  # 结果为 frozenset({1})

 

 

 

 

 （6）浅复制与深复制

前面的list(), tuple(), dict(), set(), frosenset()在复制一个已有对象时，使用的都是“浅复制”，即：只有数字（整数/浮点数/布尔值/复数）是实打实复制一个新的数字，其余全部类型都是共享的（列表、字符串、对象等）。

a = [1,2,[3,4]]
b = list(a)
b.append(5)   # b新添加的值不影响a

# 可是若做如下修改，会影响a
b[2][0] = 6

# 结果：a = [1,2[6,4]]

 

而“深复制”将在建立新对象时，将递归地复制它所包含的全部对象

import copy
a = [1,2,[3,4]]
b = copy.deepcopy(a)
# b 和 a 如今是两个完彻底全不相干的列表

 

 

 

返回目录