关于python：将列表组合为一个


Combining lists into one

本问题已经有最佳答案，请猛点这里访问。

我正在写一个小脚本来帮助日语假名记忆。如何将以下列表组合成一个列表？我尝试如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
a = ["a",  "i",  "u",  "e",  "o"]
k = ["ka", "ki", "ku", "ke", "ko"]
g = ["ga", "gi", "gu", "ge", "go"]
s = ["sa", "shi","su", "se", "so"]
z = ["za", "ji", "zu", "ze", "zo"]
t = ["ta", "chi","tsu","te", "to"]
d = ["da",        "du", "de", "do"]
n = ["na", "ni", "nu", "ne", "no"]
h = ["ha", "hi", "hu", "he", "ho"]
b = ["ba", "bi", "bu", "be", "bo"]
p = ["pa", "pi", "pu", "pe", "po"]
m = ["ma", "mi", "mu", "me", "mo"]
y = ["ya",        "yu",        "yo"]
n = ["n"]

kana = [a, k, g, s, z, t, d, n, h, b, p, m, y, n]

print kana
相关讨论

这个问题实际上是问您如何扁平列表列表，这里给出了答案：用Python连接列表。

您可以通过执行以下操作打印出所有内容：

1
2
import itertools
print list(itertools.chain(*kana))
相关讨论

一种方式：

1
kana = a + k + g + s + z + t + d + n + h + b + p + m + y + n
相关讨论

带.extend()的显式for循环的my+1

1
2
3
4
5
6
7
8
9
10
>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
...
Readability counts.
...
In the face of ambiguity, refuse the temptation to guess.
...

当测量时，普通for循环比列表理解的副作用更快。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import itertools
import timeit

def flattenListOfLists(lst):
    result = []
    for sublist in lst:
        result.extend(sublist)
    return result

def flattenListOfLists2(lst):
    result = []
    [result.extend(sublist) for sublist in lst]  # uggly side effect ;)
    return result

def flattenIterTools(lst):
    return list(itertools.chain(*lst))


a = ["a",  "i",  "u",  "e",  "o"]
k = ["ka", "ki", "ku", "ke", "ko"]
g = ["ga", "gi", "gu", "ge", "go"]
s = ["sa", "shi","su", "se", "so"]
z = ["za", "ji", "zu", "ze", "zo"]
t = ["ta", "chi","tsu","te", "to"]
d = ["da",        "du", "de", "do"]
n = ["na", "ni", "nu", "ne", "no"]
h = ["ha", "hi", "hu", "he", "ho"]
b = ["ba", "bi", "bu", "be", "bo"]
p = ["pa", "pi", "pu", "pe", "po"]
m = ["ma", "mi", "mu", "me", "mo"]
y = ["ya",        "yu",        "yo"]
n = ["n"]

kana = [a, k, g, s, z, t, d, n, h, b, p, m, y, n]

t = timeit.timeit('lst = flattenListOfLists(kana)', 'from __main__ import kana, flattenListOfLists', number=100000)
print 'for loop:', t

t = timeit.timeit('lst = flattenListOfLists2(kana)', 'from __main__ import kana, flattenListOfLists2', number=100000)
print 'list comprehension side effect:', t

t = timeit.timeit('lst = flattenIterTools(kana)', 'from __main__ import kana, flattenIterTools
import itertools', number=100000)
print 'itertools:', t

它在我的控制台上打印：

1
2
3
for loop: 0.389831948464
list comprehension side effect: 0.468136159616
itertools: 0.620626692887

不管怎样，时间是重复同样的10万次。可读性计数是我的论点。

1
kana = sum([a, k, g, s, z, t, d, n, h, b, p, m, y, n], [])
相关讨论

另一种方法是使用lambda

1
2
3
kana = [a, k, g, s, z, t, d, n, h, b, p, m, y, n]

reduce(lambda x,y: x+y,kana)

我们还应该知道一个非常重要的事实，即扁平列表与原始列表共享原始对象。在这种情况下，这不是问题，因为对象是不可变的字符串。如果对象是可变的，在一个结构中更改它们将改变通过第二个结构可观察到的元素值。

总而言之，我们必须对Python内部结构有更多的了解。有时我们想复制原始的子列表，比如：

1
2
3
4
5
...
result = []
for sublist in lst:
    result.extend(sublist[:])     # notice the [:] here
...

1
2
3
4
5
6
7
kana = [a, k, g, s, z, t, d, n, h, b, p, m, y, n]
combined_list=[]
for x in kana:
    combined_list.extend(x)
print(combined_list)

['a', 'i', 'u', 'e', 'o', 'ka', 'ki', 'ku', 'ke', 'ko', 'ga', 'gi', 'gu', 'ge', 'go', 'sa', 'shi', 'su', 'se', 'so', 'za', 'ji', 'zu', 'ze', 'zo', 'ta', 'chi', 'tsu', 'te', 'to', 'da', 'du', 'de', 'do', 'n', 'ha', 'hi', 'hu', 'he', 'ho', 'ba', 'bi', 'bu', 'be', 'bo', 'pa', 'pi', 'pu', 'pe', 'po', 'ma', 'mi', 'mu', 'me', 'mo', 'ya', 'yu', 'yo', 'n']
相关讨论

下面是一个列表理解，其中so_on被用作示例中的一个快捷方式，以表示您要组合的实际剩余列表。

漫长的道路：

1
>>> `all_list = [e for l in [a, k, so_on] for e in l]`