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
當然，如果你想要增加、刪減或者改變元素，那麼列表顯然更優。原因你現在肯定知道了，那就是對於元組，你必須得通過新建一個元組來完成。
列表和元組的使用場景
那麼列表和元組到底用哪一個呢？根據上面所說的特性，我們具體情況具體分析。
1. 如果存儲的數據和數量不變，比如你有一個函數，需要返回的是一個地點的經緯度，然後直接傳給前端渲染，那麼肯定選用元組更合適。
def get_location():
.....
return (longitude, latitude)
2. 如果存儲的數據或數量是可變的，比如社交平臺上的一個日誌功能，是統計一個用戶在一週之內看了哪些用戶的帖子，那麼則用列表更合適。
viewer_owner_id_list = [] # 裏面的每個元素記錄了這個 viewer 一週內看過的所有 owner 的 id
records = queryDB(viewer_id) # 索引數據庫，拿到某個 viewer 一週內的日誌
for record in records:
viewer_owner_id_list.append(record.id)
總結
- 列表和元組都是有序的，可以存儲任意數據類型的集合。
- 列表是動態的，長度可變，可以隨意增加、刪減、改變元素。
- 元組是靜態的，長度大小固定，不可對元素進行增加、刪減、改變操作。
- 列表的存儲空間略大於元組，性能略遜於元組。元組相對列表更輕量級。
