Łączenie list w jeden

Question

Piszę mały skrypt, aby pomóc w japońskim zapamiętywaniu kana. Jak połączyć poniższe listy w jedną? Próbowałem w następujący sposób.

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 

Answer 1

Jednym ze sposobów:

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

Answer 2

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

Answer 3

Pytanie jest skutecznie pytając skąd spłaszczyć ten wykaz list, który ma tutaj odpowiedzi: join list of lists in python.

Można wydrukować wszystko, robiąc coś takiego:

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

Answer 4

Poniżej znajduje się lista rozumienie ze so_on używane jako skrót tylko na przykład do reprezentowania rzeczywistych pozostałe listy, które chcesz połączyć.

Długa droga:

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

Answer 5

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

Answer 6

My +1 do wyraźnego do pętli z .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. 
... 

Podczas pomiaru, zwykły dla pętli jest większa niż ubocznych efekt przez zrozumienie listy.

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 

Drukuje na mojej konsoli:

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

Zresztą, czas jest do powtarzania tych samych 100 tysięcy razy. Czytelność liczy się jest moim argumentem.

Answer 7

Trzeba również pamiętać o Bardzo ważnym faktem, że lista spłaszczonej akcji oryginalne obiekty z oryginalnej listy list. W tym przypadku nie stanowi to problemu, ponieważ obiekty są niezmiennymi łańcuchami. Jeśli obiekty były zmienne, zmiana ich w jednej strukturze zmieniałaby wartość elementu obserwowalną przez drugą strukturę.

Podsumowując, trzeba wiedzieć trochę więcej o wewnętrznych elementach Pythona. Czasami chcemy wykonać kopię oryginalnych podlist, tak:

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

Answer 8

inny sposób z lambda

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

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