在Python中将列表的列表转换为元组

Question

我有一个列表，里面又包含了很多小列表（这个是用简单的列表推导式生成的）：

>>> base_lists = [[a, b] for a in range(1, 3) for b in range(1, 6)]
>>> base_lists

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

我想把这个整个列表转换成一个元组，里面包含所有小列表中的值，也就是说：

resulting_tuple = (1,1,1,2,1,3,1,4,1,5,2,1,2,2,2,3,2,4,2,5)

有什么有效的方法可以做到这一点呢？（如果能用列表推导式生成同样的元组，那也可以接受。）我查过这里的答案和Python的文档，但一直没找到合适的。

补充：

非常感谢所有回答的人！

Answer 1

这段代码的目的是为了实现某个功能，具体来说，它可能是在处理数据或者执行某个操作。代码块中的内容通常包含了一些指令，计算或者逻辑判断，这些都是计算机需要遵循的步骤。

在编程中，我们常常会看到类似的代码结构，它们帮助我们完成特定的任务。理解这些代码的意思，可以帮助我们更好地掌握编程的基本概念。

如果你对这段代码有疑问，可以尝试逐行分析，看看每一行在做什么，或者查找相关的资料来加深理解。

>>> sum(base_lists,[])
[1, 1, 1, 2, 1, 3, 1, 4, 1, 5, 2, 1, 2, 2, 2, 3, 2, 4, 2, 5]
>>> tuple(sum(base_lists,[]))
(1, 1, 1, 2, 1, 3, 1, 4, 1, 5, 2, 1, 2, 2, 2, 3, 2, 4, 2, 5)

Answer 2

当然可以！请看下面的内容：

在编程中，有时候我们需要处理一些数据，比如从一个地方获取数据，然后在另一个地方使用这些数据。这个过程就像是把水从一个水桶倒到另一个水桶里。我们需要确保水不会洒出来，也就是说，我们要确保数据在传输过程中是安全的。

为了做到这一点，程序员们会使用一些特定的工具和方法来帮助他们管理这些数据。这些工具就像是水管，帮助我们把水（数据）顺利地从一个地方送到另一个地方。

在这个过程中，我们可能会遇到一些问题，比如数据格式不对、数据丢失等等。就像在倒水的时候，如果水桶有个洞，水就会漏掉。因此，程序员需要仔细检查每一步，确保数据能够完整无误地到达目的地。

总之，处理数据就像是一个小小的水管工，确保每一滴水都能安全到达，避免任何损失。

希望这个解释能帮助你更好地理解这个过程！

from itertools import chain
base_lists = [[a, b] for a in range(1, 3) for b in range(1, 6)]

print tuple(chain(*base_lists))

Answer 3

tuple(x for sublist in base_lists for x in sublist)

编辑：请注意，当 base_lists 很短时，生成表达式（genexp）在内存充足的情况下运行得比较慢。考虑以下文件 tu.py：

base_lists = [[a, b] for a in range(1, 3) for b in range(1, 6)]

def genexp():
  return tuple(x for sublist in base_lists for x in sublist)

def listcomp():
  return tuple([x for sublist in base_lists for x in sublist])

def withsum():
  return tuple(sum(base_lists,[]))

import itertools as it

def withit():
  return tuple(it.chain(*base_lists))

现在：

$ python -mtimeit -s'import tu' 'tu.genexp()'
100000 loops, best of 3: 7.86 usec per loop
$ python -mtimeit -s'import tu' 'tu.withsum()'
100000 loops, best of 3: 5.79 usec per loop
$ python -mtimeit -s'import tu' 'tu.withit()'
100000 loops, best of 3: 5.17 usec per loop
$ python -mtimeit -s'import tu' 'tu.listcomp()'
100000 loops, best of 3: 5.33 usec per loop

当列表变长时（也就是性能变得很重要时），情况就有点不同了。例如，在定义 base_lists 的右侧加上 100 *：

$ python -mtimeit -s'import tu' 'tu.genexp()'
1000 loops, best of 3: 408 usec per loop
$ python -mtimeit -s'import tu' 'tu.withsum()'
100 loops, best of 3: 5.07 msec per loop
$ python -mtimeit -s'import tu' 'tu.withit()'
10000 loops, best of 3: 148 usec per loop
$ python -mtimeit -s'import tu' 'tu.listcomp()'
1000 loops, best of 3: 278 usec per loop

所以对于长列表来说，只有 withsum 的性能非常糟糕——其他的性能差不多，虽然显然 itertools 更好，而列表推导（当内存充足时，微基准测试中总是会有充足的内存；-)）比生成表达式要快。

使用 1000 * 时，生成表达式的速度大约慢了10倍（相对于 100 *），而 withit 和列表推导的速度大约慢了12倍，withsum 的速度则慢了约180倍（withsum 的复杂度是 O(N平方)，而且在这个大小下，它开始遭遇严重的堆内存碎片问题）。