深挖 Python 元組 pt.1

哈嘍大家好，我是鹹魚

好久不見甚是想念，2023 年最後一次法定節假日已經結束了，不知道各位小伙伴是不是跟鹹魚一樣今天就開始“搬磚”了呢？

我們知道元組（tuple）是 Python 的內置數據類型，tuple 是一個不可變的值序列

tuple 的元素可以是任何類型，一般用在存儲異構數據（例如資料庫記錄）的場景

那麼今天這篇文章將帶大家深入瞭解一下 tuple 以及它們的主要功能和示例(原文較長，我分成幾個部分去講)

原文鏈接：https://realpython.com/python-tuple/

前言

tuple 是不可變的，可以存儲固定數量的元素（也可以叫項目，item）

例如可以通過 tuple 來表示笛卡爾坐標(x,y)、RGB 顏色(red,green,blue)或者資料庫表中的記錄(name,age,job)

tuple 的一些特點如下：

• 有序：裡面的元素可以按照順序排列
• 輕量級：與列表等其他序列相比，tuple 消耗的記憶體要少
• 從零開始索引：可以從零開始索引訪問裡面的元素
• 不可變：不可以改變裡面的元素
• 異構：可以存儲不同數據類型的對象（包括可變對象）
• 可嵌套：tuple 裡面可以包含 tuple
• 可迭代：能夠遍歷裡面的元素
• 可切片：可以從元組中提取一系列元素
• 可組合：支持串聯操作，可以使用串聯運算符組合多個元組
• 可哈希：裡面的元素都是不可變時可以用作字典的鍵

在 python 中，tuple 是有序的，這意味著其元素保持原始插入順序，這個順序在 tuple 的生命周期內保持不變

>>> record = ("John", 35, "Python Developer")

>>> record
('John', 35, 'Python Developer')

可以按位置或索引訪問元組中的元素（從零開始）

>>> record[0]
'John'
>>> record[1]
35
>>> record[2]
'Python Developer'

創建 tuple

tuple 是以逗號分隔的序列對象。要在元組中存儲對象，需要一次創建包含其所有內容的元組對象

直接創建

# 語法
(item_0, item_1, ..., item_n)

需要註意的是，括弧不是必需的，逗號才是。但是在大多數情況下括弧可以提高代碼的可讀性

>>> jane = ("Jane Doe", 25, 1.75, "Canada")
>>> point = (2, 7)
>>> pen = (2, "Solid", True)

>>> days = (
...     "Monday",
...     "Tuesday",
...     "Wednesday",
...     "Thursday",
...     "Friday",
...     "Saturday",
...     "Sunday",
... )

儘管括弧對於定義大多數 tuple 不是必需的，但在創建空 tuple 時必須包含它們：

>>> empty = ()
>>> empty
()

>>> type(empty)
<class 'tuple'>

因為 tuple 是不可變的，所以創建空 tuple 之後無法往裡面添加元素。到這裡有小伙伴可能會問：既然這樣為什麼還要創建一個空 tuple？

例如現在有一個構建並返回 tuple 的函數，在一些情況下這個函數不會為生成的 tuple 創建元素，這樣我們就需要返回一個空 tuple。以此來使得函數的返回值類型保持一致

除此之外，下麵的情況也需要使用到括弧

>>> "Hello, %s! You're %s years old." % ("Linda", 24)
'Hello, Linda! You're 24 years old.'

>>> "Hello, %s! You're %s years old." % "Linda", 24
Traceback (most recent call last):
    ...
TypeError: not enough arguments for format string

當我們使用 % 進行格式化輸出的時候：

• 第一種加括弧：使用括在括弧中的元組作為 % 運算符的右側操作數，按預期工作
• 第二種沒加括弧：報錯

我們創建單個元素的 tuple

>>> one_word = "Hello",
>>> one_word
('Hello',)

>>> one_number = (42,)
>>> one_number
(42,)

可以看到括弧不是必需的，尾隨逗號才是

使用 tuple() 創建

還可以使用 tuple() 從可迭代對象（列表、集合、字典或字元串）中創建 tuple，預設生成一個空 tuple

# 語法
tuple([iterable])

>>> tuple(["Jane Doe", 25, 1.75, "Canada"])
('Jane Doe', 25, 1.75, 'Canada')

>>> tuple("Pythonista")
('P', 'y', 't', 'h', 'o', 'n', 'i', 's', 't', 'a')

>>> tuple({
...     "manufacturer": "Boeing",
...     "model": "747",
...     "passengers": 416,
... }.values())
('Boeing', '747', 416)

>>> tuple()
()

通過集合來創建 tuple 時需要註意集合是無序的，會影響生成 tuple 中的元素的最終順序

如果我們從一個迭代器對象中創建一個tuple，那麼 tuple() 函數會使用迭代器逐個生成元素，然後將這些元素組合成一個元組並返回

my_list = [1, 2, 3, 4, 5] # 可迭代對象
my_iterator = iter(my_list) # 轉換為迭代器對象 my_iterator
my_tuple = tuple(my_iterator)
print(my_tuple)  # 輸出結果為：(1, 2, 3, 4, 5)

又或者從生成器表達式中創建 tuple，生成器是一種特殊的迭代器

>>> tuple(x**2 for x in range(10))
(0, 1, 4, 9, 16, 25, 36, 49, 64, 81)

tuple 索引和切片

tuple 中每一個元素都有一個整數索引，用於指定其在元組中的位置，索引從 0 開始

# 語法
tuple_object[index]

# 例子
>>> jane = ("Jane Doe", 25, 1.75, "Canada")

>>> jane[0]
'Jane Doe'
>>> jane[1]
25
>>> jane[3]
'Canada'

用不同的索引為 tuple 建立索引，可以直接訪問相關的值。如果使用大 O 符號表示時間複雜度，那麼可以說索引是一個O(1)操作

這意味著 tuple 非常適合需要快速訪問序列中的特定項的情況

len() 函數返回 tuple 長度

>>> len(jane)
4

如果使用大於或等於 tuple 長度的索引，則會報錯

>>> jane[4]
Traceback (most recent call last):
    ...
IndexError: tuple index out of range

還可以使用負索引，負索引從右端開始數起

負索引對於所有 Python 序列（例如列表和字元串）都是通用的

>>> jane[-1]
'Canada'

>>> jane[-2]
1.75

如果使用負索引，則 -len(tuple_object) 將成為元組中的第一項。如果使用低於此值的索引，則會報錯

>>> jane[-5]
Traceback (most recent call last):
    ...
IndexError: tuple index out of range

對於嵌套 tuple，我們該如何訪問到裡面的元素？

>>> employee = (
...     "John",
...     35,
...     "Python Developer",
...     ("Django", "Flask", "FastAPI", "CSS", "HTML"),
... )

答案是通過多層索引

>>> employee[-1][0]
'Django'

>>> employee[-1][1]
'Flask'

tuple 切片

和其他序列一樣，tuple 可以使用切片操作來提取其中的內容

# 語法
tuple_object[start:stop:step]

[start:stop:step] 此構造的一部分稱為切片運算符。它由一對方括弧和三個可選索引組成： start 、 stop 和 step

其中第二個冒號不是必須的，如果 step為1的話就可以省略

>>> days = (
...     "Monday",
...     "Tuesday",
...     "Wednesday",
...     "Thursday",
...     "Friday",
...     "Saturday",
...     "Sunday",
... )

>>> days[:5]
('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')

>>> days[5:]
('Saturday', 'Sunday')

不可變特性

Python 的 tuple 是不可變的，這意味著一旦你創建了一個 tuple，你就不能就地更改或更新它的元素，只能創建新的 tuple 對象

>>> jane = ("Jane Doe", 25, 1.75, "Canada")

>>> jane[3] = "United States"
Traceback (most recent call last):
    ...
TypeError: 'tuple' object does not support item assignment

tuple 不可變的另一個含義是無法對其擴容縮容，與列表不同，元組沒有.append() 、 .extend() .insert() .remove() 和 .clear() 方法

也不支持 del 語句

>>> point = (7, 14, 21)

>>> del point[2]
Traceback (most recent call last):
    ...
TypeError: 'tuple' object doesn't support item deletion

儘管 tuple 是不可變的，但是我們知道 tuple 裡面可以存儲任意類型的對象，包括可變對象

這意味著我們可以在 tuple 中存儲列表、集合、字典等其他可變對象

>>> student_info = ("Linda", 18, ["Math", "Physics", "History"])

student_info 中前兩個元素是不可變的，最後一個是列表（可變），所以我們可以對其進行更改

>>> student_info[2][2] = "Computer science"
>>> student_info
('Linda', 22, ['Math', 'Physics', 'Computer science'])

又因為 tuple 是不可變的（可哈希），所以可以用作字典中的 key

>>> student_courses = {
...     ("John", "Doe"): ["Physics", "Chemistry"],
...     ("Jane", "Doe"): ["English", "History"],
... }

>>> student_courses[("Jane", "Doe")]
['English', 'History']

如果用作 key 的 tuple 裡面包含可變元素，則會報錯

>>> student_courses = {
...     (["John", "Miguel"], "Doe"): ["Physics", "Chemistry"],
...     (["Fatima", "Jane"], "Doe"): ["English", "History"],
... }
Traceback (most recent call last):
    ...
TypeError: unhashable type: 'list'