Python 笔记 — 基本数据类型（四）元组类型

一、定义

用于表示一组有序的元素，可以使用圆括号来定义元组。

元组保留了元素的顺序，可以包含不同类型的元素（如整数、字符串、列表等），可以包含重复的元素。

元组是一种不可变的数据类型，一旦创建后，其元素不能被修改。不像列表可以进行增删改操作，元组的元素是固定的。

my_tuple = (1, "apple", [2, 3, 4], "apple")
print(my_tuple) # (1, 'apple', [2, 3, 4], 'apple')

my_tuple2 = tuple([4, 5, 6])
print(my_tuple2) # (4, 5, 6)

my_tuple3 = tuple({4, 5, 6})
print(my_tuple3) # (4, 5, 6)

二、相关操作

1、访问元组

可以通过索引来访问元组中的元素，索引从 0 开始。也可以使用切片操作获取子元组。

my_tuple = (1, 2, 3)
print(my_tuple[0]) # 1

sub_tuple = my_tuple[1:3]
print(sub_tuple) # (2, 3)

2、修改元组

元组的元素不可被修改，一旦创建后，无法对元组进行增加、删除、修改等操作。

my_tuple = (1, 2, 3)
my_tuple[0] = 4 # 报错：TypeError: 'tuple' object does not support item assignment

3、len

获取元组的长度，即元素的个数。

my_tuple = (1, 2, 3)
length = len(my_tuple)
print(length) # 3

4、count

用于统计某个元素在元组中出现的次数。

my_tuple = (1, 2, 3, 2, 4, 2)
count = my_tuple.count(2)
print(count) # 3

5、index

用于查找元素的索引位置。

my_tuple = (1, 2, 3, 2, 4, 2)
index = my_tuple.index(4)
print(index) # 4

6、解析

使用逗号 , 分隔变量名，将元组中的元素按顺序赋值给对应的变量。

左侧变量的数量必须与元组中的元素数量相等，否则会引发 ValueError 错误。

主要用于将元组中的元素按顺序解包到多个变量中，方便获取和使用元组的各个元素。

my_tuple = (1, 2, 3)
a, b, c = my_tuple
print(a, b, c) # 1 2 3

7、解包

使用等号 = 将元组赋值给变量，不需要使用逗号。

解包时，变量的数量可以与元组中的元素数量不相等，可以使用 * 操作符来处理剩余的元素。

可以用于交换变量的值、将多个变量打包成元组、从元组中提取元素等更广泛的应用。

# 交换变量的值
a = 10
b = 20
a, b = b, a
print(a, b) # 20 10

# 将多个变量打包成元组
x = 1
y = 2
z = 3
coordinates = x, y, z
print(coordinates) # (1, 2, 3)

# 从元组中提取元素
my_tuple = (1, 2, 3)
first, *rest = my_tuple
print(first) # 1
print(rest) # [2, 3]

三、元组嵌套

# 元组嵌套
nested_tuple = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
print(nested_tuple) # ((1, 2, 3), (4, 5, 6), (7, 8, 9))

# 访问嵌套元组中的元素
print(nested_tuple[0]) # (1, 2, 3)
print(nested_tuple[1][2]) # 6

# 修改嵌套元组中的元素是不允许的，因为元组是不可变的数据类型

# 迭代遍历嵌套元组
for subtuple in nested_tuple:
    for item in subtuple:
        print(item, end=' ')
    print()
# 1 2 3
# 4 5 6
# 7 8 9

四、元组推导式

在 Python 中，元组推导式（Tuple comprehension）是一种用于创建元组的简洁方式。然而，元组推导式在语法上与列表推导式和集合推导式略有不同，因为元组是不可变的。
需要注意的是，元组推导式返回一个生成器表达式，如果需要将其转换为元组，可以使用 tuple() 函数进行转换。

基本形式：

(表达式 for 元素 in 可迭代对象) 或者 (表达式 for 元素 in 可迭代对象 if 条件)

1、从列表中选择大于 5 的偶数并构建一个元组

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
new_tuple = tuple(x for x in numbers if x > 5 and x % 2 == 0)
print(new_tuple) # (6, 8, 10)

2、创建一个元组，计算数字列表中所有数的平方

numbers = [1, 2, 3, 4, 5]
squares = tuple(x**2 for x in numbers)
print(squares) # (1, 4, 9, 16, 25)

3、创建一个元组，输出列表中每个单词的长度

words = ["apple", "banana", "cherry", "date"]
word_lengths = tuple(len(word) for word in words)
print(word_lengths) # (5, 6, 6, 4)

五、使用 for 循环遍历

my_tuple = ('a', 'b', 'c')
for i in my_tuple:
    print(i)
# a
# b
# c

六、enumerate 枚举

当我们需要遍历元组并获取每个元素的索引时，可以使用枚举（enumerate）函数。枚举函数会返回一个可迭代对象，其中每个元素是由索引和对应的元素值组成的。

my_tuple = ('a', 'b', 'c')
for index, value in enumerate(my_tuple):
    print(index, value)
# 0 a
# 1 b
# 2 c

七、使用 while 循环

my_tuple = ('a', 'b', 'c')
my_tuple_len = len(my_tuple)
i = 0
while i < my_tuple_len:
    print(my_tuple[i])
    i += 1
# a
# b
# c

八、应用

1、打印出成绩最高的学生的姓名和最高成绩。

# 定义一个元组列表，表示多个学生的成绩信息
students = [("Alice", 90),
            ("Bob", 80),
            ("Charlie", 95),
            ("David", 87)]

# 找出成绩最高的学生
max_grade = 0
top_student = None

for student in students:
    name, grade = student
    if grade > max_grade:
        max_grade = grade
        top_student = name

# 打印成绩最高的学生信息
print("成绩最高的学生是：", top_student)
print("最高成绩：", max_grade)

# 成绩最高的学生是： Charlie
# 最高成绩： 95

2、计算不同城市的平均气温。

# 定义一个元组列表，表示不同城市的气温数据
temperature_data = [
    ("北京", (18, 21, 20)),
    ("上海", (25, 30, 27)),
    ("深圳", (22, 26, 24)),
    ("广州", (30, 33, 32))
]

# 计算每个城市的平均气温
average_temperatures = []
for city, temperatures in temperature_data:
    average_temp = sum(temperatures) / len(temperatures)
    average_temperatures.append((city, average_temp))

# 打印每个城市的平均气温
for city, avg_temp in average_temperatures:
    print("{} 的平均气温为: {:.2f}".format(city, avg_temp))

# 北京 的平均气温为: 19.67
# 上海 的平均气温为: 27.33
# 深圳 的平均气温为: 24.00
# 广州 的平均气温为: 31.67

记录学习过程，欢迎讨论交流，尊重原创，转载请注明出处~