将列表合并为一个[重复]答案

【问题标题】：Combining lists into one [duplicate]将列表合并为一个[重复]
【发布时间】：2012-05-12 13:05:25
【问题描述】：

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

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 list

【解决方案1】：

一种方式：

kana = a + k + g + s + z + t + d + n + h + b + p + m + y + n

【讨论】：

【解决方案2】：

问题实际上是在问如何展平该列表列表，此处回答：join list of lists in python。

您可以通过以下方式打印出所有内容：

import itertools
print list(itertools.chain(*kana))

【讨论】：

或chain.from_iterable(kana)
在我看来，itertools 方案绝对适合那些习惯了itertools 以及在其他代码中使用该模块的人。否则，它比使用基本类型的方法更不易于解释。它也更慢 - 请参阅我的答案中的时间。

【解决方案3】：

我对明确的 for 循环 +1 .extend()

>>> 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 循环比列表理解的副作用更快。

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\nimport itertools', number=100000)
print 'itertools:', t

它打印在我的控制台上：

for loop: 0.389831948464
list comprehension side effect: 0.468136159616
itertools: 0.620626692887

无论如何，时间是重复相同的 10 万次。 可读性很重要是我的论点。

【讨论】：

【解决方案4】：

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

【讨论】：

将sum() 与列表一起使用具有二次性能。每次添加另一个列表时，它都会创建一个全新的列表
“+”运算符不也是这样吗？
@spinlok 是的，+ 和 sum 对此同样不利。最好的方法是使用itertools.chain，根据@JackKelly 和@gnibbler，它不会构建任何中间列表。

【解决方案5】：

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

总而言之，人们必须对 Python 内部结构有所了解。有时我们想要复制原始子列表，如下所示：

...
result = []
for sublist in lst:
    result.extend(sublist[:])     # notice the [:] here
...

【讨论】：

【解决方案6】：

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']

【讨论】：

对副作用使用列表推导通常被认为是非 Python 的
@gnibbler 你是对的，但我只是在这里使用它，因为列表推导速度很快。
真的吗？您是否为 LC 与 for 循环计时？
for x in kana:combined_list.extend(x) 比我电脑上的 LC 快 20%
@Ashwini Chaudhary：“面对歧义，拒绝猜测的诱惑。” ;) 我同意 gnibbler 的观点，但我认为这是一个值得学习的宝贵例子。我不会投赞成票，但我也不会投反对票。 不仅在 Python 中应该避免（如果可能的话）副作用。

【解决方案7】：

与 lambda 的其他方式

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

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

【讨论】：

【解决方案8】：

以下是列表推导式，so_on 在示例中用作快捷方式，表示您要合并的实际剩余列表。

漫长的路：

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

【讨论】：