前言
在我們實際開發中，經常需要將一組數據存儲起來，以便使用。如果學習了其他的語言可能知道數組（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)內容請搜索腳本之家以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持腳本之家！
您可能感興趣的文章:- 一篇文章帶你了解python元組基礎
- Python內置數據結構列表與元組示例詳解
- python元組打包和解包過程詳解
- Python基礎之元組與文件知識總結
- Python中元組的基礎介紹及常用操作總結
