Python 常用数据结构之元组详解

3. 遍历与成员运算

可以通过循环遍历元组中的元素，也可以使用 in 和 not in 进行成员判断。

# 循环遍历元组中的元素
for elem in t1:
    print(elem)

# 成员运算
print(12 in t1)          # True
print(99 in t1)          # False
print('Hao' not in t2)   # False

4. 拼接与比较运算

元组支持拼接运算（+）和比较运算（==, >=, <= 等）。

# 拼接运算
t3 = t1 + t2
print(t3)  # (35, 12, 98, '骆昊', 43, True, '四川成都')

# 比较运算
print(t1 == t3)            # False
print(t1 >= t3)            # False
print(t1 <= (35, 11, 99))  # False

5. 特殊定义注意事项

• 空元组：() 表示空元组。
• 一元组：如果元组中只有一个元素，必须加上逗号，否则 () 仅作为改变运算优先级的圆括号。
  • ('hello', ) 和 (100, ) 是一元组。
  • ('hello') 和 (100) 只是字符串和整数。

a = ()
print(type(a))  # <class 'tuple'>
b = ('hello')
print(type(b))  # <class 'str'>
c = (100)
print(type(c))  # <class 'int'>
d = ('hello', )
print(type(d))  # <class 'tuple'>
e = (100, )
print(type(e))  # <class 'tuple'>

打包和解包操作

1. 打包操作

当把多个用逗号分隔的值赋给一个变量时，多个值会自动打包成一个元组。

# 打包操作
a = 1, 10, 100
print(type(a))  # <class 'tuple'>
print(a)        # (1, 10, 100)

2. 解包操作

将一个元组赋值给多个变量时，元组会解包成多个值分别赋给对应的变量。如果元素个数与变量个数不对应，会引发 ValueError 异常。

# 解包操作
i, j, k = a
print(i, j, k)  # 1 10 100

# 错误示例：值太多
# i, j, k = a  # ValueError: too many values to unpack (expected 3)

# 错误示例：值不足
# i, j, k, l, m, n = a  # ValueError: not enough values to unpack (expected 6, got 3)

3. 星号表达式

为了解决变量个数少于元素个数的问题，可以使用星号表达式（*）。被星号修饰的变量会接收剩余的所有值并转换为列表。注意，星号表达式在解包语法中只能出现一次。

a = 1, 10, 100, 1000
i, j, *k = a
print(i, j, k)        # 1 10 [100, 1000]

i, *j, k = a
print(i, j, k)        # 1 [10, 100] 1000

*i, j, k = a
print(i, j, k)        # [1, 10] 100 1000

解包语法适用于所有序列，包括列表、range 对象甚至字符串。

a, b, *c = range(1, 10)
print(a, b, c)        # 1 2 [3, 4, 5, 6, 7, 8, 9]

a, b, c = [1, 10, 100]
print(a, b, c)        # 1 10 100

a, *b, c = 'hello'
print(a, b, c)        # h ['e', 'l', 'l'] o

交换变量的值

在 Python 中，交换两个或多个变量的值非常便捷，无需中间变量。

# 交换两个变量
a, b = b, a

# 交换三个变量
a, b, c = b, c, a

底层机制涉及打包和解包，对于多于三个变量的互换，需要通过打包解包方式完成。

元组和列表的比较

1. 为什么需要元组？

既然有了列表，为什么还需要元组？主要原因如下：

1. 不可变性：元组是不可变类型，适合多线程环境，降低了并发访问的同步开销。
2. 性能优势：创建元组通常比创建列表更快，且占用内存更少。
3. 语义明确：当数据不应被修改时，使用元组能向其他开发者传达'只读'的意图。

2. 性能对比

使用 timeit 模块可以测试创建相同元素数量的列表和元组的时间差异。

import timeit

print('%.3f 秒' % timeit.timeit('[1, 2, 3, 4, 5, 6, 7, 8, 9]', number=10000000))
print('%.3f 秒' % timeit.timeit('(1, 2, 3, 4, 5, 6, 7, 8, 9)', number=10000000))

通常情况下，创建元组的速度显著快于列表。

3. 相互转换

元组和列表可以相互转换。

infos = ('骆昊', 43, True, '四川成都')
# 将元组转换成列表
print(list(infos))  # ['骆昊', 43, True, '四川成都']

frts = ['apple', 'banana', 'orange']
# 将列表转换成元组
print(tuple(frts))  # ('apple', 'banana', 'orange')

元组的典型应用场景

1. 作为字典的键

由于元组是不可变的，它可以作为字典的键（Key），而列表因为可变不能作为键。

scores = {
    ('Alice', 'Math'): 95,
    ('Bob', 'Math'): 88,
}
print(scores[('Alice', 'Math')])  # 95

2. 函数返回多个值

Python 函数默认返回单个值，但通过元组打包，可以方便地返回多个结果。

def get_min_max(numbers):
    return min(numbers), max(numbers)

result = get_min_max([1, 5, 3, 9, 2])
print(result)  # (1, 9)

总结

列表和元组都是容器型的数据类型，即一个变量可以保存多个数据，而且它们都是按一定顺序组织元素的有序容器。

• 列表是可变数据类型，支持添加、删除、排序等操作。
• 元组是不可变数据类型，一旦创建无法修改，更适合存储固定配置或多线程共享数据。
• 两者都支持拼接运算、成员运算、索引运算、切片运算等操作。
• 推荐使用列表生成式语法创建列表，效率高且代码简洁。

在实际开发中，如果数据不需要修改，优先使用元组可以提高程序的安全性和运行效率；如果需要频繁修改数据集合，则使用列表。