元组的作用

遍历

 修改

元组运算符

索引和切片

加法运算符

 重复运算符

比较运算符

完结撒花 

前言

元组(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）而不是元组。

元组运算符

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

len((1, 2, 3))

>>> a = (1, 2, 3)
>>> b = (4, 5, 6)
>>> c = a+b
>>> c
(1, 2, 3, 4, 5, 6)

>>> a = (1, 2, 3)
>>> b = (4, 5, 6)
>>> a += b
>>> a
(1, 2, 3, 4, 5, 6)

('Hi!',) * 4

3 in (1, 2, 3)

for x in (1, 2, 3): 
    print (x, end=" ")

索引和切片

元组可以使用索引和切片操作来访问元素，索引从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)  # 返回: []

解题思路：

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

实现代码 

def group_consecutive_tuples(nums, k):
    if len(nums) < k:
        return []

    start = nums[0]
    result = []

    for num in nums:
        if num == start:
            continue
        elif num == start + 1:
            start = num
        else:
            result.append(tuple(range(start, num)))
            start = num + 1

    result.append(tuple(range(start, nums[-1] + 1)))
    return result

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

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