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 是一种非常高效的语言，它在动态领域的应用使其非常强大。