python中列表(list)和元組(tuple)的深入講解
前言
在我們實際開發中，經常需要將一組數據存儲起來，以便使用。如果學習瞭其他的語言可能知道數組（Array）這個數據結構，它就可以將多個數據進行存儲，訪問數據可以通過數組下標的方式，的進行獲取。如果你是python開發者，那麼可以使用更加靈活的列表(list)和元組(tuple)，來進行數據儲存。下面我們先簡單瞭解下列表和元組的基本使用。
列表
列表是動態的，長度可以改變，可以隨意增加，修改或刪除元素。
初始化列表
a = list()
b = []
# 可以通過range快速創建list
c = list(range(1,6))
print("a:", a)
print("b:", b)
print("c:", c)
# a: []
# b: []
# c: [1, 2, 3, 4, 5]
添加元素
append：在列表的末尾添加一個元素
>>l = []
>>l.append("python")
>>l
['python']
extend：使用可迭代對象中的所有元素來擴展列表
>>l = ["python"] >>t = ["java"] >>l.extend(t) >>l ['python', 'java']
insert:在給定的位置插入一個元素。第一個參數是要插入的元素的索引，所以 list_name.insert(0, x) 插入列表頭部
>>l = ["python", "java"] >>l.insert(1,"go") >>l ['python', 'go', 'java']
刪除元素
remove(x)：從列表中刪除值為x的第一項。 如果沒有需要刪除的值，那就拋出異常
>>l = ["python", "java"]
>>l.remove("java")
>>l
['python']
>>l.remove("test")
Traceback (most recent call last):
File "<input>", line 1, in <module>
ValueError: list.remove(x): x not in list
pop: 刪除列表中給定位置的元素並返回它。如果沒有給定位置，pop() 將會刪除並返回列表中的最後一個元素
>>l = ["python", "java", "go"] >>l.pop() 'go' >>l ['python', 'java'] >>l.pop(1) 'java' >>l.pop(1) Traceback (most recent call last): File "<input>", line 1, in <module> IndexError: pop index out of range
del: Python 中的關鍵字，專門用來執行刪除操作，它不僅可以刪除整個列表，還可以刪除列表中的某些元素
>>l = ["python", "java", "go", "js"] >>del l[0:1] >>l ['java', 'go', 'js'] >>del l[0] >>l ['go', 'js']
clear(): 移除列表中的所有元素。等價於 del a[:]
>>l = ["python", "java", "go", "js"] >>l.clear() >>l []
ps： 這裡註意和del 的區別， clear是清空， del list_name 是刪除，內存也釋放
修改元素
修改單個可以通過下標的方法
>>l = ["python", "go", "java"] >>l[0] = "PYTHON" >>l ['PYTHON', 'go', 'java']
修改一組數據可以通過切片的方式
>>l = ["python", "go", "java"] >>l[0:2] = "PYTHON", "GO" >>l ['PYTHON', 'GO', 'java'] >>l[0:2] = ["python", "go"] >>l ['python', 'go', 'java']
查詢元素
index(x) ：方法用來查找某個元素在列表中出現的位置（也就是索引），如果該元素不存在，則會導致 ValueError 錯誤
>>l
['python', 'go', 'java']
>>l.index("python")
0
>>l.index("python1")
Traceback (most recent call last):
File "<input>", line 1, in <module>
ValueError: 'python1' is not in list
count() :用來統計某個元素在列表中出現的次數
>>l
['python', 'go', 'java']
>>l.count("PYTHON")
0
>>l.count("python")
1
其他操作
sort：對列表中的元素進行排序
>>l ['go', 'java', 'python'] >>l.sort(reverse=True) >>l ['python', 'java', 'go'] >>l.sort() >>l ['go', 'java', 'python']
reverse: 反轉元素
>>l = [1,2,3,4,5] >>l.reverse() >>l [5, 4, 3, 2, 1]
copy: 返回列表的一個淺拷貝，等價於 a[:]
>>l [5, 4, 3, 2, 1] >>a = l.copy() >>a [5, 4, 3, 2, 1]
python列表使用場景
1-使用列表實現棧
棧（stack)特點就是後進先出， 使用列表實現是非常容易的，要添加一個元素到堆棧的頂端，使用 append() 。要從堆棧頂部取出一個元素，使用 pop() ，不用指定索引。
stack = [] stack.append(1) stack.append(2) stack.append(3) stack.append(4) stack.pop() # 4 stack.pop() # 3 stack.pop() # 2 stack.pop() # 1 # 註意捕捉錯誤
2-實現隊列
from collections import deque
queue = deque(["python", "go", "java"])
queue.append("python")
queue.append("go")
print(queue)
queue.popleft()
queue.popleft()
print(queue)
返回結果
deque([‘python’, ‘go’, ‘java’, ‘python’, ‘go’])
deque([‘java’, ‘python’, ‘go’])
列表推導式
a = [x ** 2 for x in range(10)]
b = [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]
# 嵌套列表推導式
matrix = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
]
c = [[row[i] for row in matrix] for i in range(4)]
print("a:", a)
print("b:", b)
print("c:", c)
返回
a: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
b: [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
c: [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
元組
元組是靜態，大小固定，不可以對元素進行增加，修改或刪除的操作
創建元組
a = 1, 2, 3
print("a", a)
b = (1, 2, 3)
print("b", b)
# 將字符串轉換成元組
tup1 = tuple("hello")
print("將字符串轉換成元組", tup1)
# 將列表轉換成元組
list1 = ['Python', 'Java', 'C++', 'JavaScript']
tup2 = tuple(list1)
print("將列表轉換成元組", tup2)
# 將字典轉換成元組
dict1 = {'a': 100, 'b': 42, 'c': 9}
tup3 = tuple(dict1)
print("將字典轉換成元組", tup3)
# 將區間轉換成元組
range1 = range(1, 6)
tup4 = tuple(range1)
print("將區間轉換成元組", tup4)
返回結果
a (1, 2, 3)
b (1, 2, 3)
將字符串轉換成元組 (‘h’, ‘e’, ‘l’, ‘l’, ‘o’)
將列表轉換成元組 (‘Python’, ‘Java’, ‘C++’, ‘JavaScript’)
將字典轉換成元組 (‘a’, ‘b’, ‘c’)
將區間轉換成元組 (1, 2, 3, 4, 5)
訪問元素
a = (1, 2, 3, 4, 5) # 通過下標 print(a[0]) # 通過切片：a[start : end : step] print(a[0:4:2])
返回結果
1
(1, 3)
刪除
a = (1, 2, 3, 4, 5) del a
元組和列表區別
元組是靜態，列表是動態
元組修改
l = (1,2,3,4) id(l) # 4497372488 l = l + (5,6) id(l) # 4494985832
列表修改
l = [1,2,3,4] id(l) # 4499169160 l = l + [5,6] id(l) # 4495787016
通過上面可以發現元組是不可以改變的，這裡強調一點很多新手對這個 l = l + (5,6) 很不難理解，不是說元組不可以修改的嗎，那為什麼這裡可以修改？記住這裡雖然可以執行，但是他是創建瞭一個新的元組，這時候的 l 不是原來的 l, 可以通過 id 查詢（或則執行 l[0] = -1 就會報錯）
在這裡我多說幾句，這裡的靜態和動態，大白話來講是列表是可以進行列表的操作（新增，刪除，修改），一般操作行為下他的內存地址不變（通過id查看），這和他的實現有關，但是元組就會改變，所以新的元組和原來的不一樣，一般時候有人（面試官或則開發不小心）會問你 a = ([1,2], 3,4), 為什麼可以進行a[0].append(3)，但是id(a)前後不變，這就是0下標的元素是列表，列表可以修改的。
列表需要更多內存，元組需要更少內存
list_t = []
print("列表初始化時候大小:", list_t.__sizeof__())
tuple_t = ()
print("元組初始化時候大小:", tuple_t.__sizeof__())
返回結果
列表初始化時候大小: 40
元組初始化時候大小: 24
看到結果有沒有發現列表比元組大18字節，那麼問題來瞭：這18字節是怎麼來的？這是由於列表是動態的，它需要存儲指針來指向對應的元素（占用 8 個字節）。另外，由於列表中元素可變，所以需要額外存儲已經分配的長度大小（占用 8 個字節），這樣才能實時追蹤列表空間的使用情況。但是對於元組，情況就不同瞭，元組長度大小固定，且存儲元素不可變，所以存儲空間也是固定的。
列表不可被hash，元組可以被hash
tuple_t = (1, 2)
print("元組hash值:", hash(tuple_t))
list_t = [1, 2]
print("列表hash值:", hash(list_t))
執行結果
Traceback (most recent call last):
File “/Users/linjian/MonitorCenter/MonitorCenter/apps/t6.py”, line 4, in <module>
print(“列表hash值:”, hash(list_t))
TypeError: unhashable type: ‘list’
元組hash值: 3713081631934410656
從上面的結果可以發現元組是可以被hash，但列表卻是不可以。如果基礎紮實的應該會反應過來，python中hash需要滿足是不可變類型的數據結構(字符串str、元組tuple、對象集objects)
執行效率
# 初始化一個相同元素的列表和元組使用情況 (djangoDemo) MonitorCenter % python -m timeit 'x=(1,2,3,4,5,6)' 100000000 loops, best of 3: 0.0103 usec per loop (djangoDemo) MonitorCenter % python -m timeit 'x=[1,2,3,4,5,6]' 10000000 loops, best of 3: 0.0514 usec per loop # 元組和列表索引操作對比 (djangoDemo) MonitorCenter % python -m timeit 'x=(1,2,3,4,5,6)' 'y=x[3]' 10000000 loops, best of 3: 0.0267 usec per loop (djangoDemo) MonitorCenter % python -m timeit 'x=(1,2,3,4,5,6)' 'y=x[3]' 10000000 loops, best of 3: 0.0265 usec per loop
上面的運行結果顯示： 元組初始化遠快於列表 ，大概有五倍的差距，但是索引操作的時候速度沒有多大差距
截止目前為止，我們可以簡單總結列表和元組的區別有如下：
- 元組使用tuple()或()初始化，列表使用list()或[]初始化
- 元組是靜態，而列表是動態
- 列表需要更多內存，元組需要更少內存
- 列表不可被hash，元組可以被hash
- 元組初始化效率高於列表，但索引操作沒有多大差距
元組和列表使用場景
再說使用場景前先講一下，在python後臺，對靜態數據做一些資源緩存，通常因為垃圾回收機制的存在，一些變量不使用，python就會回收他們所占的內存，但是對於一些靜態變量（比如說元組），當他們占用不大時候（長度1~20的元組），python會暫時緩存這部分內存，這樣下次就可以不再向操作系統發出請求，分配內存資源，而是直接使用用緩存中之前的內存空間，這樣大大加快瞭程序的運行速度。所以一般有時候數據量不大，我經常使用元組替代列表。到目前為止我們可以簡單的總結出場景可以如下所示：
- 如果數據不可變，我們就可以考慮使用元組，比如說性別類型，返回出去的城市信息等等
- 如果數據可變，我們就考慮使用列表，比如說用戶當天訪問的網頁等等
拓展知識
創建空的列表，是使用list()效率好還是[]？
(djangoDemo) MonitorCenter % python -m timeit ‘x=list()’
10000000 loops, best of 3: 0.087 usec per loop
(djangoDemo) MonitorCenter % python -m timeit ‘x=[]’
100000000 loops, best of 3: 0.0177 usec per loop
通過上面的測試可以知道是[]快。list()函數調用，python中函數調用會創建stack並且會進行參數檢查，[]是一個內置C函數，可以直接調用，因此效率更高。
執行相乘操作時候，是 *= 效率好， 還是*？
(djangoDemo) MonitorCenter % python -m timeit ‘x = [1,2,3]’ ‘x*=3’
10000000 loops, best of 3: 0.0903 usec per loop
(djangoDemo) MonitorCenter % python -m timeit ‘x = [1,2,3]’ ‘x = x * 3’
10000000 loops, best of 3: 0.104 usec per loop
從結果可以看出是*效率會低點。*= 中會預分配，不足的時候擴容，但是* 會按照每次的量進行分配大小
為什麼輸出是這樣的？
list_1 = [1, 2, 3, 4]
list_2 = [1, 2, 3, 4]
list_3 = [1, 2, 3, 4]
list_4 = [1, 2, 3, 4]
for idx, item in enumerate(list_1):
del item
for idx, item in enumerate(list_2):
list_2.remove(item)
for idx, item in enumerate(list_3[:]):
list_3.remove(item)
for idx, item in enumerate(list_4):
list_4.pop(idx)
print("list_1", list_1)
print("list_2", list_2)
print("list_3", list_3)
print("list_4", list_4)
結果
list_1 [1, 2, 3, 4]
list_2 [2, 4]
list_3 []
list_4 [2, 4]
list_2為什麼輸出是[2,4]? 因為在第一次刪除後，list_2變成瞭 [2,3,4], 然後在刪除輪循到到第二個數據也就是3（大部分都以為是2，但是2從原來的下表2變為1），可以參看下面的
give next element: 0 0 ---> 1 1 2 2 3 3 4 give next element: 1 0 2 1 ---> 3 2 4 give next element: 2 0 2 1 4
list_3 為什麼是[], 還記得之前我們說copy時候，copy等於[:]（淺拷貝），所以輪詢的和刪除的不是同一內存的數據。
list_4可以結合list_2思考，因為第一次刪除，第二次刪除是下標2，但是數據變瞭，下標2的數據不是原來的2，而是3.
學習鏈接
官方文檔
淺析Python中的列表和元組
總結
到此這篇關於python中列表(list)和元組(tuple)的文章就介紹到這瞭,更多相關python列表(list)和元組(tuple)內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！
推薦閱讀：
- 源碼解析python中randint函數的效率缺陷
- Python中的復雜數據類型（list、tuple）
- Python 列表(List)的底層實現原理分析
- python基礎入門之列表（一）
- tuple在python中什麼意思 python中tuple的用法