一、列表（list）
1.列表的內建函式為 list 。列表可以是普通列表、混合列表，也可以是空列表，列表中可以新增列表。列表內容可以是整數，可以是浮點數，也可以是字串。元素的位置是從“0”開始的。

2.新建列表：
新建列表 變數 = []

3.len() 函式可以獲取列表元素的個數

4.用索引訪問列表中每一個元素的位置列表[位置]

A.可以正向搜尋（預設起始位置為“0”）

B.也可以逆向搜尋（預設起始位置為“-1”）

當索引超出了範圍時，Python會報一個IndexError錯誤。

5.更改列表中的元素

A.在列表中，可以通過 .append 方式增加元素到末尾位置。

B.通過 .insert() 方法增加元素並指定其在列表中的位置
list.insert(位置,’增加的元素’)

C.通過 .pop() 方法刪除列表中的元素
列表.pop()，預設刪除最後一個元素

由於 pop() 有返回值，因此可以採用賦值的方法，倒序刪除

列表.pop(位置)，刪除指定位置元素

D.替換元素，可以直接將新元素賦值給指定位置

E.列表的擴充套件，將多個元素加入列表中
列表.extend([])

列表的擴充套件應採用 變數“點” extend([]) 的方式，不要採用 + （連線操作符）的方式，會出現違規操作，因為 + 兩邊的元素必須一致。

F.列表頁可以包含列表，要定位被包含列表中某一位置的元素，可以採取 列表[包含列表位置][被包含列表位置] 的方法

或 被包含列表[位置] 的方法

G.變數.remove(元素名稱) 知道元素名稱進行刪除

H.delete 方法
del列表[元素位置]

或者 del空格列表賦值的變數，整個列表被刪除

最後提示“沒有這個列表”，表示刪除成功

6.一個元素的列表，呼叫元素種類讀取。

7.切片
為了一次性獲取列表中更多的元素，可以採用 切片/分片/slice 的方法
A.切片，通過分號隔開索引值，複製列表。其中，冒號左邊為開始（包含開始索引值），冒號右邊為結束（不包含結束索引值）。

B.同理，可以在開始位置或是結束位置不填寫索引值，則複製的列表包含開始/結束的位置；也可以只填寫冒號，獲取整個列表的複製。

C.切片是複製整個列表，所以適用於需要修改列表同時又要保留原列表的情況；賦值是元素值完全相同的兩個列表。

8.列表比較大小
列表比較大小，是以索引值第 0 個位置的大小判定， 0 位置的索引值大，當前列表就大，反之亦然。

9.列表相乘，列表中元素數量增倍，但是數值不變。

10.成員關係操作符
通過 in 和 not in 確定成員關係

對於確定列表中的列表的成員關係，應當在一層列表中引入二層列表

11.列表內建函式(BIF)及部分常用內建函式(BIF)
dir(list)

A.count()：用於計算某元素在列表中出現的次數
列表.count(需要查詢的元素)

count(sub[,start[,end]])，start 表示此位置之前的捨去（不含此位置），end 表示此位置之後的捨去（不含此位置）。

B.index()：返回引數在列表中的位置。
列表.index(需要查詢位置的元素)

如果一個列表中有多個相同的元素分佈在不同的位置，Index預設只查詢第一個元素的位置，可以劃定位置範圍查詢其他相同元素（只找排列在最前面的）。

列表.index(需要查詢位置的元素,查詢起始位置,查詢結束位置)

C.reverse()：將整個列表原地反轉，前後的值互相調換位置。
列表.reverse()

D.排序
sort()：預設從小到大進行排隊
列表.sort()

如果列表需要從大到小排序，可以先通過 sort 從小到大排序，再用 reverse 反轉；另外還有一個方法是呼叫 sort 中的 reverse 引數
列表.sort(reverse = True)

.sort(reverse) 中的 reverse 預設值是 False，所以要改為 True 。

二、元組（tuple）
1.新建一個元組，與字串不同，元組內的元素要加上英文逗號。tuple 一旦初始化，元素指向不能改變。

2.tuple 陷阱：
當定義一個只有一個元素的 tuple，如果如下圖定義，則定義的不是 tuple，只是一個數，這是因為括號()既可以表示 tuple，又可以表示數學公式中的小括號，這就產生了歧義，因此，Python 規定，這種情況下，按小括號進行計算，計算結果自然是1。

所以，只有1個元素的tuple定義時必須加一個英文逗號消除歧義。

3.“可變的”元組
例：

tuple所謂的“不變”是說，tuple的每個元素，指向永遠不變。即指向’a’，就不能改成指向’b’，指向一個list，就不能改成指向其他物件，但指向的這個list本身是可變的！
所以，如果需要建一個“不可變”的元組，那就需要元組內的每一個元素都是“不可變”的。

4.數字乘以元組，* 相當於重複操作符，不再有乘法意義。

5.刪除元組
del元組

6.適用於元組的操作符
1.拼接操作符
2.重複操作符
3.關係操作符（>、<、 ==、!=）
4.邏輯操作符（and、or、not）
5.成員操作符（in、not in）

三、序列

1.列表、元組和字串的共同點
A.都可以通過索引得到每一個元素；
B.預設索引值總是從零開始；
C.可以通過分片的方法得到一個範圍內的元素的集合；
D.共用重複操作符、拼接操作符、成員關係操作符。

2.生成空列表
>>> a = list()
>>> a
[]

3.將字串轉換為單獨列出的列表
b = 'Python'
>>> b = list(b)
>>> b
['P', 'y', 't', 'h', 'o', 'n']

4.將元組轉換為列表
b = (1,2,3,4,5)
>>> b = list(b)
>>> b
[1, 2, 3, 4, 5]

5.將列表轉換為元組
b = [1,2,3,4,5]
>>> b = tuple(b)
>>> b
(1, 2, 3, 4, 5)

6.max（sub） 返回序列或引數集合中的最大值（資料型別必須一致）
>>> c = (11,23,56,3,789)
>>> max(c)
789

7.min（sub） 返回序列或引數集合中的最大值（資料型別必須一致）
>>> min(11,23,56,3,789)
3

8.sum(iterable[, start=0]) 返回序列 iterable 和可選引數 start 的總和(可以是資料型別（整數、浮點數），字串不能實現此操作)
A.sum(iterable)
>>> d = (1,2,3,4,5)
>>> sum(d)
15

B.sum(iterable,star)
>>> d = (1,2,3,4,5)
>>> sum(d)
15
>>> sum(d,15)
30

9.sorted() 預設由小到大排序
>>>c = (11,23,56,3,789)
>>> sorted(c)
[3, 11, 23, 56, 789]

10.reversed() 返回迭代器物件 ，如果將 reversed 表示的迭代器物件返回為列表，可以通過 list() 或是 tuple() 。
>>> c = (11,23,56,3,789)
>>> reversed(c)
<reversed object at 0x00000238FF8811D0>
>>> list(reversed(c))
[789, 3, 56, 23, 11]
>>> tuple(reversed(c))
(789, 3, 56, 23, 11)

11.enumerateenumerate() 列舉，生成由每個元素的 index（索引） 值和 item 值組成的元組。
>>> enumerate(d)
<enumerate object at 0x00000238FF884EA0>
>>> list(enumerate(d))
[(0, 1), (1, 22), (2, 345), (3, 43), (4, 576), (5, 60)]
>>> tuple(enumerate(d))
((0, 1), (1, 22), (2, 345), (3, 43), (4, 576), (5, 60))

元素前面都加了元 其所在列表的索引值

12.zip() 返回由各個引數的序列組成的集合。
A.
>>> e = (11,23,41,36,77,90)
>>> f = (43,76,45,22,11,489,123,65)
>>> zip(e,f)
<zip object at 0x00000238FF880F88>
>>> list(zip(e,f))
[(11, 43), (23, 76), (41, 45), (36, 22), (77, 11), (90, 489)]
>>> tuple(zip(e,f))
((11, 43), (23, 76), (41, 45), (36, 22), (77, 11), (90, 489))
B.
>>> e = [11,23,41,36,77,90]
>>> f = [43,76,45,22,11,489,123,65]
>>> zip(e,f)
<zip object at 0x00000238FF888548>
>>> list(zip(e,f))
[(11, 43), (23, 76), (41, 45), (36, 22), (77, 11), (90, 489)]
>>> tuple(zip(e,f))
((11, 43), (23, 76), (41, 45), (36, 22), (77, 11), (90, 489))

成對打包，元素相對多的集合，多出來的元素捨棄不要。

From：http://blog.csdn.net/komazhy/article/details/51911617