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 如今是兩個完徹底全不相干的列表

 

 

 

返回目錄