элементы - список списков python




Как объединить два списка в Python? (19)

В Python вы можете объединить два массива совместимых измерений с помощью этой команды

numpy.concatenate([a,b])

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

Пример:

listone = [1, 2, 3]
listtwo = [4, 5, 6]

Ожидаемый результат:

>>> joinedlist
[1, 2, 3, 4, 5, 6]

Вы можете использовать метод append() определенный для объектов list :

mergedlist =[]
for elem in listone:
    mergedlist.append(elem)
for elem in listtwo:
    mergedlist.append(elem)

Вы можете использовать оператор + для их комбинирования:

listone = [1,2,3]
listtwo = [4,5,6]

mergedlist = listone + listtwo

Выход:

>>> mergedlist
[1,2,3,4,5,6]

Вы можете использовать функцию extends

listone.extends(listtwo)

Вы можете просто использовать оператор + или += следующим образом:

a = [1, 2, 3]
b = [4, 5, 6]

c = a + b

Или же:

c = []
a = [1, 2, 3]
b = [4, 5, 6]

c += (a + b)

Кроме того, если вы хотите, чтобы значения в объединенном списке были уникальными, вы можете:

c = list(set(a + b))

Вы также можете использовать extend , чтобы добавить list добавив конец другого:

listone = [1,2,3]
listtwo = [4,5,6]
mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)

Если вам нужно объединить два упорядоченных списка со сложными правилами сортировки, вам, возможно, придется его вручную опрокинуть, как в следующем коде (с использованием простого правила сортировки для удобочитаемости :-)).

list1 = [1,2,5]
list2 = [2,3,4]
newlist = []

while list1 and list2:
    if list1[0] == list2[0]:
        newlist.append(list1.pop(0))
        list2.pop(0)
    elif list1[0] < list2[0]:
        newlist.append(list1.pop(0))
    else:
        newlist.append(list2.pop(0))

if list1:
    newlist.extend(list1)
if list2:
    newlist.extend(list2)

assert(newlist == [1, 2, 3, 4, 5])

Если вы не можете использовать оператор плюс ( + ), вы можете использовать функцию __add__ :

listone = [1,2,3]
listtwo = [4,5,6]

result = list.__add__(listone, listtwo)
print(result)

>>> [1, 2, 3, 4, 5, 6]

В качестве альтернативы, если вам не нравится использование dunders вы можете использовать импорт operator :

import operator

listone = [1,2,3]
listtwo = [4,5,6]

result = operator.add(listone, listtwo)
print(result)

>>> [1, 2, 3, 4, 5, 6]

Можно утверждать, что это немного читаемо.


Как более общий способ для большего количества списков, вы можете поместить их в список и использовать itertools.chain.from_iterable() 1, которая на основе THIS ответа является наилучшим способом для выравнивания вложенного списка:

>>> l=[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> import itertools
>>> list(itertools.chain.from_iterable(l))
[1, 2, 3, 4, 5, 6, 7, 8, 9] 

1. Обратите внимание: chain.from_iterable() доступен в python => 2.6.В других версиях используйте chain(*l)


Как уже указывалось многими, itertools.chain() - это способ пойти, если нужно применять одинаковое обращение к обоим спискам. В моем случае у меня был ярлык и флаг, который отличался от одного списка к другому, поэтому мне было нужно что-то более сложное. Как оказалось, за кулисами itertools.chain() просто делает следующее:

for it in iterables:
    for element in it:
        yield element

(см. https://docs.python.org/2/library/itertools.html ), поэтому я получил вдохновение отсюда и написал что-то в этом роде:

for iterable, header, flag in ( (newList, 'New', ''), (modList, 'Modified', '-f')):
    print header + ':'
    for path in iterable:
        [...]
        command = 'cp -r' if os.path.isdir(srcPath) else 'cp'
        print >> SCRIPT , command, flag, srcPath, mergedDirPath
        [...]

Основные моменты, которые следует понимать здесь, - это список только случайных истребителей, которые являются объектами, как и любые другие; и что for ... in циклах в python может работать с переменными кортежа, поэтому просто петля на нескольких переменных одновременно.


Очень сжатый способ комбинировать список списков

list_of_lists = [[1,2,3], [4,5,6], [7,8,9]]
reduce(list.__add__, list_of_lists)

который дает нам

[1, 2, 3, 4, 5, 6, 7, 8, 9]

С Python 3.3+ вы можете использовать доход от :

listone = [1,2,3]
listtwo = [4,5,6]

def merge(l1, l2):
    yield from l1
    yield from l2

>>> list(merge(listone, listtwo))
[1, 2, 3, 4, 5, 6]

Или, если вы хотите поддерживать произвольное количество итераторов:

def merge(*iters):
    for it in iters:
        yield from it

>>> list(merge(listone, listtwo, 'abcd', [20, 21, 22]))
[1, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd', 20, 21, 22]

Также возможно создать генератор, который просто выполняет итерации над элементами в обоих списках. Это позволяет объединять списки (или любые итеративные) вместе для обработки без копирования элементов в новый список:

import itertools
for item in itertools.chain(listone, listtwo):
   # do something with each list item

Таким образом, есть два простых способа.

  1. Использование + : он создает новый список из предоставленных списков

Пример :

In [1]: a = [1, 2, 3]

In [2]: b = [4, 5, 6]

In [3]: a + b
Out[3]: [1, 2, 3, 4, 5, 6]

In [4]: %timeit a + b
10000000 loops, best of 3: 126 ns per loop
  1. Использование extend : добавляет новый список в существующий список. Это означает, что он не создает отдельный список.

Пример :

In [1]: a = [1, 2, 3]

In [2]: b = [4, 5, 6]

In [3]: %timeit a.extend(b)
10000000 loops, best of 3: 91.1 ns per loop

Таким образом, мы видим, что из двух самых популярных методов extend является эффективным.


Этот вопрос непосредственно задает вопрос о присоединении к двум спискам. Однако он довольно высок в поиске, даже если вы ищете способ объединения многих списков (включая случай, когда вы присоединяетесь к нулевым спискам).

Я считаю, что лучшим вариантом является использование списков:

>>> a = [[1,2,3], [4,5,6], [7,8,9]]
>>> [x for xs in a for x in xs]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Вы также можете создавать генераторы:

>>> map(str, (x for xs in a for x in xs))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

Старый ответ

Рассмотрим этот более общий подход:

a = [[1,2,3], [4,5,6], [7,8,9]]
reduce(lambda c, x: c + x, a, [])

Вывод:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Обратите внимание, что это также работает правильно, когда a является [] или [[1,2,3]] .

Однако это можно сделать более эффективно с помощью itertools :

a = [[1,2,3], [4,5,6], [7,8,9]]
list(itertools.chain(*a))

Если вам не нужен list , а просто итерабельный, опустите list() .

Обновить

Альтернатива, предложенная Патриком Коллинзом в комментариях, может также работать на вас:

sum(a, [])

Я удивлен, что никто не предложил использовать простое понимание списка :

joined_list = [y for x in [list_one, list_two] for y in x]

Он имеет все преимущества новейшего подхода к использованию дополнительных разделяющих обобщений - т. Е. Таким образом вы можете объединить произвольное количество разных итераций (например, списки, кортежи, диапазоны, генераторы) - и это не ограничивается Python >= 3.5 .


a = [1,2,3,4,5,6]
b = [7,8,9,10]
c = a.extend(b)

print (c) дает

[1,2,3,4,5,6,7,8,9,10]

import itertools

A = list(zip([1,3,5,7,9],[2,4,6,8,10]))
B = [1,3,5,7,9]+[2,4,6,8,10]
C = list(set([1,3,5,7,9] + [2,4,6,8,10]))

D = [1,3,5,7,9]
D.append([2,4,6,8,10])

E = [1,3,5,7,9]
E.extend([2,4,6,8,10])

F = []
for a in itertools.chain([1,3,5,7,9], [2,4,6,8,10]):
    F.append(a)


print ("A: " + str(A))
print ("B: " + str(B))
print ("C: " + str(C))
print ("D: " + str(D))
print ("E: " + str(E))
print ("F: " + str(F))

Выход:

A: [(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]
B: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
C: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
D: [1, 3, 5, 7, 9, [2, 4, 6, 8, 10]]
E: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
F: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

lst1 = [1,2]

lst2 = [3,4]

def list_combinationer(Bushisms, are_funny):

    for item in lst1:
        lst2.append(item)
        lst1n2 = sorted(lst2)
        print lst1n2

list_combinationer(lst1, lst2)

[1,2,3,4]




list