python中列表(list)和元組(tuple)的區別

這期內容當中小編將會給大家帶來有關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

 上面的運行結果顯示： 元組初始化遠快于列表  ，大概有五倍的差距，但是索引操作的時候速度沒有多大差距

截止目前為止，我們可以簡單總結列表和元組的區別有如下：

1. 元組使用tuple()或()初始化，列表使用list()或[]初始化

2. 元組是靜態，而列表是動態

3. 列表需要更多內存，元組需要更少內存

4. 列表不可被hash，元組可以被hash

5. 元組初始化效率高于列表，但索引操作沒有多大差距
   

元組和列表使用場景

再說使用場景前先講一下，在python后臺，對靜態數據做一些資源緩存，通常因為垃圾回收機制的存在，一些變量不使用，python就會回收他們所占的內存，但是對于一些靜態變量（比如說元組），當他們占用不大時候（長度1~20的元組），python會暫時緩存這部分內存，這樣下次就可以不再向操作系統發出請求，分配內存資源，而是直接使用用緩存中之前的內存空間，這樣大大加快了程序的運行速度。所以一般有時候數據量不大，我經常使用元組替代列表。到目前為止我們可以簡單的總結出場景可以如下所示：

1. 如果數據不可變，我們就可以考慮使用元組，比如說性別類型，返回出去的城市信息等等

2. 如果數據可變，我們就考慮使用列表，比如說用戶當天訪問的網頁等等
   

拓展知識

創建空的列表，是使用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中列表(list)和元組(tuple)的區別了，如果剛好有類似的疑惑，不妨參照上述分析進行理解。如果想知道更多相關知識，歡迎關注億速云行業資訊頻道。