Python语法速查： 2. 列表、元组、字典、集合操作
本篇索引
（1）通用序列操作
（2）列表操作
（3）元组操作
（4）字典操作
（5）集合操作
（6）浅复制与深复制
（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 现在是两个完完全全不相干的列表
