『無為則無心』Python序列 — 20、Python元組的介紹與使用

• 2021 年 7 月 6 日
• 筆記
• 測試基礎必會技能 - Python基礎

元組是一個不可變的序列。

元組的操作的方式基本上和列表是一致的，所以你在操作元組時，就把元組當成是一個不可變的列表就OK了。

一般情況下，當我們希望數據不改變時，就使用元組，其餘情況都使用列表。

1、元組的應用場景

思考：如果想要存儲多個數據，但是這些數據是不能修改的數據，怎麼做？

答：列表可以一次性存儲多個數據，但是列表中的數據允許更改。

# 結果：[100, 20, 30]
num_list = [10, 20, 30]
num_list[0] = 100
print(num_list)

這個時候，我們就可以定義一個元祖，一個元組可以存儲多個數據，元組內的數據是不能修改的。

2、定義元組

元組特點：定義元組使用小括號，且用逗號隔開各個數據，數據可以是不同的數據類型。

示例：

# 1. 定義多個元素元組
t1 = (10, 20, 30)
print(type(t1)) # <class 'tuple'>

# 2. 定義單個元素的元組
# 如果元組不是空元組，它裡邊至少要有一個逗號
t2 = (10,)
print(type(t2))

# 3. 如果單個數據的元組不加逗號
t3 = (10)
print(type(t3))  # <class 'int'>

t4 = ('aaa')
print(type(t4))  # <class 'str'>

t5 = ('aaa',)
print(type(t5)) # <class 'tuple'>

# 4.當元組不是空元組時，括號可以省略（封包）
my_tuple = 10,20,30,40
print(type(my_tuple))  # <class 'tuple'>
my_tuple1 = 40,
print(type(my_tuple1))  # <class 'tuple'>

注意：如果定義的元組只有一個數據，那麼這個數據後面也要添加逗號，否則該數據類型為對應的基本類型數據。

3、元組的常見操作

元組是不可變對象，所以不能嘗試為元組中的元素重新賦值（修改、刪除），只支持查找，具體如下：

@1、按下標查找數據

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0])  # aa

# 如果下標越界會報異常
# IndexError: tuple index out of range
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[7])

@2、index()方法

index()方法：查找某個數據，如果數據存在返回對應的下標，否則報錯。

語法和列表、字符串的index()方法相同。

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.index('aa'))  # 0

# ValueError: tuple.index(x): x not in tuple
print(tuple1.index('aaa')) 

@3、count()方法

count()方法：統計某個元素在當前元組出現的次數。沒有出現結果就是0。

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.count('bb'))  # 2
print(tuple1.count('bbb')) # 0

@4、len()方法

len()：統計元組中元素的個數。

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(len(tuple1))  # 4

4、元祖中的列表元素

注意：元組內的直接數據如果修改則立即報錯

# TypeError: 'tuple' object does not support item assignment
tuple1 = ('aa', 'bb', 'cc', 'bb')
tuple1[0] = 'aaa'

但是如果元組裏面有列表，則列表裏面的元素是支持修改的，這點要記住。

# 結果：['aa', 'bb', 'cc']
tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
print(tuple2[2])  # 訪問到列表

# 結果：(10, 20, ['孫悟空', 'bb', 'cc'], 50, 30)
tuple2[2][0] = '孫悟空'
print(tuple2)

5、擴展：序列封包和序列解包

• 序列封包：程序把多個值賦給一個變量時，Python會自動將多個值封裝成元組，這種功能叫做序列封包。
• 程序允許將序列（字符串、元組、列表等）直接賦值給多個變量，此時序列的各元素會被依次賦值給每個變量（要求序列的元素個數和變量個數相等），這種功能叫做序列解包。

（1）示例說明：

# 1.元組封包
# 多個值賦給一個變量，將多個值封裝成元組
my_tuple = 10,20,30,40
print(type(my_tuple))  # <class 'tuple'>
print(my_tuple)  # (10, 20, 30, 40)

# 2.元組解包
# 解包指就是將元組當中每一個元素都賦值給一個變量
my_tuple = (10, 20, 30, 40)
a, b, c, d = my_tuple
print("a = ", a)
print("b = ", b)
print("c = ", c)
print("d = ", d)
"""
輸出結果：
a =  10
b =  20
c =  30
d =  40
"""

# 3.序列的元素個數和變量個數相等，否則會報錯
# 結果：ValueError: too many values to unpack (expected 3)
my_tuple = 10, 20, 30, 40
a, b, c = my_tuple

（2）應用擴展：

# 1.如果元組中有100個元素，我想取前兩個。
# 可以在變量前邊添加一個*，這樣變量將會獲取元組中所有剩餘的元素
my_tuple = (10, 20, 30, 40)
a, b, *c = my_tuple
print("a = ", a)
print("b = ", b)
print("c = ", c)
"""
輸出結果：
a =  10
b =  20
c =  [30, 40]
"""

# 2.*給任何一個變量都可以
my_tuple = (10, 20, 30, 40)
a, *b, c = my_tuple
print("a = ", a)
print("b = ", b)
print("c = ", c)
"""
輸出結果：
a =  10
b =  [20, 30]
c =  40
"""

# 3.不能同時出現兩個或以上的*變量，否則會報錯
# 結果：SyntaxError: two starred expressions in assignment
my_tuple = (10, 20, 30, 40)
a, *b, *c = my_tuple

# 4.同理字符串和列表都支持序列的解包。
a , b , *c = [1,2,3,4,5,6,7]
a , b , *c = 'hello world'


# 5.字典拆包
dict1 = {'name': 'TOM', 'age': 18}
a, b = dict1

# 對字典進行拆包，取出來的是字典的key
print(a)  # name
print(b)  # age

# 通過上面的拆包得到了字典中的key名，
# 在通過key名就可以取到字典中key所對應的value值了。
print(dict1[a])  # TOM
print(dict1[b])  # 18

（3）數值交互應用

需求：有變量`a = 10`和`b = 20`，交換兩個變量的值。

# 1. 方法一
"""
1.1 定義中間的第三變量，為了臨時存儲a或b的數據
1.2 把a的數據存儲到c，做保存
1.3 把b的數據賦值到a， a = 20
1.4 把c的數據賦值到b， b = 10
"""
a = 10
b = 20

# 交互
c = 0
c = a
a = b
b = c

print("a =", a) # a = 20
print("b =", b) # b = 10


# 2.應用序列的組包，拆包
"""
兩個變量互換值，如交互a和b的值
等號右邊b,a就是一個元祖的定義。（組包）
等號左邊的兩個變量接收元組中的元素。（拆包）

輸出結果：
a = 20
b = 10
"""

a, b = b, a
print("a =", a)
print("b =", b)