深挖 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的话就可以省略
| Index | Description | Default Value |
|---|---|---|
start |
指定要开始切片的索引（开区间） | 0 |
stop |
指定希望切片停止提取元素的索引（闭区间） | len(tuple_object) |
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'
