千里之行，始於足下。要練成一雙洞悉一切的眼睛，還是得先把基本功紮紮實實地學好。今天，本喵帶大家仔細溫習一下Python的列表。溫故而知新，不亦說乎。
當然，溫習的同時也要發散思考，因為有些看似無關緊要的、約定俗成的語言習慣，例如陣列索引為何從0開始，其背後可能大有來歷。知其然，亦需知其所以然啊喵喵喵~~~
最後，在基礎知識之上，更要探索進階，例如學習生成器表示式，這樣既能更紮實地掌握基礎，又能融會貫通，獲得更全面的認知升級。
Python的列表是怎樣滴？
列表（list）是一種有序的集合，可以隨時新增、查詢和刪除元素。
列表支援加入不同資料型別的元素：數字、字串、列表、元組等。
列表通過有序的索引可遍歷所有的元素，從前往後數，索引是[0,n-1]，從後往前數，索引是[-1, -n]，其中n是列表的長度。
列表可以是不含元素的空列表，也可以包含超級多的元素（在記憶體大小支援的情況下）。
list_a = [] # 空列表，即len(list_a) == 0
list_b = [2018, 10, `2018-10-1`, [`hi`, 1, 2], (33, 44)]
# list_b 長度為5，包含2個數字元素、1個字串元素、1個列表元素和1個元組元素
len(list_b) == 5
list_b[0] == list_b[-5] == 2018
lits_b[3] == list_b[-2] == [`hi`, 1, 2]
lits_b[4] == list_b[-1] == (33, 44)Python中怎麼操作列表？
1）建立列表：
用中括號[]包裹元素，元素使用逗號分隔。
用list()方法，轉化生成列表。
列表生成式/列表解析式/列表推導式，生成列表。
list_a = [1, 2, 3]
list_b = list("abc") # list_b == [`a`, `b`, `c`]
list_c = list((4, 5, 6)) # list_c == [4, 5, 6]
list_d = [i for i in list_a] # list_d == [1, 2, 3]
list_e = [i*j for i in list_a for j in list_c] # list_e == [4,5,6,10,12,12,15,18]
list_f = [i*j for i,j in zip(list_a,list_c)] # list_f == [4, 10, 18]
list_g = [i for i in list_a if i%2 == 0] # list_g == [2]
# 結合range()函式，range(start, stop[, step])
list_h = list(range(3)) # list_h == [0, 1, 2]
list_i = list(range(3,7)) # list_i == [3, 4, 5, 6]
list_j = list(range(3,9,2)) # list_j == [3, 5, 7]
# 找出100以內的能夠被3整除的正整數
list_k = list(range(3,100,3)) # list_k == [3, 6, 9, ..., 96, 99]2）擴充列表：
用append()方法，在列表尾部新增單個新元素。
用insert()方法，在列表中指定位置新增元素。
用 “+” 運算子，將兩個列表拼接出一個新列表。
用extend()方法，在一個列表後面拼接進另一個列表。
# 以下分別新增2個元素
list_a = []
list_a.append(`happy`) # list_a == [`happy`]
list_a.insert(0, `very`) # list_a == [`very`, `happy`]
# 以下兩種擴充列表方式
list_1 = [`I`, `am`]
list_2 = [`very`, `happy`]
list_3 = list_1 + list_2 # 新列表 list_3 == [`I`, `am`, `very`, `happy`]
list_1.extend(list_2) # 原列表1擴充，list_1 == [`I`, `am`, `very`, `happy`]3）刪減列表與銷燬列表：
用del list[m] 語句，刪除指定索引m處的元素。
用remove()方法，刪除指定值的元素（第一個匹配項）。
用pop()方法，取出並刪除列表末尾的單個元素。
用pop(m)方法，取出並刪除索引值為m的元素。
用clear()方法，清空列表的元素。（杯子還在，水倒空了）
用del list 語句，銷燬整個列表。（杯子和水都沒有了）
# 以下4種刪除列表元素方式
list_1 = list_2 = list_3 = list_4 = [`I`, `am`, `very`, `happy`]
del list_1[0] # list_1 == [`am`, `very`, `happy`]
list_2.remove(`I`) # list_2 == [`am`, `very`, `happy`]
list_3.pop() # list_3 == [`I`, `am`, `very`]
list_4.pop(0) # list_4 == [`am`, `very`, `happy`]
# 清空與銷燬
list_a = [1, 2, 3]
list_b = [1, 2, 3]
list_b.clear() # list_b == []
del list_a # 沒有list_a了，再使用則會報錯4）列表切片：
基本含義：從第i位索引起，向右取到後n位元素為止，按m間隔過濾
基本格式：[i : i+n : m] ；i 是切片的起始索引值，為列表首位時可省略；i+n 是切片的結束位置，為列表末位時可省略；m 可以不提供，預設值是1，不允許為0，當m為負數時，列表翻轉。注意：這些值都可以大於列表長度，不會報越界。
li = [1, 4, 5, 6, 7, 9, 11, 14, 16]
# 以下寫法都可以表示整個列表，其中 X >= len(li)
li[0:X] == li[0:] == li[:X] == li[:] == li[::] == li[-X:X] == li[-X:]
li[1:5] == [4,5,6,7] # 從1起，取5-1位元素
li[1:5:2] == [4,6] # 從1起，取5-1位元素，按2間隔過濾
li[-1:] == [16] # 取倒數第一個元素
li[-4:-2] == [9, 11] # 從倒數第四起，取-2-(-4)=2位元素
li[:-2] == li[-len(li):-2] == [1,4,5,6,7,9,11] # 從頭開始，取-2-(-len(li))=7位元素
# 注意列表先翻轉，再擷取
li[::-1] == [16,14,11,9,7,6,5,4,1] # 翻轉整個列表
li[::-2] == [16,11,7,5,1] # 翻轉整個列表，再按2間隔過濾
li[:-5:-1] == [16,14,11,9] # 翻轉整個列表，取-5-(-len(li))=4位元素
li[:-5:-3] == [16,9] # 翻轉整個列表，取-5-(-len(li))=4位元素，再按3間隔過濾
li[::0] # 報錯（ValueError: slice step cannot be zero）
5) 其它操作：
用len()方法，統計全部元素的個數。
用count()方法，統計指定值的元素的個數。
用max()方法，統計元素中的最大值（要求元素型別相同；數字型別直接比較，其它型別比較id）
用min()方法，統計元素中的最小值（要求元素型別相同；數字型別直接比較，其它型別比較id）
用index()方法，查詢指定值的元素的索引位置（第一個匹配項）。
用reverse()方法，翻轉列表中的元素。
用copy()方法，淺拷貝並生成新的列表。
用deepcopy()方法，深拷貝並生成新的列表。
用sort()方法，在原列表基礎上進行排序。
用sorted()方法，將新列表基礎上對原列表的元素進行排序。
list_1 = [2018, 10, `2018-10-1`, [`hi`, 1, 2], (33, 44)]
len(list_1) == 5
list_1.count(10) == 1 # 元素10的數量為1
list_1.index(10) == 1 # 元素10的索引為1
list_1.reverse() # list_1 == [(33, 44), [`hi`, 1, 2], `2018-10-1`, 10, 2018]
# 比較淺拷貝與深拷貝
import copy
list_a = [2018, 10, `2018-10-1`, [`hi`, 1, 2], (33, 44)]
list_b = [`hi`, 1, 2]
list_c = list_a.copy() # list_c == [2018, 10, `2018-10-1`, [`hi`, 1, 2], (33, 44)]
list_d = copy.deepcopy(list_a) # list_d == [2018, 10, `2018-10-1`, [`hi`, 1, 2], (33, 44)]
# 改變原列表中的可變物件元素
list_a[3].append(`new`) # list_a == [2018, 10, `2018-10-1`, [`hi`, 1, 2, `new`], (33, 44)]
# 淺拷貝中的可變物件會隨原列表變化而變化
list_c == [2018, 10, `2018-10-1`, [`hi`, 1, 2, `new`], (33, 44)]
# 深拷貝中的可變物件不會隨原列表變化而變化
list_d == [2018, 10, `2018-10-1`, [`hi`, 1, 2], (33, 44)]
# 比較sort() 與 sorted()
list_1 = list_2 = [2,1,4,6,5,3]
list_1.sort() # 原列表變化：list_1 == [1,2,3,4,5,6]
list_3 = sorted(list_2) # 原列表不變：list_2 == [2,1,4,6,5,3]; list_3 == [1,2,3,4,5,6]Python列表索引為何從0始？
權威解釋來自Guido van Rossum（Python之父）的博文：《Why Python uses 0-based indexing》
一句話總結：索引從0開始，切片用法很優雅。
翻譯精華如下：
我決定在Python中使用0-based索引方式的一個原因，就是切片語法(slice notation)。
讓我們來先看看切片的用法。可能最常見的用法，就是“取前n位元素”或“從第i位索引起，取後n位元素”(前一種用法，實際上是i==起始位的特殊用法)。如果這兩種用法實現時可以不在表示式中出現難看的+1或-1，那將會非常的優雅。
使用0-based的索引方式、半開區間切片和預設匹配區間的話（Python最終採用這樣的方式），上面兩種情形的切片語法就變得非常漂亮：a[:n]和a[i:i+n]，前者是a[0:n]的縮略寫法。
如果使用1-based的索引方式，那麼，想讓a[:n]表達“取前n個元素”的意思，你要麼使用閉合區間切片語法，要麼在切片語法中使用切片起始位和切片長度作為切片引數。半開區間切片語法如果和1-based的索引方式結合起來，則會變得不優雅。而使用閉合區間切片語法的話，為了從第i位索引開始取後n個元素，你就得把表示式寫成a[i:i+n-1]。
……
特別是當兩個切片操作位置鄰接時，第一個切片操作的終點索引值是第二個切片的起點索引值時，太漂亮了，無法捨棄。例如，你想將一個字串以i，j兩個位置切成三部分，這三部分的表示式將會是a[:i]，a[i:j]和a[j:]。
其它程式語言的索引？
索引從0開始的程式語言：C、C++、Python、Java、PHP、Ruby、Javascript…
索引從1開始的程式語言：ABC、Matlab、VB、易語言、大部分shell語言…
索引從其它值開始的程式語言：Pascal、Lua…
還有像表示星期、月份等序列結構的資料，各種程式語言也劃分成了不同陣營。
它們出於何種考慮？
C語言：索引從0開始，可以大大提升記憶體定址計算的效率，詳細分析參考《C語言陣列元素下標為何從0開始》
大部分shell語言：大多數是從1開始，來源參考stackexchange這篇問答
Pascal、Lua：預設從1開始，但支援改變起始索引值，原因據說是對非專業的開發者更友好，來源參考這篇知乎問答
以上列舉的原因是最審慎的、體面的解釋，話題應該到此終結，因為“索引應該從幾開始最好”這個問題的破壞性不亞於“哪種程式語言是最好的”……
優雅漂亮的結尾：生成器表示式
列表生成式是一種漂亮優雅的東西，然而它有一個致命的缺點：它一次性把所有元素載入到記憶體中，當列表過長的時候，便會佔據過多的記憶體資源，而且，我們通常僅需要使用少數的元素，這樣未使用的元素所佔據的絕大部分的記憶體，就成了不必要的支出。
生成器是一種更高階更優雅的東西，它使用“懶載入”的原理，並不生成完整的列表，而是迭代地、即時地、按需地生成元素，這樣不僅能極大地節省記憶體空間，而且，在理論上，它可以生成一個無窮大的列表！
大多數生成器是以函式來實現的，然而，它並不返回（return）一個值，而是生成（yield）一個值，並掛起程式。然後，通過next()方法生成並馬上返回一個元素，或者通過for迴圈，逐一生成和返回全部元素。
next()效率太低，且呼叫次數越界時會丟擲StopIteration的異常，而for迴圈會自動捕捉這個異常，並停止呼叫，所以使用更佳。
# 計算斐波那契數列的生成器
def fibon(n):
a = b = 1
for i in range(n):
yield a # 使用yield
a, b = b, a + b
# 計算前1000000個數，通過next()函式，按順序每次生成一個數
g = fibon(1000000)
next(g) # 1
next(g) # 1
next(g) # 2
next(g) # 3
next(g) # 5
# 以此類推，但若呼叫超過1000000次，就會報異常StopIteration
# 計算前1000000個數，通過for迴圈逐一列印生成數
for x in fibon(1000000):
print(x)生成器表示式與列表生成式極其形似，只是把[]改成了()，但背後的原理大不相同。
l = [x*2 for x in range(5)] # 列表生成式，4以內整數的2倍數
g = (x*2 for x in range(5)) # 生成器表示式
type(l) # 結果：<type `list`>
type(g) # 結果：<type `generator`>
print(l) # 結果：[0,2,4,6,8]
print(g) # 結果：<generator object at 0x000002173F0EBC50>
next(g) # 0
next(g) # 2
next(g) # 4
next(g) # 6
next(g) # 8
next(g) # Traceback (most recent call last): ....StopIteration
for x in g:
print(x, end=` `) # 結果：0 2 4 6 8 本文原創並首發於微信公眾號【Python貓】，後臺回覆“愛學習”，免費獲得20+本精選電子書。