Python学习之元组及其操作
前面的博客里，我们详细介绍了列表（List）这一种数据类型，现在我们来讲讲与列表相似的一种数据类型，元组（Tuple）。下表是元组与列表的对比：
| 特征 | 元组 | 列表 |
|---|---|---|
| 可变性 | 不可变 | 可变 |
| 性能 | 操作上更快 | 一些操作上比较慢 |
| 语法 | 使用圆括号 () | 使用方括号 [] |
在Python中的元组（Tuple）是一种不可变序列，它可以容纳任意数量的元素，这点和列表（List）是一样的。然而，元组与列表之间有着关键的区别，这些区别也使得元组在某些情况下更为适用。
一、什么是元组？
元组由一系列元素组成，并用小括号 （）括起来。元组中的元素可以是任何类型，包括数字、字符串、列表等等。如下图：
元组的特点：
- 元组是不可变的（Immutable），一旦创建了元组，就不能再修改其中的元素。意味着与列表相比，元组更加稳定和安全。
- 元组是有序的，这意味着元组中的元素会按照一定的顺序排列。
- 元组可以重复，这意味着元组中的元素可以出现多次。
二、创建元组
创建元组只需使用圆括号 () 并在其中放置元素，元素之间用逗号 , 分隔。例如：
my_tuple = (1, 2, 3, 4, 5)
创建空元组：
empty_tuple = ()
创建只包含一个元素的元组：
single_element_tuple = (42,)
tips：这里在元素后面加上逗号，是为了以区分它与普通的表达式不同，不加的话，这里就是括号运算。
三、访问元组
在Python中，元组（tuple）可以通过索引和切片来访问其中的元素。索引从 0 开始，一直到元组的长度减 1。下面我们定义一个元组，内容包含多种数据类型，为了帮助大家理解，示例代码如下：
#🌾：定义元组 my_tuple = (1, "apple", True, 3.14, [5, 6, 7], {"name": "TiYong", "age": 25}) #🌾：使用索引访问单个元素 first_element = my_tuple[0] # 第一个元素 print("第一个元素:", first_element) second_element = my_tuple[1] # 第二个元素 print("第二个元素:", second_element) last_element = my_tuple[-1] # 最后一个元素 print("最后一个元素:", last_element) print("-" * 30) # 分隔线 #🌾：使用切片访问子序列 from_second_to_last = my_tuple[1:] # 从第二个到最后一个元素 print("从第二个到最后一个元素:", from_second_to_last) first_three_elements = my_tuple[:3] # 前三个元素 print("前三个元素:", first_three_elements) second_to_second_last = my_tuple[1:-1] # 第二个到倒数第二个元素 print("第二个到倒数第二个元素:", second_to_second_last) print("-" * 30) # 分隔线 #🌾：访问嵌套元素 first_value_in_list = my_tuple[4][0] # 访问列表元素中的第一个值 print("列表元素中的第一个值:", first_value_in_list) value_in_dict = my_tuple[5]["name"] # 访问字典元素中的值 print("字典元素中的值:", value_in_dict) print("-" * 30) # 分隔线 #🌾：使用负数索引 second_last_element = my_tuple[-2] # 倒数第二个元素 print("倒数第二个元素:", second_last_element) print("-" * 30) # 分隔线 #🌾：多层混合访问 age_value = my_tuple[5]["age"] # 获取字典中年龄的值 print("字典中年龄的值:", age_value)
具体输出如下：
第一个元素: 1 第二个元素: apple 最后一个元素: {'name': 'TiYong', 'age': 25} ------------------------------ 从第二个到最后一个元素: ('apple', True, 3.14, [5, 6, 7], {'name': 'TiYong', 'age': 25}) 前三个元素: (1, 'apple', True) 第二个到倒数第二个元素: ('apple', True, 3.14, [5, 6, 7]) ------------------------------ 列表元素中的第一个值: 5 字典元素中的值: TiYong ------------------------------ 倒数第二个元素: [5, 6, 7] ------------------------------ 字典中年龄的值: 25
四、元组的运算
在Python中，元组（tuple）是不可变的序列，它支持一些基本的运算，包括拼接、重复和成员检测等操作。
1. 拼接元组
元组可以通过加号 + 运算符进行拼接，创建一个新的元组。
tuple1 = (1, 2, 3) tuple2 = ("apple", "banana", "cherry") #🌾：+ 拼接 result_tuple = tuple1 + tuple2 print(result_tuple) #输出：(1, 2, 3, 'apple', 'banana', 'cherry')
2. 元组重复
使用乘号 * 来重复一个元组的内容。
tuple3 = ("a", "b", "c") #🌾：* 重复一个元组的内容 repeated_tuple = tuple3 * 3 print(repeated_tuple) #输出：('a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c')
3. 成员检测
使用 in 关键字来检查元素是否存在于元组中。
my_tuple = (1, 2, 3, 4, 5) #🌾：in 关键字来检查元素是否存在于元组中 print(3 in my_tuple) # True print(6 in my_tuple) # False
4. 元组长度
使用 len() 函数获取元组的长度。
my_tuple = (1, 2, 3, 4, 5) #🌾：使用 len() 函数获取元组的长度。 print(len(my_tuple)) # 5
5. 元组解包
将元组中的元素解包到多个变量中。
my_tuple = (10, 20, 30) #🌾：结构 a, b, c = my_tuple print(a) # 10 print(b) # 20 print(c) # 30
6. 比较元组
比较两个元组是否相等。
tuple1 = (1, 2, 3) tuple2 = (1, 2, 3) tuple3 = (3, 2, 1) #🌾： == 是否相等 print(tuple1 == tuple2) # True print(tuple1 == tuple3) # False
五、修改元组不可行
前面我们一直强调：元组（tuple）是一种不可变的序列类型。这意味着一旦创建了元组，就不能对其进行修改。
下面我们通过具体的代码，详细讲解，关于元组不可变性的几个重要知识点：
🌾 a. 元组创建后不可修改：元组一旦创建了，其中的元素就不能被修改、添加或删除。
my_tuple = (1, 2, 3) my_tuple[0] = 10 # 这行代码会导致错误，因为元组不可变 ###################### Traceback (most recent call last): File "Untitled-1.py", line 2, in <module> my_tuple[0] = 10 # 这行代码会导致错误，因为元组不可变 TypeError: 'tuple' object does not support item assignment
🌾b. 添加和删除元素是不允许的：与列表（list）不同，元组不支持 append()、insert()、remove() 等方法来添加或删除元素。
my_tuple = (1, 2, 3) my_tuple.append(4) # 会导致 AttributeError 错误 del my_tuple[1] # 会导致 TypeError 错误 ###################### #报错如下： Traceback (most recent call last): File "Untitled-1.py", line 2, in <module> my_tuple.append(4) # 会导致 AttributeError 错误 AttributeError: 'tuple' object has no attribute 'append'
🌾c. 元组拼接和重复会生成新元组：虽然不能直接修改现有元组，但可以通过拼接和重复操作生成新的元组。
tuple1 = (1, 2, 3) tuple2 = ("a", "b", "c") #🌾：+ 拼接 result_tuple = tuple1 + tuple2 print(result_tuple) # (1, 2, 3, 'a', 'b', 'c') #🌾：* 重复内容 repeated_tuple = tuple1 * 2 print(repeated_tuple) # (1, 2, 3, 1, 2, 3)
🌾d. 修改元组需要重新赋值：虽然不能直接修改元组，但可以通过重新赋值来实现对元组的间接修改。
my_tuple = (1, 2, 3) #🌾：+ 拼接 my_tuple = my_tuple + (4,) # 创建新的元组并赋值给原变量 print(my_tuple) # (1, 2, 3, 4)
🌾 e. 元组作为字典键：由于元组不可变性，可以作为字典的键，而列表等可变类型则不能。
#🌾：元组作为字典的键 my_dict = {(1, 2): "apple", (3, 4): "banana"} #输出 print(my_dict[(1, 2)]) # apple
六、元组的应用场景
在Python中，元组有很多应用场景，下面我们简单展示一些。
🌾 a.存储一组相关的数据：
#🌾：定义一个包含学生信息的元组列表 students = [ ('Alice', 20, 'A'), ('Bob', 21, 'B'), ('Charlie', 19, 'A-'), ('David', 22, 'B+') ] #🌾：打印每个学生的信息 for student in students: name, age, grade = student print(f"Name: {name}, Age: {age}, Grade: {grade}")
🌾 b.作为函数的参数或返回值：
#🌾：定义一个函数，返回两个数字的和与差组成的元组 def add_subtract(a, b): return (a + b, a - b) #🌾：调用函数并获取返回的元组 result = add_subtract(10, 5) sum_result, diff_result = result #🌾：输出 print(f"Sum: {sum_result}, Difference: {diff_result}")
🌾c.用于集合运算：
#🌾：定义两个元组 tuple1 = (1, 2, 3, 4, 5) tuple2 = (4, 5, 6, 7, 8) #🌾：求并集 ｜ union = set(tuple1) | set(tuple2) print("Union:", union) #🌾：求交集 & intersection = set(tuple1) & set(tuple2) print("Intersection:", intersection) #🌾：求差集 - difference = set(tuple1) - set(tuple2) print("Difference:", difference)
元组的不可变性这一点，对于许多不可变的数据结构非常有用。
浙公网安备 33010602011771号