序列按存儲元素類型是否一緻可分為：扁平序列、容器序列。
扁平序列：string(字元串)、array.array(數組)、memoryview(記憶體視圖)、bytes(位元組串)、bytearray(位元組數組)
扁平序列中所有元素都為同類型資料。
容器序列：list(清單)、tuple(元組)、collection.deque(雙向隊列)
容器序列則可以存儲不同類型的資料，但容器序列實際存儲的是個元素的引用。支援元素嵌套
序列按是否更改又能分為：可變和不可變序列。
可變序列：list、array.array、bytearray、colloction.deque、memoryview
不可變序列：tuple、string、bytes
字典和集合嚴格意義上說并不屬于序列。序列即為一系列資料元素有秩序的組合在一起，構成一個整體，是一種組織資料的模型。
python中有序序列如list、tuple、str和range等都支援雙向索引
正向索引：從0開始
逆向索引：-1代表倒數第一個元素，-2代表代數第二個元素，以此類推
清單清單為python内置的可變序列資料結構之一，包含若幹==有序連續==的記憶體空間。
當清單增加或删除元素時，清單對象會自動進行記憶體的擴充或收縮，以保證元素之間沒有縫隙。
由于在清單中間插入或删除元素時會涉及大量元素的移動，效率較低，是以盡量從尾部增删元素。
==*同一清單中的元素的資料類型可以各不相同==
因為基于值的記憶體管理機制，清單中元素并不直接存儲值，而是存儲值的引用（或者說對象的引用）。
清單的建立list()内置函數
操作符，各元素之間用逗号隔開
清單的基本操作原地操作（通常都是list對象自帶的行為操作，del指令删除指定位置元素）
函數
功能
lst.append(x)
在清單lst末尾增加元素X
lst.extend(lst2)
在清單lst與lst2合并，==與lst+=lst2效果一樣且都是原地操作.
但lst=lst+lst2則會改變lst的id值，即lst+lst2傳回一個新的清單對象==
lst.insert(index,x)
在清單lst指定的index位置插入元素x
lst.remove(x)
删除清單lst中元素x
lst.pop([index])
傳回并删除清單lst指定index位置的元素,
預設為清單尾部元素
lst.clear()
删除清單lst中所有元素，但保留清單對象，
即傳回空清單
lst.index(X)
傳回清單lst中第一個為X的元素的下标
lst.count(x)
傳回指定元素X在清單lst中出現的次數
lst.reverse()
将清單lst逆序，lst發生變化（原地操作）
而内置函數reversed(lst)為非原地操作，原lst不變，傳回一個新清單
lst.sort(key=None,reverse=False)
将lst排序（原地操作）
lst.copy()
傳回清單lst的==淺複制==
淺複制&深複制
我們尋常意義的複制就是深複制，即将被複制對象完全再複制一遍作為獨立的新個體單獨存在。是以改變原有被複制對象不會對已經複制出來的新對象産生影響。
淺複制并不會産生一個獨立的對象單獨存在，他隻是将原有的資料塊打上一個新标簽，是以當其中一個标簽被改變的時候，資料塊就會發生變化，另一個标簽也會随之改變。這就和我們尋常意義上的複制有所不同了。
對于簡單的 object，用 shallow copy 和 deep copy 沒差別
複雜的 object,如 list 中套着 list 的情況，shallow copy中的子list，并未從原object 真的「獨立」出來。也就是說，如果你改變原 object 的子 list 中的一個元素，你的copy 就會跟着一起變。這跟我們直覺上對「複制」的了解不同。
了解原子對象和容器對象
非原地操作（Python内置函數，運算符+、*等）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68>>> x=list(range(10))
>>> y=x #x,y指向同一個對象，由id(x),id(y)可以看出
>>> y
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> id(x)
2568897570056
>>> id(y)
2568897570056
>>> import random
>>> random.shuffle(x) #随即打亂
>>> x
[3, 7, 1, 6, 8, 2, 0, 9, 4, 5]
>>> x is y
True
>>> y
[3, 7, 1, 6, 8, 2, 0, 9, 4, 5]
>>> x.pop() #原地操作
5
>>> id(x)
2568897570056
>>> x.append(258) #原地操作
>>> x
[3, 7, 1, 6, 8, 2, 0, 9, 4, 258]
>>> y
[3, 7, 1, 6, 8, 2, 0, 9, 4, 258]
>>> id(x)
2568897570056
>>> x.extend([15,51]) #原地操作
>>> y
[3, 7, 1, 6, 8, 2, 0, 9, 4, 258, 15, 51]
>>> id(y)
2568897570056
>>> x.insert(0,'insert') #原地操作
>>> x
['insert', 3, 7, 1, 6, 8, 2, 0, 9, 4, 258, 15, 51]
>>> x.remove(7) #原地操作
>>> x
['insert', 3, 1, 6, 8, 2, 0, 9, 4, 258, 15, 51]
>>> x.reverse() #list對象本身自帶逆序函數，原地操作
>>> x
[51, 15, 258, 4, 9, 0, 2, 8, 6, 1, 3, 'insert']
>>> x.pop()
'insert'
>>> x
[51, 15, 258, 4, 9, 0, 2, 8, 6, 1, 3]
>>> x.sort() #原地操作
>>> x
[0, 1, 2, 3, 4, 6, 8, 9, 15, 51, 258]
>>> reversed(x) #内置函數進行逆序，非原地操作，傳回新的對象。x不變
>>> x
[0, 1, 2, 3, 4, 6, 8, 9, 15, 51, 258]
>>> sorted(x,reverse=True) #非原地操作，産生新的清單
[258, 51, 15, 9, 8, 6, 4, 3, 2, 1, 0]
>>> x
[0, 1, 2, 3, 4, 6, 8, 9, 15, 51, 258]
>>> x=x+[1,2] #非原地操作（*）
>>> id(x)
2569288051976
>>> id(y)
2568897570056
>>> y
[0, 1, 2, 3, 4, 6, 8, 9, 15, 51, 258]
>>> y+=[1,2] #原地操作（與上一語句（*）對比）
>>> y
[0, 1, 2, 3, 4, 6, 8, 9, 15, 51, 258, 1, 2]
>>> id(y)
2568897570056
python中内置函數map(),filter(),reduce()等函數是==python函數式程式設計==的重要展現
(reduce()函數在python3中不是内置函數，而是在functools庫中)
注：下表中的lst不一定是清單，其他可疊代對象均可
函數 | 功能
— | —
map.(func,lst) | 傳回清單lst中每個元素經過函數func映射後的結果清單，
這裡的func也可以是lambda函數
filter(func,lst) | 将一個單參數函數作用到序列lst上，并傳回該序列中使得該函數
傳回值為True的那些元素組成的filter對象，如果指定函數為None，
則傳回序列中等價于True的元素所組成的filter對象
reduce(func,lst) | 将一個兩參數函數以累積方式從左到右依次作用到序列lst上
zip(seq1[,sep2[,sep3…]]) | 傳回元素為元組的新清單
enumerate(seq) | 枚舉清單元素，傳回enumerate對象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15>>> a=list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b=list(map(lambda x :chr(x+ord('A')),a))
>>> b
['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
>>> list(enumerate(b))
[(0, 'A'), (1, 'B'), (2, 'C'), (3, 'D'), (4, 'E'), (5, 'F'), (6, 'G'), (7, 'H'), (8, 'I'), (9, 'J')]
>>> list(filter(lambda x:x>6,a))
[7, 8, 9]
[x>6 for x in a ]
[False, False, False, False, False, False, False, True, True, True]
>>> from functools import reduce
>>> reduce(lambda i,j:i+j ,a)
45
切片通過切片擷取清單部分元素
可以通過切片實作删除、更改、增加元素
通過切片進行淺複制
清單推導式[表達式或函數式 for 變量 in 可疊代對象]
清單推導式結合if語句過濾元素
清單推導式實作多重循環
清單推導式實作矩陣轉置
清單推導式内使用函數或複雜表達式
array.array
簡介
array數組類型和C語言中的數組很類似，可以指定數組中存儲元素的類型。特點是速度快，可以通過執行個體方法存儲和讀取二進制檔案。
執行個體
collection.deque
簡介
清單可以通過pop()方法和append()方法來實作“先進先出”的隊列屬性，但由于頻繁移動元素導緻效率不高。deque類型專門對入隊出隊進行了優化。
執行個體
元組及具名元組
元組
元組基本知識元組為不可變序列，支援切片操作，但隻能通過切片來通路元組中的元素。可以将元組看成‘常量清單’。
當元組中的元素包含可變序列（如清單）時，情況變得不一樣。
python對元組内部做了優化，其通路和處理速度比清單更快。而且由于其不可改變的特點通常用來==函數調用時進行參數傳遞==
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27>>> a= (1,2,3)
>>> a
(1, 2, 3)
>>> type(a)
>>> b=a[:]
>>> b
(1, 2, 3)
>>> c=(3) #c=3等價，建立含一個元素的元組如d
>>> c
3
>>> type(c)
>>> d=(3,)
>>> d
(3,)
>>> type(d)
>>> e=()
>>> e
()
>>> f=tuple()
>>> f
()
>>> g=tuple([1,2,34,5])
>>> g
(1, 2, 34, 5)
生成器推導式格式：（表達式 for 變量 in 序列或疊代對象）
生成器推導式的結果為一個生成器對象
==生成器對象==：
可以使用工廠函數list(),tuple()将其轉化為清單或元組，也可以通過生成器對象本身的next方法或内置函數next()進行周遊，也可将其直接當做疊代器對象使用。但無論如何周遊或使用，當所有元素周遊完後，需要重新建立生成器對象才能重新通路其中的元素。生成器對象的優點是節省記憶體空間
包含yield關鍵字的函數可以用來建立可疊代的生成器對象
注意事項盡量不要把可變序列作為元組的元素
增量指派不是 原子操作，對于可變序列，+=運算符調用–iadd–() 特殊方法，就地操作。而不可變序列則沒有–add–()，是通過–add–()方法實作的，此時會建立一個新的對象，完成操作後與原變量關聯。
具名元組
collection.namedtuple()是一個工廠函數，用來建構帶字段名的元組和帶名字的類。
執行個體
序列解包對多個變量同時指派
同時周遊多個序列
在實參前加*号可以實作序列解包并在函數調用時進行參數傳遞
元組拆包常常用來傳遞函數參數。