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) 空間。