【Python探索之旅】元组-编程知识

元组的作用

遍历

修改

元组运算符

索引和切片

加法运算符

重复运算符

比较运算符

完结撒花

前言

元组(tuple)是一种静态的(immutable)或者说是不可变(unchangeable)的数据结构，里面的元素按照一定的顺序排列。它是静态的，所以元组里的元素不能被修改。

元组用于给数据分组。元组中的每一个元素称之为“项”(item)。

元组中的值被包装在括号中，并用逗号分隔，空元组可以写成tuple=()，不过只有一项元素的元组必须使用逗号:tuple = (“Googlel”,)。

如果使用print()函数打印元组，会得到如下的输出，其中元组依然‘()’用括号包裹

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号 ( )，列表使用方括号 [ ]。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

元组的作用

元组在Python中非常有用，特别是在需要保证数据不被更改的场景。例如，在函数中返回多个值时，使用元组可以确保这些值不会被函数外部意外修改。此外，元组也常用于有序的集合，其中元素的顺序很重要，或者当我们想要存储不可变的数据时，如函数的参数。

例如：

# 创建一个空元组
empty_tuple = ()# 创建一个包含多个元素的元组
my_tuple = (1, 2, 3, 'a', 'b', 'c')# 创建一个单个元素的元组（注意逗号是必须的）
single_element_tuple = (42,)# 元组的元素可以通过索引访问
print(my_tuple[0])  # 输出: 1
print(my_tuple[-1])  # 输出: 'c'

可以看到，元组类似于列表，0索引开始，-1为最后一位元素。

遍历

顾名思义就将一个范围内的所以值全部输出一遍，比如遍历1-100，则是将1-100之间所有的数字遍历一遍，在Python元组中，遍历这需要使用我们前面所学的for循环语句。

可以使用一个 for 循环来遍历元组

my_tuple = (1, 2, 3, 'a', 'b', 'c')for element in my_tuple:print(element)

这里，我们使用 for 循环迭代了 my_tuple，每次迭代时，都会将元组中的下一个元素赋值给 element 变量，然后我们可以在循环体内对 element 进行相应的处理。

1
2
3
a
b
c

如果需要同时获取元素的索引，可以使用 enumerate 函数：

my_tuple = (1, 2, 3, 'a', 'b', 'c')for index, element in enumerate(my_tuple):print(index, element)#输出结果
0 1
1 2
2 3
3 a
4 b
5 c

这里，我们使用了 enumerate 函数，它会在迭代元组时同时返回元素的索引和元素本身，这样我们就能在迭代过程中获取到元素的索引。

修改

在Python中，元组（tuple）是不可变的，这意味着一旦创建，就不能直接修改元组中的元素。然而，我们可以通过一些技巧来“修改”元组，实际上是创建一个新的元组，或者将元组转换为列表进行修改后再转换回元组。

方法一：将元组转换为列表进行修改

# 原始元组
original_tuple = (1, 2, 3, 4, 5)# 将元组转换为列表
list_from_tuple = list(original_tuple)# 修改列表中的元素
list_from_tuple[2] = 'modified'# 将列表转换回元组
modified_tuple = tuple(list_from_tuple)print(modified_tuple)  # 输出: (1, 2, 'modified', 4, 5)

方法二：创建一个新的元组，包含修改后的元素

# 原始元组
original_tuple = (1, 2, 3, 4, 5)# 创建一个新的元组，包含修改后的元素
modified_tuple = (original_tuple[0], original_tuple[1], 'modified', original_tuple[3], original_tuple[4])print(modified_tuple)  # 输出: (1, 2, 'modified', 4, 5)

在这些方法中，我们都没有直接修改原始元组，而是创建了一个新的元组来反映修改。原始元组保持不变，这是元组不可变性的体现。如果你需要频繁地修改数据，可能应该考虑使用列表（list）而不是元组。

元组运算符

与字符串一样，元组之间可以使用 +、+=和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
>>> a = (1, 2, 3) >>> b = (4, 5, 6) >>> c = a+b >>> c (1, 2, 3, 4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接，c 就是一个新的元组，它包含了 a 和 b 中的所有元素。
>>> a = (1, 2, 3) >>> b = (4, 5, 6) >>> a += b >>> a (1, 2, 3, 4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接，a 就变成了一个新的元组，它包含了 a 和 b 中的所有元素。
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print (x, end=" ")	1 2 3	迭代

索引和切片

元组可以使用索引和切片操作来访问元素，索引从0开始，切片遵循[start:stop:step]的格式。

tup = (1, 2, 3, 4, 5, 6)# 访问第一个元素
print(tup[0])  # 输出: 1# 访问最后一个元素
print(tup[-1])  # 输出: 6# 访问第二个到第四个元素
print(tup[1:4])  # 输出: (2, 3, 4)

加法运算符

元组可以使用加法运算符（+）来连接两个元组，形成一个新的元组。

tup1 = (1, 2, 3)
tup2 = (4, 5, 6)print(tup1 + tup2)  # 输出: (1, 2, 3, 4, 5, 6)

重复运算符

元组可以使用重复运算符（*）来重复构造一个新的元组。

tup1 = (1, 2, 3)print(tup1 * 3)  # 输出: (1, 2, 3, 1, 2, 3, 1, 2, 3)

比较运算符

元组可以使用比较运算符（<，<=，>，>=，==，!=）来进行比较。两个元组进行比较时，比较的是元组中的元素。

tup1 = (1, 2, 3)
tup2 = (1, 2, 3, 4)print(tup1 < tup2)  # 输出: True
print(tup1 == tup2)  # 输出: False

需要注意的是，元组的运算符只能用于访问元素、连接元组、重复元组、判断成员资格和进行比较。对元组中的元素进行修改是不被允许的，因为元组是不可变的。

完结撒花

讲完了，Python中的元组，接下来来看一道关于元组的算法题。

题目：

实现函数 group_consecutive_tuples，接收一个由整数组成的元组 nums 和一个整数 k 作为参数，返回一个由由长度为 k 的元组组成的列表，其中每个元组内的元素是连续的。如果 nums 中的元素数量少于 k，请返回一个空的列表。

示例：

group_consecutive_tuples((1, 2, 3, 4, 5, 6, 7), 3)  # 返回: [(1, 2, 3), (4, 5, 6), (7,)]
group_consecutive_tuples((1, 2, 3, 4, 5), 4)  # 返回: [(1, 2, 3, 4), (5,)]
group_consecutive_tuples((1, 2, 3, 4, 5, 6), 4)  # 返回: [(1, 2, 3, 4), (5, 6)]
group_consecutive_tuples((1, 2, 3), 4)  # 返回: [(1, 2, 3)]
group_consecutive_tuples((1, 2, 3, 4), 5)  # 返回: [(1, 2, 3, 4)]
group_consecutive_tuples((1, 2, 3, 4, 5, 6, 7, 8, 9), 5)  # 返回: [(1, 2, 3, 4, 5), (6, 7, 8, 9)]
group_consecutive_tuples((10, 9, 8, 7, 6, 5, 4, 3, 2, 1), 4)  # 返回: [(10, 9, 8, 7), (6, 5, 4, 3), (2, 1)]
group_consecutive_tuples((1, 2, 3, 4, 5, 6, 7, 8, 9), 10)  # 返回: [(1, 2, 3, 4, 5, 6, 7, 8, 9)]
group_consecutive_tuples((1, 2, 3, 4, 5, 6, 7, 8, 9), 11)  # 返回: []

解题思路：

初始化一个变量 start 并将其赋值为 nums[0]。
初始化一个空的列表 result，用于存储最终的结果。
遍历元组 nums，将元素 num 与变量 start 进行比较：
- 如果 num 与 start 连续，则继续遍历下一个元素。
- 如果 num 与 start 不连续，则将 start 到 num 的连续元素（包括 start 和 num）组成一个长度为 k 的元组，并将其添加到列表 result 中。然后，将 start 更新为 num + 1。
如果 nums 中的元素数量少于 k，则返回一个空的列表。
返回列表 result。

实现代码

def group_consecutive_tuples(nums, k):if len(nums) < k:return []start = nums[0]result = []for num in nums:if num == start:continueelif num == start + 1:start = numelse:result.append(tuple(range(start, num)))start = num + 1result.append(tuple(range(start, nums[-1] + 1)))return result

---------------------------------------------------------------------------------------------------------------------------------

如果对博主感兴趣欢迎大家点赞+关注，添加博主联系方式一起探索哦！