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的第一个元素创建一个单值列表，并将其封装在一个元组中。然后，使用输入列表的切片listInput[1:]重新调用函数tuple_singlelist。

递归函数的时间复杂度是O(n2)，其中n是列表输入的长度。空间复杂度也是O(n2)，其中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作为一种非常高效的语言，在动态领域的应用使其非常强大。