目錄
python序列概述
列表
列表常用方法
列表的創建
列表元素的增加
列表元素的刪除
切片操作
列表排序
列表推導式
元組
元組的創建與刪除
序列解包
生成器推導式
字典
字典的創建與刪除
字典元素的讀取
字典元素的修改與添加
字典推導式
集合
集合的創建與刪除
集合運算
方法
說明
lst.append(x)
將元素x添加至列表lst尾部
lst.extend(L)
將列表L中所有元素添加至列表lst尾部
lst.insert(index, x)
在列表lst指定位置index處添加元素x，該位置後面的所有元素後移一個位置
lst.remove(x)
在列表lst中刪除首次出現的指定元素，該元素之後的所有元素前移一個位置
lst.pop([index])
刪除並返回列表lst中下標為index（默認為-1）的元素
lst.clear()
刪除列表lst中所有元素，但保留列表對象
lst.index(x)
返回列表lst中第一個值為x的元素的下標，若不存在值為x的元素則拋出異常
lst.count(x)
返回指定元素x在列表lst中的出現次數
lst.reverse()
對列表lst所有元素進行逆序
lst.sort(key=None, reverse=False)
對列表lst中的元素進行排序，key用來指定排序依據，reverse決定升序（False）還是降序（True）
lst.copy()
返回列表lst的淺復制
使用“=”直接將一個列表賦值給變量即可創建列表對象
>>> a_list = ['a', 'b', 'mpilgrim', 'z', 'example']
>>> a_list = [] #創建空列表
也可以使用list()函數將元組、range對象、字符串或其他類型的可迭代對象類型的數據轉換為列表。
>>> a_list = list((3,5,7,9,11))
>>> a_list
[3, 5, 7, 9, 11]
>>> list(range(1,10,2))
[1, 3, 5, 7, 9]
>>> list('hello world')
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
>>> x = list() #創建空列表
當不再使用時，使用del命令刪除整個列表。
（1）可以使用“+”運算符將元素添加到列表中。
>>> aList = [3,4,5]
>>> aList = aList + [7]
>>> aList
[3, 4, 5, 7]
嚴格意義上來講，這並不是真的為列表添加元素，而是創建了一個新列表，並將原列表中的元素和新元素依次復制到新列表的內存空間。由於涉及大量元素的復制，該操作速度較慢，在涉及大量元素添加時不建議使用該方法。
（2）使用列表對象的append()方法在當前列表尾部追加元素，原地修改列表，是真正意義上的在列表尾部添加元素，速度較快。
Python采用的是基於值的自動內存管理方式，當為對象修改值時，並不是真的直接修改變量的值，而是使變量指向新的值，這對於Python所有類型的變量都是一樣的。
>>> a = [1,2,3]
>>> id(a) #返回對象的內存地址
20230752
>>> a = [1,2]
>>> id(a)
20338208
列表中包含的是元素值的引用，而不是直接包含元素值。
如果是直接修改序列變量的值，則與Python普通變量的情況是一樣的
如果是通過下標來修改序列中元素的值或通過可變序列對象自身提供的方法來增加和刪除元素時，序列對象在內存中的起始地址是不變的，僅僅是被改變值的元素地址發生變化，也就是所謂的“原地操作”。
>>> a = [1, 2, 3]
>>> id(a)
2389572193096
>>> a.append(4)
>>> a.remove(3)
>>> a[0] = 5
>>> a
[5, 2, 4]
>>> id(a)
2389572193096（3）使用乘法來擴展列表對象，將列表與整數相乘，生成一個新列表，新列表是原列表中元素的重復。
>>> aList = [3,5,7]
>>> aList * 3
[3, 5, 7, 3, 5, 7, 3, 5, 7]
當使用*運算符將包含列表的列表重復並創建新列表時，並不是復制子列表值，而是復制已有元素的引用。因此，當修改其中一個值時，相應的引用也會被修改。
>>> x = [[None] * 2] * 3
>>> x
[[None, None], [None, None], [None, None]]
>>> x[0][0] = 5
>>> x
[[5, None], [5, None], [5, None]]
（1）使用del命令刪除列表中的指定位置上的元素。
>>> a_list = [3,5,7,9,11]
>>> del a_list[1]
>>> a_list
[3, 7, 9, 11]
（2）使用列表的pop()方法刪除並返回指定位置（默認為最後一個）上的元素，如果給定的索引超出了列表的范圍則拋出異常。
>>> a_list = list((3,5,7,9,11))
>>> a_list.pop()
11
>>> a_list
[3, 5, 7, 9]
>>> a_list.pop(1)
5
>>> a_list
[3, 7, 9]
（3）使用列表對象的remove()方法刪除首次出現的指定元素，如果列表中不存在要刪除的元素，則拋出異常。
>>> a_list = [3,5,7,9,7,11]
>>> a_list.remove(7)
>>> a_list
[3, 5, 9, 7, 11]
注意：
在刪除列表元素時，Python會自動對列表內存進行收縮並移動列表元素以保證所有元素之間沒有空隙，增加列表元素時也會自動擴展內存並對元素進行移動以保證元素之間沒有空隙。每當插入或刪除一個元素之後，該元素位置後面所有元素的索引就都改變了。
#正確代碼
>>> x = [1,2,1,2,1,1,1]
>>> for i in range(len(x)-1,-1,-1): #從後往前刪
if x[i]==1:
del x[i]
切片適用於列表、元組、字符串、range對象等類型，但作用於列表時功能最強大。可以使用切片來截取列表中的任何部分，得到一個新列表，也可以通過切片來修改和刪除列表中部分元素，甚至可以通過切片操作為列表對象增加元素。
切片使用2個冒號分隔的3個數字來完成：
第一個數字表示切片開始位置（默認為0）。
第二個數字表示切片截止（但不包含）位置（默認為列表長度）。
第三個數字表示切片的步長（默認為1），當步長省略時可以順便省略最後一個冒號。
>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[::] #返回包含所有元素的新列表
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[::-1] #逆序的所有元素
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
>>> aList[::2] #偶數位置，隔一個取一個
[3, 5, 7, 11, 15]
>>> aList[1::2] #奇數位置，隔一個取一個
[4, 6, 9, 13, 17]
>>> aList[3::] #從下標3開始的所有元素
[6, 7, 9, 11, 13, 15, 17]
>>> aList[3:6] #下標在[3, 6)之間的所有元素
[6, 7, 9]
>>> aList[0:100:1] #前100個元素，自動截斷
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[100:] #下標100之後的所有元素，自動截斷
[]
>>> aList[100] #直接使用下標訪問會發生越界
IndexError: list index out of range
可以使用切片來原地修改列表內容
>>> aList = [3, 5, 7]
>>> aList[len(aList):] = [9] #在尾部追加元素
>>> aList
[3, 5, 7, 9]
>>> aList[:3] = [1, 2, 3] #替換前3個元素
>>> aList
[1, 2, 3, 9]
>>> aList[:3] = [] #刪除前3個元素
>>> aList
[9]
>>> aList = list(range(10))
>>> aList
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> aList[::2] = [0]*5 #替換偶數位置上的元素
>>> aList
[0, 1, 0, 3, 0, 5, 0, 7, 0, 9]
>>> aList[::2] = [0]*3 #切片不連續，兩側元素個數必須一樣多
ValueError: attempt to assign sequence of size 3 to extended slice of size 5
使用del與切片結合來刪除列表元素
>>> aList = [3,5,7,9,11]
>>> del aList[:3] #刪除前3個元素
>>> aList
[9, 11]
>>> aList = [3,5,7,9,11]
>>> del aList[::2] #刪除偶數位置上的元素
>>> aList
[5, 9]
切片返回的是淺復制。所謂淺復制，是指生成一個新的列表，並且把原列表中所選元素的引用都復制到新列表中。如果原列表中只包含整數、實數、復數等基本類型或元組、字符串這樣的不可變類型的數據，一般是沒有問題的。
>>> aList = [3, 5, 7]
>>> bList = aList[::] #切片，淺復制
>>> aList == bList #兩個列表的元素完全一樣
True
>>> aList is bList #但不是同一個對象
False
>>> id(aList) == id(bList) #內存地址不一樣
False
>>> bList[1] = 8 #修改其中一個不會影響另一個
>>> bList
[3, 8, 7]
>>> aList
[3, 5, 7]
如果原列表中包含列表之類的可變數據類型，由於淺復制時只是把子列表的引用復制到新列表中，這樣的話修改任何一個都會影響另外一個。
>>> aList = [3, [5], 7] #列表aList中包含可變的列表對象
>>> bList = aList[:] #切片
>>> bList[1].append(6) #調用子列表的append()方法，這個方法是原地操作的
>>> bList
[3, [5, 6], 7]
>>> aList #aList受到影響
[3, [5, 6], 7]
標准庫copy中的deepcopy()函數實現深復制。所謂深復制，是指對原列表中的元素進行遞歸，把所有的值都復制到新列表中，對嵌套的子列表不再是復制引用。新列表和原列表是互相獨立，修改任何一個都不會影響另外一個。
>>> aList = [3, [5], 7]
>>> import copy
>>> bList = copy.deepcopy(aList) #深賦值，遞歸復制，直到遇到可哈希對象
#aList和bList完全獨立，互相不影響
>>> aList == bList
True
>>> aList is bList
False
>>> bList[1].append(6) #修改bList不會影響aList
>>> bList
[3, [5, 6], 7]
>>> aList
[3, [5], 7]
使用列表對象的sort()方法進行原地排序，支持多種不同的排序方法。
>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> import random
>>> random.shuffle(aList)
>>> aList
[3, 4, 15, 11, 9, 17, 13, 6, 7, 5]
>>> aList.sort() #默認是升序排序
>>> aList
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList.sort(reverse=True) #降序排序
>>> aList
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
>>> aList.sort(key=lambda x:len(str(x))) #按轉換成字符串的長度排序
>>> aList
[9, 7, 6, 5, 4, 3, 17, 15, 13, 11]
使用內置函數sorted()對列表進行排序並返回新列表。
>>> aList
[9, 7, 6, 5, 4, 3, 17, 15, 13, 11]
>>> sorted(aList) #升序排序
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> sorted(aList,reverse=True) #降序排序
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
使用列表對象的reverse()方法將元素原地逆序。
使用內置函數reversed()對列表元素進行逆序排列並返回迭代對象。
>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> newList = reversed(aList) #返回reversed對象
>>> list(newList) #把reversed對象轉換成列表
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
>>> for i in newList:
print(i, end=' ') #這裡沒有輸出內容
#迭代對象已遍歷結束
>>> newList = reversed(aList) #重新創建reversed對象
>>> for i in newList:
print(i, end=' ')
17 15 13 11 9 7 6 5 4 3
all()和any()：all()函數用來測試列表、元組等序列對象以及map對象、zip對象等類似對象中是否所有元素都等價於True，any()函數用來測試序列或可迭代對象中是否存在等價於True的元素。例如：
>>> all([1,2,3])
True
>>> all([0,1,2,3])
False
>>> any([0,1,2,3])
True
>>> any([0])
False
len(列表)：返回列表中的元素個數，同樣適用於元組、字典、集合、字符串等。 max(列表)、 min(列表)：返回列表中的最大或最小元素，同樣適用於元組、字典、集合、range對象等。 sum(列表)：對列表的元素進行求和運算，對非數值型列表運算需要指定start參數，同樣適用於元組、range。
zip()函數返回可迭代的zip對象。
>>> aList = [1, 2, 3]
>>> bList = [4, 5, 6]
>>> cList = zip(a, b) #返回zip對象
>>> cList
<zip object at 0x0000000003728908>
>>> list(cList) #把zip對象轉換成列表
[(1, 4), (2, 5), (3, 6)]
enumerate(列表):枚舉列表元素，返回枚舉對象，其中每個元素為包含下標和值的元組。該函數對元組、字符串同樣有效。
>>> for item in enumerate('abcdef'):
print(item)
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')
(5, 'f')
列表推導式語法形式為：
[expression for expr1 in sequence1 if condition1
for expr2 in sequence2 if condition2
for expr3 in sequence3 if condition3
...
for exprN in sequenceN if conditionN]
使用列表推導式實現嵌套列表的平鋪
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
#相當於
>>> vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> result = []
>>> for elem in vec:
for num in elem:
result.append(num)
>>> result
[1, 2, 3, 4, 5, 6, 7, 8, 9]
如果不確定嵌套層數，可以這樣做：
data = [[[1],[2],[3]],[[4],[5],[6]],[[7],[8],[9]]]
print(data)
result = []
def take_out(arr):
for item in arr:
if isinstance(item, int):
result.append(item)
else:
take_out(item)
take_out(data)
print(result)
在列表推導式中使用多個循環，實現多序列元素的任意組合
>>> [(x, y) for x in range(3) for y in range(3)]
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
>>> [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
元組和列表類似，但屬於不可變序列，元組一旦創建，用任何方法都不可以修改其元素。
使用“=”將一個元組賦值給變量
>>> a_tuple = ('a', 'b', 'mpilgrim', 'z', 'example')
>>> a_tuple
('a', 'b', 'mpilgrim', 'z', 'example')
>>> a = (3)
>>> a
3
>>> a = (3,) #包含一個元素的元組，最後必須多寫個逗號
>>> a
(3,)
>>> a = 3, #也可以這樣創建元組
>>> a
(3,)
>>> x = () #空元組
使用tuple函數將其他序列轉換為元組 >>> tuple('abcdefg')
>>> tuple('abcdefg') #把字符串轉換為元組
('a', 'b', 'c', 'd', 'e', 'f', 'g')
>>> aList
[-1, -4, 6, 7.5, -2.3, 9, -11]
>>> tuple(aList) #把列表轉換為元組
(-1, -4, 6, 7.5, -2.3, 9, -11)
>>> s = tuple() #空元組
>>> s
()
使用del可以刪除元組對象，不能刪除元組中的元素
元組一旦定義就不允許更改。
元組沒有append()、extend()和insert()等方法，無法向元組中添加元素。
元組沒有remove()或pop()方法，也無法對元組元素進行del操作，不能從元組中刪除元素。
元組可用作字典的“鍵”，也可以作為集合的元素。列表不能作為字典的“鍵”，包含列表、字典、集合或其他類型可變對象的元組也不能做字典的“鍵”。
可以使用序列解包功能對多個變量同時賦值。
>>> x, y, z = 1, 2, 3 #多個變量同時賦值
>>> v_tuple = (False, 3.5, 'exp')
>>> (x, y, z) = v_tuple
>>> x, y, z = v_tuple
>>> x, y, z = range(3) #可以對range對象進行序列解包
>>> x, y, z = iter([1, 2, 3]) #使用迭代器對象進行序列解包
>>> x, y, z = map(str, range(3)) #使用可迭代的map對象進行序列解包
>>> a, b = b, a #交換兩個變量的值
>>> x, y, z = sorted([1, 3, 2]) #sorted()函數返回排序後的列表
>>> a, b, c = 'ABC' #字符串也支持序列解包
>>> x = [1, 2, 3, 4, 5, 6]
>>> x[:3] = map(str, range(5)) #切片也支持序列解包
>>> aList = [1,2,3]
>>> bList = [4,5,6]
>>> cList = [7,8,9]
>>> dList = zip(aList, bList, cList)
>>> for index, value in enumerate(dList):
print(index, ':', value)
0 : (1, 4, 7)
1 : (2, 5, 8)
2 : (3, 6, 9)
使用生成器對象__next__()方法或內置函數next()進行遍歷
>>> g = ((i+2)**2 for i in range(10)) #創建生成器對象
>>> g
<generator object <genexpr> at 0x0000000003095200>
>>> tuple(g) #將生成器對象轉換為元組
(4, 9, 16, 25, 36, 49, 64, 81, 100, 121)
>>> list(g) #生成器對象已遍歷結束，沒有元素了
[]
>>> g = ((i+2)**2 for i in range(10)) #重新創建生成器對象
>>> g.__next__() #使用生成器對象的__next__()方法獲取元素
4
>>> g.__next__() #獲取下一個元素
9
>>> next(g) #使用函數next()獲取生成器對象中的元素
16
字典是無序、可變序列。
定義字典時，每個元素的鍵和值用冒號分隔，元素之間用逗號分隔，所有的元素放在一對大括號“｛｝”中。
字典中的鍵可以為任意不可變數據，比如整數、實數、復數、字符串、元組等等。
globals()返回包含當前作用域內所有全局變量和值的字典。
locals()返回包含當前作用域內所有局部變量和值的字典。
使用dict利用已有數據創建字典：
>>> keys = ['a', 'b', 'c', 'd']
>>> values = [1, 2, 3, 4]
>>> dictionary = dict(zip(keys, values))
>>> dictionary
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> x = dict() #空字典
>>> x
{}
使用dict根據給定的鍵、值創建字典
>>> d = dict(name='Dong', age=37)
>>> d
{'name': 'Dong', 'age': 37}
以鍵作為下標可以讀取字典元素，若鍵不存在則拋出異常
>>> aDict = {'name':'Dong', 'sex':'male', 'age':37}
>>> aDict['name']
'Dong'
使用字典對象的get()方法獲取指定鍵對應的值，並且可以在鍵不存在的時候返回指定值。
使用字典對象的items()方法可以返回字典的元素。
使用字典對象的keys()方法可以返回字典的“鍵”。
使用字典對象的values()方法可以返回字典的“值”。
>>> aDict={'name':'Dong', 'sex':'male', 'age':37}
>>> for item in aDict.items(): #輸出字典中所有元素
print(item)
('age', 37)
('name', 'Dong')
('sex', 'male')
>>> for key in aDict: #不加特殊說明，默認輸出“鍵”
print(key)
age
name
sex
>>> for key, value in aDict.items(): #序列解包用法
print(key, value)
age 37
name Dong
sex male
>>> aDict.keys() #返回所有“鍵”
dict_keys(['name', 'sex', 'age'])
>>> aDict.values() #返回所有“值”
dict_values(['Dong', 'male', 37])
當以指定鍵為下標為字典賦值時：1）若鍵存在，則可以修改該鍵的值；2）若不存在，則表示添加一個鍵、值對。
>>> aDict['age'] = 38 #修改元素值
>>> aDict
{'age': 38, 'name': 'Dong', 'sex': 'male'}
>>> aDict['address'] = 'SDIBT' #增加新元素
>>> aDict
{'age': 38, 'address': 'SDIBT', 'name': 'Dong', 'sex': 'male'}
使用字典對象的update()方法將另一個字典的鍵、值對添加到當前字典對象。
>>> aDict
{'age': 37, 'score': [98, 97], 'name': 'Dong', 'sex': 'male'}
>>> aDict.items()
dict_items([('age', 37), ('score', [98, 97]), ('name', 'Dong'), ('sex', 'male')])
>>> aDict.update({'a':'a','b':'b'})
>>> aDict
{'a': 'a', 'score': [98, 97], 'name': 'Dong', 'age': 37, 'b': 'b', 'sex': 'male'}
使用del刪除字典中指定鍵的元素
使用字典對象的clear()方法來刪除字典中所有元素
使用字典對象的pop()方法刪除並返回指定鍵的元素
使用字典對象的popitem()方法刪除並返回字典中的一個元素
>>> {i:str(i) for i in range(1, 5)}
{1: '1', 2: '2', 3: '3', 4: '4'}
>>> x = ['A', 'B', 'C', 'D']
>>> y = ['a', 'b', 'b', 'd']
>>> {i:j for i,j in zip(x,y)}
{'A': 'a', 'C': 'b', 'B': 'b', 'D': 'd'}
集合是無序、可變序列，使用一對大括號界定，元素不可重復，同一個集合中每個元素都是唯一的。
集合中只能包含數字、字符串、元組等不可變類型（或者說可哈希）的數據，而不能包含列表、字典、集合等可變類型的數據。
使用set將其他類型數據轉換為集合
>>> a_set = set(range(8,14))
>>> a_set
{8, 9, 10, 11, 12, 13}
>>> b_set = set([0, 1, 2, 3, 0, 1, 2, 3, 7, 8]) #自動去除重復
>>> b_set
{0, 1, 2, 3, 7, 8}
>>> c_set = set() #空集合
>>> c_set
set()
當不再使用某個集合時，可以使用del命令刪除整個集合。
集合對象的pop()方法彈出並刪除其中一個元素，remove()方法直接刪除指定元素，clear()方法清空集合。
>>> a = {1, 4, 2, 3}
>>> a.pop()
1
>>> a.pop()
2
>>> a
{3, 4}
>>> a.add(2)
>>> a
{2, 3, 4}
>>> a.remove(3)
>>> a
{2, 4}
交集、並集、差集、對稱差集等運算
交集、並集、差集、對稱差集等運算
>>> a_set = set([8, 9, 10, 11, 12, 13])
>>> b_set = {0, 1, 2, 3, 7, 8}
>>> a_set | b_set #並集
{0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 13}
>>> a_set & b_set #交集
{8}
>>> a_set - b_set
{9, 10, 11, 12, 13}
>>> a_set ^ b_set #對稱差集
{0, 1, 2, 3, 7, 9, 10, 11, 12, 13}
集合包含關系測試
>>> x = {1, 2, 3}
>>> y = {1, 2, 5}
>>> z = {1, 2, 3, 4}
>>> x < y #比較集合大小/包含關系
False
>>> x < z #真子集
True
>>> y < z
False
>>> {1, 2, 3} <= {1, 2, 3} #子集
True
