Python – 將列表轉換為元組中的單值列表

---

本文旨在探討將列表轉換為元組中單值列表的各種方法。我們將研究實現這一目標的 Python 程式設計方法。我們將根據輸入列表的大小討論每種方法的實現細節、時間和空間複雜度以及效率。具有基本技術背景的開發者、資料科學家和普通讀者會發現本文對於判斷最適合其特定用例的方法非常有益。

在 Python 中，將列表轉換為單值列表的元組並非一項複雜的任務。本文將重點介紹五種不同的轉換方法。請記住，還有其他幾種方法，請繼續探索。讓我們根據每種方法的實現邏輯、時間和空間複雜度來討論每種方法。之後，讀者將能夠根據自己的特定需求判斷最佳方法。

方法 1：實現遞迴函式

遞迴是程式設計中的一種方法，其中一個函式呼叫自身（使用下一個用例），最終以終止遞迴呼叫的基本情況結束。

讓我們看看程式碼

示例

def tuple_singlelist(listInput):
    if not listInput:
        return ()
    else:
        return ([listInput[0]],) + tuple_singlelist(listInput[1:])

listDemo = [1,2,3,4,5]
output_tuple = tuple_singlelist(listDemo)

# Printing the input list and the output tuple of single lists
print("input list:", listDemo)
print("output tuple:", output_tuple)

輸出

input list: [1, 2, 3, 4, 5]
output tuple: ([1], [2], [3], [4], [5])

在遞迴函式 `tuple_singlelist()` 中，我們以列表 `listInput` 作為輸入。然後，我們將列表透過 if-else 語句，檢查 `listInput` 是否為空。如果為真，則它充當基本情況並退出遞迴，返回空元組。如果為假，即 `listInput` 不為空，則取 `listInput` 的第一個元素建立一個單值列表，並將其包含在元組中。然後，使用輸入列表呼叫函式 `tuple_singlelist`，切片其第一個元素 `listInput[1:]`。

遞迴函式的時間複雜度為 O(n²)，其中 n 是列表輸入的長度。空間複雜度也是 O(n²)，其中 n 是列表輸入的長度。

方法 2：使用列表推導和元組函式

轉換最簡單的方法之一是列表推導方法。我們可以輕鬆地使用列表推導方法來解析各個元素以形成單值列表的列表。然後，可以將該列表轉換為元組。讓我們看看我們的程式碼來理解

示例

demo_list = [1,2,3,4,5]
#printing initial list
print("Initial List:"+ str(demo_list))

#Using list conversion and tuple() function
final_tuple = tuple([x] for x in demo_list)

#printing after tuple conversion
print("Final Tuple:"+ str(final_tuple))

輸出

Initial List:[1, 2, 3, 4, 5]
Final Tuple:([1], [2], [3], [4], [5])

在此程式碼中，`[x] for x in demo_list` 命令從 `demo_list` 中獲取單個元素，並建立單值的列表。接下來，`tuple()` 函式將所有形成的單值列表包含在一個元組中。

遞迴函式的時間複雜度為 O(n)，其中 n 是列表輸入的長度。空間複雜度也是 O(n)，其中 n 是列表輸入的長度。

方法 3：使用簡單的 for 迴圈、`tuple()` 和 `append()` 函式

這是一個我們可以用來分解這個問題的簡單的思路。將列表分解為單個元素，然後將單個元素放在元組中。

為了實現這一點，我們可以使用一個空列表來儲存我們的值，透過將單個元素作為列表追加。迭代由 for 迴圈執行。一旦我們有了單值列表的列表，我們就可以使用 `tuple()` 函式來建立元組。

讓我們深入研究程式碼

示例

listInput = [1,2,3,4,5]

#printing initial list
print("Initial List:"+ str(listInput))

finalList=[]
for item in listInput:
    finalList.append([item])
outputTuple = tuple(finalList)

#printing after tuple conversion
print("Final Tuple:"+ str(outputTuple))

輸出

Initial List:[1, 2, 3, 4, 5]
Final Tuple:([1], [2], [3], [4], [5])

因此，我們在上面的程式碼中所做的是，我們建立了一個空列表。現在，使用 for 迴圈迭代輸入列表中的每個專案。正如我們前面討論的那樣，`append()` 的作用在這裡，其中這些單個元素在用方括號 [] 括起來後傳遞，以建立單值列表的列表。之後，`tuple` 函式用於將生成的列表轉換為元組。

時間和空間複雜度與最後一種方法相同，即 O(n)，其中 n 是輸入列表的長度。

方法 4：結合 `map()` 和 lambda 函式

`map` 是 Python 中一個非常有用的函式，它可以幫助我們在對可迭代物件的每個專案應用特定指令後迭代任何可迭代物件。

我們可以在 `map()` 中使用 lambda 表示式來完成所需的任務。讓我們編寫一個程式碼來嘗試生成一個單值列表的元組。

示例

listInput = [1,2,3,4,5]

#printing initial list
print("Initial List:"+ str(listInput))

#implement map(lambda)
outputTuple = tuple(map(lambda ele: [ele], listInput))

#printing after tuple conversion
print("Final Tuple:"+ str(outputTuple))

輸出

Initial List:[1, 2, 3, 4, 5]
Final Tuple:([1], [2], [3], [4], [5])

如果我們檢視我們的程式碼，我們會發現它是一行簡單的程式碼，`map` 函式包含 lambda 函式，該函式為可迭代物件中的每個迭代元素提供指令，將其用方括號 [] 括起來，即建立一個列表。`map` 函式迭代 `listInput` 中的每個元素，並透過此 lambda 函式。

函式的時間複雜度為 O(n)，空間複雜度也是 O(n)。

方法 5：為 `tuple()` 建立生成器表示式

生成器表示式與列表推導有些類似，只是它生成的是生成器物件而不是列表，可以迭代該物件來建立值。

為了建立所需的元組，我們可以將生成器語句傳遞到 `tuple()` 函式中，以從每個迭代的列表元素建立單值列表。一個程式碼將使我們更容易地視覺化，讓我們看看程式碼。

示例

listInput = [1,2,3,4,5]
#printing initial list
print("Initial List:"+ str(listInput))
outputTuple = tuple([item] for item in listInput)
#printing after tuple conversion
print("Final Tuple:"+ str(outputTuple))

輸出

Initial List:[1, 2, 3, 4, 5]
Final Tuple:([1], [2], [3], [4], [5])

正如你所看到的，我們使用了一個生成器表示式，它從給定列表的每個迭代項建立單值列表。將其傳遞到 `tuple()` 中，即可得到所需的輸出。

時間複雜度和空間複雜度：O(𝑛)

結論

到目前為止，我們在本文中實現了五種不同的方法，總是有可能探索其他現有的和可能的方法來實現或獲得相同的功能或輸出。

Python 是一種非常高效的語言，它在動態領域的應用使其非常強大。