Вопрос по list, python – Объединение списков в один [дубликат]

10

На этот вопрос уже есть ответ:

Как мне объединить два списка в Python? 30 ответов

Я пишу небольшой сценарий, чтобы помочь с запоминанием японской каны. Как бы я объединить следующие списки в один? Я пытался следующим образом.

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
Спасибо, я выполнил поиск, но ничего полезного не нашел. Эти ответы были полезны, спасибо всем! :) abkai

Ваш Ответ

8   ответов
5
kana = sum([a, k, g, s, z, t, d, n, h, b, p, m, y, n], [])
@ spinlok да,+ а такжеsum одинаково плохо для этого. Лучший способ - использоватьitertools.chain, за @JackKelly и @gnibbler, которые не создают промежуточных списков. lvc
С помощьюsum() со списками имеет квадратичную производительность. Он будет создавать новый список каждый раз, когда добавляет новый список John La Rooy
Разве это не так с оператором «+»? spinlok
1

so_on используется в качестве ярлыка только в примере для представления фактических оставшихся списков, которые вы хотите объединить.

Долгий путь:

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

Другой способ с лямбдой

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

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

один очень важный факт, что сплющенный список разделяет оригинальные объекты с оригинальным списком списков. В этом случае это не проблема, поскольку объекты являются неизменяемыми строками. Если бы объекты были изменяемыми, изменение их в одной структуре изменило бы значение элемента, наблюдаемое через вторую структуру.

Подводя итог, нужно знать немного больше о внутренностях Python. Иногда мы хотим сделать копию оригинальных списков, например:

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

Мой +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

Во всяком случае, время повторять те же 100 тысяч раз.читаемость имеет значение это мой аргумент.

13

В одну сторону

kana = a + k + g + s + z + t + d + n + h + b + p + m + y + n
Ideone.com / M9WbM dwerner
1
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']
Использование понимания списка для побочного эффекта обычно считается непифоническим John La Rooy
@ gnibbler вы правы, но я просто использовал это здесь, потому что списки понимаются быстро. Ashwini Chaudhary
В самом деле? Вы время ЛК противfor петля? John La Rooy
for x in kana:combined_list.extend(x) на 20% быстрее, чем ЖК на моем компьютере John La Rooy
@ Ashwini Chaudhary: «Перед лицом двусмысленности откажитесь от соблазна гадать». ;) Я согласен с gnibbler, но я думаю, что это ценный пример для изучения. Я не собираюсь голосовать, но не собираюсь голосовать. Побочных эффектов следует избегать (если это возможно) не только в Python. pepr
14

как эффективно сгладить этот список списков, на который вы найдете ответ: присоединиться к списку списков в Python.

Вы можете распечатать все, сделав что-то вроде:

import itertools
print list(itertools.chain(*kana))
илиchain.from_iterable(kana) John La Rooy
По моему мнению, решение itertools определенно подходит для тех, кто привык к itertools и использует модуль в другом коде. В противном случае это менее очевидно, чем использование методов основных типов. Это также медленнее - см. Timeit в моем ответе. pepr

Похожие вопросы