Python基础 7》数据类型_元组（Tuple）

一、元组的定义

思考: 列表是可变的(可修改的).如果传递的信息, 不想要被修改, 就可以使用元组.

当我们需要在程序内存储数据, 但是又希望存储的数据不被修改, 那么就可以使用元组.

元组是有序不可变的.

1. 可以容纳多个元素.
2. 可以容纳不同类型的元素.
3. 是有序的.
4. 允许元素重复.
5. 是不可变的.

元组的不可变性带来了以下好处：

1. 安全性：由于元组不可变，因此元组中的元素在创建后就不会发生改变，这有助于保护程序数据的完整性，避免意外的修改或误操作
2. 可以作为字典的键：由于元组不可变，因此可以作为字典的键，而列表不能
3. 可以作为函数参数：由于元组不可变，因此可以安全地将元组作为函数参数传递，不用担心在函数内部被修改

需要注意的是，虽然元组本身不可变，但是元组中的元素可能是可变对象，比如列表。在这种情况下，虽然元组本身不可变，但是可以通过修改列表中的元素来改变元组的值。因此，需要特别注意元组中元素的类型。

"""
元组的定义
- 元组是Python中最基本的数据结构
- 元组中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
- 元组可以进行的操作包括索引，切片，加，乘，检查成员。
- 此外，Python已经内置确定元组的长度以及确定最大和最小的元素的方法。
- 元组是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
- 元组的数据项可以是不同的类型
- 元组是不可变类型的数据
- 元组是序列类型的数据元组的语法
# 定义元组
- 变量名称 = (元素1, 元素2, 元素3, 元素4 ....)
# 定义空元组
- 变量名称 = ()
- 变量名称 = tuple()
# 定义单个元素的元组
- 变量名称 = (元素1,)
# 定义嵌套元组
- 变量名称 = ((元素1, 元素2), (元素3, 元素4))
"""
# 定义元组
nums = (1, 2, 3, 4, 5)
print(nums, type(nums))# 定义空元组
a = ()
print(a, type(a))
b = tuple()
print(b, type(b))# 定义单个元组数据
c = (1,)
print(c, type(c))# 定义嵌套的元组
d = ((1, 2), (3, 4))
print(d, type(d))# 元组的强制转换
print(f"{'-' * 10}  元组的强制转换 {'-' * 10}")
print(tuple("Python"))  # ('P', 'y', 't', 'h', 'o', 'n')
print(tuple([1, 2, 3]))  # (1, 2, 3)
print(tuple({1, 2, 3}))  # (1, 2, 3)
print(tuple({"name": "Python", "age": 18}))  # ('name', 'age')
# 强调 : 元组转换成字符串以后再转换会元组是没办法转回元组的！
data_tuple = (1, 2, 3)
data_str = str(data_tuple)  # '(1, 2, 3)'
print(data_str)  # (1, 2, 3)
data_str_tuple = tuple(data_str)
print(data_str_tuple)  # ('(', '1', ',', ' ', '2', ',', ' ', '3', ')')

二、元组的拼接

"""
元组的拼接
+ 号拼接
* 号重复
__add__() 方法拼接
__mul__() 方法重复
"""# + 号拼接
a = (1, 2, 3)
b = (4, 5, 6)
print(a + b)  # (1, 2, 3, 4, 5, 6)# * 号重复
c = (1, 2, 3)
print(c * 2)  # (1, 2, 3, 1, 2, 3)# __add__() 方法拼接
d = (1, 2, 3)
e = (4, 5, 6)
print(d.__add__(e))  # (1, 2, 3, 4, 5, 6)#  __mul__() 方法重复
f = (1, 2, 3)
print(f.__mul__(2))  # (1, 2, 3, 1, 2, 3)

三、元组的下标与切片

元组（Tuple）在 Python 中是不可变的（Immutable），这意味着一旦创建，你就不能直接修改、添加或删除其中的元素。

1.下标（索引）

"""
元组的下标
正向索引：从0开始
负向索引：从-1开始
"""
# 元组的下标
nums = (1, 2, 3, 4, 5)
print(nums[0])
print(nums[1])
print(nums[-1])# 元组可以索引取值但是不支持索引改值
# nums[0] = 100  # TypeError: 'tuple' object does not support item assignment

2.切片

"""
元组的切片：
[start:end:step]
start: 起始索引，从0开始，-1表示结束
end: 结束索引，不包含结束索引
step: 步长，默认为1元组可以切片取值但是不支持切片改值【但是可以修改元组里面的可变数据】，只要不修改其引用，可以修改其内容。
"""# 元组的切片
nums = (1, 2, 3, 4, 5)
print(f"{'*' * 10} 元组的切片-双参数 {'*' * 10}")
print(nums[1:3])  # (2, 3)
print(nums[1:])  # (2, 3, 4, 5)
print(nums[:3])  # (1, 2, 3)
print(nums[:])  # (1, 2, 3, 4, 5)
print(nums[-1:-3])  # 空
print(nums[-3:-1])  # (3, 4)
print(nums[-1:])  # (5,)
print(nums[1:-1])  # (2, 3, 4)# 步长是整数类型. 但是 它可以是负数, 它的符号, 代表步长的方向.
print(f"{'*' * 10} 元组的切片-三参数 {'*' * 10}")
print(nums[5:1:-1])  #
print(nums[5:1:-2])  #
print(nums[-1:-3:-1])  ## 思考. 如何利用切片把一个元组进行倒序/
print(f"{'*' * 10} 元组的切片-倒序 {'*' * 10}")
print(nums[::-1])# 元组可以切片取值但是不支持切片改值
# nums[1:3] = (100, 200)  # TypeError: 'tuple' object does not support item assignmentprint(f"{'*' * 10} 元组的切片-修改元组里面的可变数据 {'*' * 10}")
my_tuple = (1, 2, [3, 4])
my_tuple[2][0] = 99  # 修改元组中列表的元素
print(my_tuple)  # 输出: (1, 2, [99, 4])

四、元组的遍历与推导式

1.元组的遍历

"""
元组的遍历
- 使用for循环遍历元组
- 使用while循环遍历元组遍历方式：
1. 直接遍历元组的元素
2. 索引遍历元组的元素
3. 使用enumerate()函数遍历元组的索引和元素元组可以遍历取值但是不支持遍历改值
"""#  元组的遍历
# 1. 直接遍历元组的元素
t1 = ("Python", "C++", "Java", "PHP", "Ruby", "MATLAB")
print(f"{'-' * 10}直接遍历元组的元素{'-' * 10}'")
for item in t1:print(item)#  2. 索引遍历元组的元素
t2 = ("Python", "C++", "Java", "PHP", "Ruby", "MATLAB")
print(f"{'-' * 10}索引遍历元组的元素{'-' * 10}'")
for i in range(len(t2)):print(t2[i])# 3. 使用enumerate()函数遍历元组的索引和元素
t3 = ("Python", "C++", "Java", "PHP", "Ruby", "MATLAB")
print(f"{'-' * 10}使用enumerate()函数遍历元组的索引和元素{'-' * 10}'")
for index, item in enumerate(t3):print(f"Index {index}: {item}")

2.元组的推导式

"""
元组的推导式
与列表的推导式类似
但是元组的推导式返回的是一个生成器对象元组的推导式：
(表达式 for 变量 in 可迭代对象)
(表达式 for 变量 in 可迭代对象 if 条件)
(表达式 if 表达式 else 表达式 for 变量 in 可迭代对象)
等等生成器对象：
可以通过tuple()函数转换为元组
"""
nums = (1, 2, 3, 4, 5)# 元组的推导式
print(f"{'*' * 10} 元组的推导式 {'*' * 10}")
result = (i * 2 for i in nums)
print(result)  # <generator object <genexpr> at 0x0000020F9F9F9F48>
print(tuple(result))  # (2, 4, 6, 8, 10)# 带条件的元组推导式
print(f"{'*' * 10} 带条件的元组推导式 {'*' * 10}")
result = (i * 2 for i in nums if i % 2 == 0)
print(tuple(result))  # (4, 8)# 带if else的元组推导式
print(f"{'*' * 10} 带if else的元组推导式 {'*' * 10}")
result = (i * 2 if i % 2 == 0 else i * 3 for i in nums)
print(tuple(result))  # (3, 4, 9, 8, 15)# 嵌套的元组推导式
print(f"{'*' * 10} 嵌套的元组推导式 {'*' * 10}")
result = (i * j for i in nums for j in nums)
print(tuple(result))  # (1, 2, 3, 4, 5, 2, 4, 6, 8, 10, 3, 6, 9, 12, 15, 4, 8, 12, 16, 20, 5, 10, 15, 20, 25)# 带if条件的嵌套元组推导式
print(f"{'*' * 10} 带if条件的嵌套元组推导式 {'*' * 10}")
result = (i * j for i in nums for j in nums if i % 2 == 0 and j % 2 == 0)
print(tuple(result))  # (4, 8, 12, 16, 20)# 带if else的嵌套元组推导式
print(f"{'*' * 10} 带if else的嵌套元组推导式 {'*' * 10}")
result = (i * j if i % 2 == 0 and j % 2 == 0 else i + j for i in nums for j in nums)
print(tuple(result))  # (2, 3, 4, 5, 6, 3, 4, 6, 8, 10, 4, 5, 6, 7, 8, 5, 6, 8, 10, 12, 6, 7, 8, 9, 10)

五、元组常用的内置函数

1.常用内置函数

"""
元组的内置函数
1. 查询与统计
- len()：查询元组的长度
- count()：统计某个元素出现的次数
- index()：查找某个元素的索引
- in, not in：判断元素是否存在【成员查询】
2. 排序与反转
- sorted()：对元组进行排序，返回一个新的列表
- reversed()：对元组进行反转，返回一个新的元组
3. 其他
- max()：返回元组中的最大值
- min()：返回元组中的最小值
- sum()：返回元组中所有元素的和
"""# 1. 查询与统计
t1 = (1, 2, 3, 4, 5)
# len()：查询元组的长度
print(f"{'-' * 10} len() {'-' * 10}")
print(len(t1))# count()：统计某个元素出现的次数
print(f"{'-' * 10} count() {'-' * 10}")
print(t1.count(1))# index()：查找某个元素的索引
# 如果元素不存在，会报错
print(f"{'-' * 10} index() {'-' * 10}")
print(t1.index(1))
print(t1.index(1, 0, 5))
# print(t1.index(10))  # ValueError: tuple.index(x): x not in tuple# in, not in：判断元素是否存在【成员查询】
print(f"{'-' * 10} in, not in {'-' * 10}")
print(1 in t1)
print(1 not in t1)# 2. 排序与反转
t2 = (1, 8, 1, 6, 68, 4, 3, 2, 5)
# sorted()：对元组进行排序
print(f"{'-' * 10} sorted() {'-' * 10}")
print(sorted(t2))
print(sorted(t2, reverse=True))# reversed()：对元组进行反转
print(f"{'-' * 10} reversed() {'-' * 10}")
print(tuple(reversed(t2)))# 3. 其他
t3 = (2, 66, 3, 88, 5)
# max()：返回元组中的最大值
print(f"{'-' * 10} max() {'-' * 10}")
print(max(t3))# min()：返回元组中的最小值
print(f"{'-' * 10} min() {'-' * 10}")
print(min(t3))# sum()：返回元组中所有元素的和
print(f"{'-' * 10} sum() {'-' * 10}")
print(sum(t3))

2.高级操作【只要是可迭代对象，都适用】

这里我就不写了，有兴趣的具体可以看看Python基础 6》数据类型_列表（List）里面的内置函数的高级操作部分。

可迭代对象来说是通用的。