Python Tuple转Tuple Pair用法及代码示例

有时，在处理 Python 元组记录时，我们可能会遇到一个问题，需要将具有 3 个元素的单元组转换为双元组对。这是一个相当特殊的问题，但在日常编程和竞争性编程中可能会出现问题。让我们讨论执行此任务的某些方法。

Input : test_tuple = (‘A’, ‘B’, ‘C’) 
Output : [(‘A’, ‘B’), (‘A’, ‘C’)]

 Input : test_tuple = (‘X’, ‘Y’, ‘Z’) 
Output : [(‘X’, ‘Y’), (‘X’, ‘Z’)]

方法#1：使用product() + next() 上述函数的组合可以用来解决这个问题。在此，我们使用乘积进行配对，使用nex() 来选择与下一个元素的配对。

分步方法：

1. 首先，程序从 itertools 模块导入 product() 函数。该函数计算输入可迭代对象的笛卡尔积。
2. 然后，程序创建一个名为 test_tuple 的元组，其中包含三个元素：“G”、“F”和“G”。
3. 然后，程序使用 print() 函数和 str() 函数打印原始元组，以将元组转换为字符串。
4. 接下来，程序使用 iter() 函数从 test_tuple 创建迭代器对象。
5. 然后，程序使用 next() 函数检索 test_tuple 迭代器的第一个元素，并将其作为第一个参数传递给 product() 函数。
6. product() 函数的第二个参数是 test_tuple 迭代器本身。通过将迭代器作为参数传递，程序能够生成配对元素的序列，其中元组中的每个元素都与元组中的每个其他元素配对。
7. 然后，程序使用list()函数将product()函数的结果转换为列表。
8. 最后，程序使用print()函数和str()函数打印配对元素，将结果转换为字符串。

# Python3 code to demonstrate working of 
# Convert Tuple to Tuple Pair
# Using product() + next()
from itertools import product
# initializing tuple
test_tuple = ('G', 'F', 'G')
# printing original tuple
print("The original tuple : " + str(test_tuple))
# Convert Tuple to Tuple Pair
# Using product() + next()
test_tuple = iter(test_tuple)
res = list(product(next(test_tuple), test_tuple))
# printing result 
print("The paired records : " + str(res))

The original tuple : ('G', 'F', 'G')
The paired records : [('G', 'F'), ('G', 'G')]

时间复杂度：O(n^2)，其中 n 是输入元组的长度。
辅助空间：O(n^2)，因为结果存储在成对的列表中。然而，输入元组没有被修改，因此它对辅助空间复杂度没有贡献。

方法#2：使用repeat() + zip() + next() 使用上述函数的组合也可以解决此问题。在此，我们使用 zip() 执行配对任务，并使用 repeat() 执行重复任务。

• 导入repeat()函数从迭代工具模块。
• 初始化一个名为的元组test_tuple具有三个元素：‘G’、‘F’和‘G’.
• 使用打印原始元组print()函数和字符串连接。
• 使用以下命令将原始元组转换为对的元组repeat()、zip() 和 next()。
  • 使用以下命令将原始元组转换为迭代器iter()函数并将其存储在test_tuple.
  • 使用next()获取第一个元素的函数test_tuple并使用无限重复repeat()。
  • 采用zip()将重复的第一个元素与其余元素组合起来test_tuple.
  • 使用以下命令将结果转换为列表list()函数并将其存储在 res 中。
• 使用打印配对记录print()函数和字符串连接。

# Python3 code to demonstrate working of 
# Convert Tuple to Tuple Pair
# Using repeat() + zip() + next()
from itertools import repeat
# initializing tuple
test_tuple = ('G', 'F', 'G')
# printing original tuple
print("The original tuple : " + str(test_tuple))
# Convert Tuple to Tuple Pair
# Using repeat() + zip() + next()
test_tuple = iter(test_tuple)
res = list(zip(repeat(next(test_tuple)), test_tuple))
# printing result 
print("The paired records : " + str(res))

The original tuple : ('G', 'F', 'G')
The paired records : [('G', 'F'), ('G', 'G')]

时间复杂度：O(n)，其中 n 是输入元组的长度。
辅助空间：O(n)，其中 n 是输入元组的长度。

方法三：使用zip+切片

t = (1, 2, 3, 4)
pair_tuple = tuple(zip(t[:-1], t[1:]))
print(pair_tuple)  # Output: ((1, 2), (2, 3), (3, 4))

((1, 2), (2, 3), (3, 4))

时间复杂度：在)
辅助空间：O(1)

方法#4：使用列表理解

在此代码中，我们首先使用一些整数值定义元组 t。然后，我们使用列表理解来创建元组列表，其中每个元组包含原始元组 t 中的两个连续元素。列表理解使用 for 循环迭代 t 的索引，并创建当前索引处的元素和下一个索引处的元素的元组。循环条件中的 range(len(t)-1) 确保循环运行到元组的倒数第二个元素，这样我们在访问下一个索引时就不会越界。最后，我们使用tuple()函数将元组列表转换为元组，并打印结果。

t = (1, 2, 3, 4)
pair_tuple = tuple((t[i], t[i+1]) for i in range(len(t)-1))
print(pair_tuple)  
#This code is contributed by Vinay Pinjala.

((1, 2), (2, 3), (3, 4))

时间复杂度：O(n)，其中 n 是输入元组的长度。这是因为我们对元组进行一次迭代以创建连续元素对，并且每次迭代都需要恒定的时间。因此，算法所花费的时间随着输入的大小线性增长。
辅助空间：O(n)，其中 n 是输入元组的长度。这是因为我们正在创建一个元组列表来保存连续的元素对，在最坏的情况下最多可以有 n-1 个元素。然后，我们使用 tuple() 函数将此列表转换为元组，该函数在内存中创建一个新的元组对象。因此，算法占用的空间与输入的大小成正比。

方法#5：使用 for 循环和列表理解

The below code defines a tuple t containing the integers 1 through 4. The code then creates a new tuple of pairs by iterating over t using a list comprehension and selecting adjacent elements. The resulting pairs are stored in a tuple named pair_tuple. Finally, the code prints the resulting tuple of pairs to the console.

# Define a tuple of integers
t = (1, 2, 3, 4)
# Create a tuple of pairs by iterating over `t` and selecting adjacent elements
pair_tuple = tuple((t[i], t[i+1]) for i in range(len(t)-1))
# Print the tuple of pairs
print(pair_tuple)

((1, 2), (2, 3), (3, 4))

时间复杂度：O(n)，其中 n 是输入元组的长度。
辅助空间：在)

方法#6：递归方法。

从元组中的相邻元素创建元组的递归方法的算法如下：

1. 如果输入元组 t 的长度小于 2，则返回一个空元组，因为没有相邻对可形成。
2. 如果输入元组 t 的长度大于或等于 2，则通过迭代输入元组的索引(从 0 到 len(t)-2)并将每个元素与其相邻元素组合来创建一个新的元组对。返回这个元组对。
3. 使用不带第一个元素的输入元组 t 递归调用 pair_tuple 函数，并将结果与当前元组对连接。重复此步骤，直到输入元组的长度小于2。

def pair_tuple(t):
    # Base case: if the tuple has less than two elements, return an empty tuple
    if len(t) < 2:
        return ()
    # Recursive case: create a tuple of pairs by combining each element with its adjacent element
    return ((t[i], t[i+1]) for i in range(len(t)-1))
# Define a tuple of integers
t = (1, 2, 3, 4)
# Create a tuple of pairs by calling the pair_tuple function
pair_tuple = tuple(pair_tuple(t))
# Print the tuple of pairs
print(pair_tuple)

((1, 2), (2, 3), (3, 4))

该算法的时间复杂度为 O(n)，其中 n 是输入元组的长度，因为它需要对输入元组进行迭代一次。

该算法的辅助空间也是 O(n)，因为它需要在调用堆栈上存储每次递归调用期间创建的对的元组。

方法#7：使用map()函数

分步方法：

• 定义pair_tuple以元组 t 作为输入的函数。
• 使用map()函数创建一个新的元组迭代器，其中每个元组由原始元组的两个连续元素组成。
• 使用以下方法将迭代器转换为元组tuple()函数。
• 返回结果元组。

下面是上述方法的实现：

def pair_tuple(t):
    # Use the map() function to create an iterator of tuples
    pairs_iter = map(lambda i: (t[i], t[i+1]), range(len(t)-1))
    # Convert the iterator to a tuple
    pairs = tuple(pairs_iter)
    return pairs
# Define a tuple of integers
t = (1, 2, 3, 4)
# Create a tuple of pairs by calling the pair_tuple function
pair_tuple = pair_tuple(t)
# Print the tuple of pairs
print(pair_tuple)

((1, 2), (2, 3), (3, 4))

时间复杂度：O(n)，其中 n 是输入元组 t 的长度，因为我们需要对元组的每个元素迭代一次。
辅助空间：O(n)，因为我们需要将结果元组存储在内存中。

方法#8：使用 numpy：

算法：

1. 定义整数 t 的元组。
2. 打印原始元组t。
3. 将元组转换为 numpy 数组 a。
4. 将数组向左移动一位元素。
5. 将原始数组和移位数组组合成对并转换为元组。
6. 从元组中删除最后一对。
7. 打印生成的元组对。

import numpy as np
# Define a tuple of integers
t = (1, 2, 3, 4)
# printing original tuple
print("The original tuple : " + str(t))
  
# Convert the tuple to a numpy array
a = np.array(t)
# Shift the array by one element
shifted_a = np.roll(a, -1)
# Combine the original and shifted arrays and reshape into pairs
res = tuple(zip(a, shifted_a))[:-1]
# printing result
print("The paired records : " + str(res))
#This code is contributed by Rayudu.

输出：

The original tuple : (1, 2, 3, 4)
The paired records : ((1, 2), (2, 3), (3, 4))

时间复杂度：O(n)，其中n是输入元组的长度。这是因为代码会遍历元组一次，将其转换为 numpy 数组，再次遍历元组以移位数组，然后第三次遍历元组，将相邻元素组合成对。

空间复杂度：O(n)，其中n是输入元组的长度。这是因为代码将输入元组存储为 numpy 数组，这需要 O(n) 空间，并创建一个与输入元组长度相同的新元组，这也需要 O(n) 空间。