超強彙總:學習Python列表,只需這篇文章就夠了

千里之行,始於足下。要練成一雙洞悉一切的眼睛,還是得先把基本功紮紮實實地學好。今天,本喵帶大家仔細溫習一下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+本精選電子書。

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章