Python內置了多種類型的數據結構，常用的有：列表、元組、集合和字典。

本文主要介紹列表和元組。

列表(list)和元組(tuple)

列表和元組，都是一個可以放置任意數據類型的有序集合。

列表和元組的區別列表是動態的，長度大小不固定，可以隨意增加、刪減或者改變元素(mutable)。

元組是靜態的，長度大小固定，無法增加刪減或改變(immutable)。

如果要對已有的元組做任何“改變”，只能重新開辟一塊內存，創建新的元組。

# 列表(list)

list = [1, 2, 3, 4, 5]

list.append(6) # 添加元素 5 到原列表的末尾

print(list)

# 元組

tup = (1, 2, 3, 4)

new_tup = tup + (5, ) # 創建新的元組 new_tup，并依次填充原元組的值

print(new_tup)

列表和元組的基本操作和注意事項

在python中，列表和元組都支持負數索引，-1表示最后一個元素，-2表示倒數第2個元素，以此類推

# 列表

list = [1, 2, 3, 4]

list[0]

list[-1]

# 元組

tup = (1, 2, 3, 4)

tup[1]

tup[-2]

列表和元組都支持切片操作

list = [1, 2, 3, 4]

l[1:3] # 返回列表中索引從 1 到 2 的子列表

[2, 3]

tup = (1, 2, 3, 4)

tup[1:3] # 返回元組中索引從 1 到 2 的子元組

(2, 3)

隨意嵌套

l = [[1, 2, 3], [4, 5]] # 列表的每一個元素也是一個列表

tup = ((1, 2, 3), (4, 5, 6)) # 元組的每一個元素也是一元組

兩者可以通過 list() 和 tuple() 函數相互轉換：

list((1, 2, 3))

[1, 2, 3]

tuple([1, 2, 3])

(1, 2, 3)

常用的內置函數count(item) 表示統計列表 / 元組中 item 出現的次數。

index(item) 表示返回列表 / 元組中 item 第一次出現的索引。

list.reverse() 和 list.sort() 分別表示原地倒轉列表和排序(注意，元組沒有內置的這兩個函數)。

reversed() 和 sorted() 同樣表示對列表 / 元組進行倒轉和排序，但是會返回一個倒轉后或者排好序的新的列表 / 元組。

l = [3, 2, 3, 7, 8, 1]

l.count(3)

2

l.index(7)

3

l.reverse()

l

[1, 8, 7, 3, 2, 3]

l.sort()

l

[1, 2, 3, 3, 7, 8]

tup = (3, 2, 3, 7, 8, 1)

tup.count(3)

2

tup.index(7)

3

list(reversed(tup))

[1, 8, 7, 3, 2, 3]

sorted(tup)

[1, 2, 3, 3, 7, 8]

列表和元組存儲方式的差異

前面我們說過：列表和元組最重要的區別就是，列表是動態的、可變的，而元組是靜態的、不可變的。這樣的差異，勢必會影響兩者存儲方式。我們先看下面的例子：

l = [1, 2, 3]

l.__sizeof__()

64

tup = (1, 2, 3)

tup.__sizeof__()

48

上面的例子中，我們在列表和元組中放置了相同的元素，但是元組的存儲空間，卻比列表要少 16 字節。這是為什么呢？

事實上，由于列表是動態的，所以它需要存儲指針，來指向對應的元素(上述例子中，對于 int 型，8 字節)。另外，由于列表可變，所以需要額外存儲已經分配的長度大小(8 字節)，這樣才可以實時追蹤列表空間的使用情況，當空間不足時，及時分配額外空間。

l = []

l.__sizeof__() // 空列表的存儲空間為 40 字節

40

l.append(1)

l.__sizeof__()

72 // 加入了元素 1 之后，列表為其分配了可以存儲 4 個元素的空間 (72 - 40)/8 = 4

l.append(2)

l.__sizeof__()

72 // 由于之前分配了空間，所以加入元素 2，列表空間不變

l.append(3)

l.__sizeof__()

72 // 同上

l.append(4)

l.__sizeof__()

72 // 同上

l.append(5)

l.__sizeof__()

104 // 加入元素 5 之后，列表的空間不足，所以又額外分配了可以存儲 4 個元素的空間

上面的例子，大概描述了列表空間分配的過程。我們可以看到，為了減小每次增加 / 刪減操作時空間分配的開銷，Python 每次分配空間時都會額外多分配一些，這樣的機制(over-allocating)保證了其操作的高效性：增加 / 刪除的時間復雜度均為 O(1)。

但是對于元組，情況就不同了。元組長度大小固定，元素不可變，所以存儲空間固定。

在數據量小的情況下，這樣的差異可以忽略不計。但是當數據量很大時，比如列表和元組存儲元素的個數是一億，十億甚至更大數量級時，這種差異就不能忽視了。

列表和元組的性能

通過上面列表和元組存儲方式的差異的學習，我們可以得出結論：元組要比列表更加輕量級一些，所以總體上來說，元組的性能速度要略優于列表。

另外，Python 會在后臺，對靜態數據做一些資源緩存(resource caching)。通常來說，因為垃圾回收機制的存在，如果一些變量不被使用了，Python 就會回收它們所占用的內存，返還給操作系統，以便其他變量或其他應用使用。

但是對于一些靜態變量，比如元組，如果它不被使用并且占用空間不大時，Python 會暫時緩存這部分內存。這樣，下次我們再創建同樣大小的元組時，Python 就可以不用再向操作系統發出請求，去尋找內存，而是可以直接分配之前緩存的內存空間，這樣就能大大加快程序的運行速度。

下面的例子，是計算初始化一個相同元素的列表和元組分別所需的時間。我們可以看到，元組的初始化速度，要比列表快 5 倍。

python -m timeit 'x=(1,2,3,4,5,6)'

20000000 loops, best of 5: 9.97 nsec per loop

python -m timeit 'x=[1,2,3,4,5,6]'

5000000 loops, best of 5: 50.1 nsec per loop

但如果是索引操作的話，兩者的速度差別非常小，幾乎可以忽略不計。

python -m timeit -s 'x=[1,2,3,4,5,6]' 'y=x[3]'

10000000 loops, best of 5: 22.2 nsec per loop

python -m timeit -s 'x=(1,2,3,4,5,6)' 'y=x[3]'

10000000 loops, best of 5: 21.9 nsec per loop

當然，如果你想要增加、刪減或者改變元素，那么列表顯然更優。原因你現在肯定知道了，那就是對于元組，你必須得通過新建一個元組來完成。

總結列表和元組都是有序的，可以存儲任意數據類型的集合。

列表是動態的，長度可變，可以隨意增加、刪減、改變元素。

元組是靜態的，長度大小固定，不可對元素進行增加、刪減、改變操作。

列表的存儲空間略大于元組，性能略遜于元組。元組相對列表更輕量級。

總結

以上是生活随笔為你收集整理的opython3l_Python从小白到攻城狮(3)——列表和元组，到底用哪个？的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。