Question

使用Sqlite，“select..from”命令返回结果“output”，其打印（在python中）：

>>print output
[(12.2817, 12.2817), (0, 0), (8.52, 8.52)]

它似乎是一个元组列表。我想在一个简单的1D数组中转换“输出”（我猜的是Python中的列表）：

[12.2817, 12.2817, 0, 0, 8.52, 8.52]

或2x3矩阵：

12.2817 12.2817
0          0 
8.52     8.52

通过“output [i] [j]”

读取

flatten命令不能完成第一个选项的工作，我不知道第二个选项......：）

你可以给我一个提示吗？有些事情很快就会很好，因为真正的数据要大得多（这里只是一个简单的例子）。

Answer 1

到目前为止发布的最快（也是最短）的解决方案：

list(sum(output, ()))

比itertools解决方案快约50％，比map解决方案快约70％。

Answer 2

与Iterable类型一起使用的列表理解方法，并且比此处显示的其他方法更快。

flattened = [item for sublist in l for item in sublist]

l是要拼合的列表（在OP中称为output）

timeit测试：

l = list(zip(range(99), range(99)))  # list of tuples to flatten

列表理解

[item for sublist in l for item in sublist]

timeit结果=每个循环7.67 µs±129 ns

列表extend（）方法

flattened = []
list(flattened.extend(item) for item in l)

timeit结果=每个循环11 µs±433 ns

sum（）

list(sum(l, ()))

时间结果= 24.2 µs±269 ns /循环

Answer 3

在Python 3中，您可以使用*语法来展平迭代列表：

>>> t = [ (1,2), (3,4), (5,6) ]
>>> t
[(1, 2), (3, 4), (5, 6)]
>>> import itertools
>>> list(itertools.chain(*t))
[1, 2, 3, 4, 5, 6]
>>>

Answer 4

或者您可以像这样拼写列表：

reduce(lambda x,y:x+y, map(list, output))

Answer 5

使用itertools链：

>>> import itertools
>>> list(itertools.chain.from_iterable([(12.2817, 12.2817), (0, 0), (8.52, 8.52)]))
[12.2817, 12.2817, 0, 0, 8.52, 8.52]

Answer 6

>>> flat_list = []
>>> nested_list = [(1, 2, 4), (0, 9)]
>>> for a_tuple in nested_list:
...     flat_list.extend(list(a_tuple))
... 
>>> flat_list
[1, 2, 4, 0, 9]
>>>

您可以轻松地从元组列表移动到单个列表，如上所示。

Answer 7

比大数组的sum选项更快的另一个选项：

使用map / extend展平：

l = []
list(map(l.extend, output))

使用列表理解而不是地图（更快）展平

l = []
list(l.extend(row) for row in output)

更新：使用扩展进行展平但不理解且不使用列表作为迭代器（最快）

在检查了下一个答案之后，通过dual for的列表理解提供了更快的解决方案我做了一些调整，现在它表现得更好，首先执行list（...）拖了一个大的时间的百分比，然后改变一个简单循环的列表理解也削减了一点。最终的解决方案是：

l = []
for row in output: l.extend(row)

新扩展的一些时间，并通过删除[...]的列表（...）来获得改进：

import timeit
t = timeit.timeit
o = "output=list(zip(range(1000000000), range(10000000))); l=[]"
steps_ext = "for row in output: l.extend(row)"
steps_ext_old = "list(l.extend(row) for row in output)"
steps_ext_remove_list = "[l.extend(row) for row in output]"
steps_com = "[item for sublist in output for item in sublist]"

print("new extend:      ", t(steps_ext, setup=o, number=10))
print("old extend w []: ", t(steps_ext_remove_list, setup=o, number=10))
print("comprehension:   ", t(steps_com, setup=o, number=10,))
print("old extend:      ", t(steps_ext_old, setup=o, number=10))

>>> new extend:       4.502427191007882
>>> old extend w []:  5.281140706967562
>>> comprehension:    5.54302118299529
>>> old extend:       6.840151469223201

Answer 8

从数据结构和速度角度来看，这都是numpy的目的。

import numpy as np

output = [(12.2817, 12.2817), (0, 0), (8.52, 8.52)]
output_ary = np.array(output)   # this is your matrix 
output_vec = output_ary.ravel() # this is your 1d-array

Answer 9

def flatten_tuple_list(tuples):
    return list(sum(tuples, ()))


tuples = [(5, 6), (6, 7, 8, 9), (3,)]
print(flatten_tuple_list(tuples))

Answer 10

如果是任意嵌套列表（以防万一）：

def flatten(lst):
    result = []
    for element in lst: 
        if hasattr(element, '__iter__'):
            result.extend(flatten(element))
        else:
            result.append(element)
    return result

>>> flatten(output)
[12.2817, 12.2817, 0, 0, 8.52, 8.52]

将“元组列表”转换为平面列表或矩阵

10 个答案:

timeit测试：

列表理解

列表extend（）方法

sum（）