Стоит отметить, что функция itertools.chain принимает переменное число аргументов:

>>> l1 = ['a']; l2 = ['b', 'c']; l3 = ['d', 'e', 'f']
>>> [i for i in itertools.chain(l1, l2)]
['a', 'b', 'c']
>>> [i for i in itertools.chain(l1, l2, l3)]
['a', 'b', 'c', 'd', 'e', 'f']

Если в качестве входных данных используется итерация (кортеж, список, генератор и т. Д.), Можно использовать метод класса from_iterable:

>>> il = [['a'], ['b', 'c'], ['d', 'e', 'f']]
>>> [i for i in itertools.chain.from_iterable(il)]
['a', 'b', 'c', 'd', 'e', 'f']

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]

Если вам нужен новый список с сохранением двух старых списков:

def concatenate_list(listOne, listTwo):
    joinedList = []
    for i in listOne:
        joinedList.append(i)
    for j in listTwo:
        joinedList.append(j)

    sorted(joinedList)

    return joinedList

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]

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

numpy.concatenate([a,b])

Действительно краткий способ объединить список списков

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]

Используйте простой список:

joined_list = [item for list_ in [list_one, list_two] for item in list_]

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

Как уже указывалось многими, 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
        [...]

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

>>> 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).}

Если вы не можете использовать оператор плюс (+), вы можете использовать импорт operator:

import operator

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

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

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

В качестве альтернативы вы можете также использовать функцию __add__ dunder:

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

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

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

Если вы хотите объединить два списка в отсортированном виде, вы можете использовать функцию merge из библиотеки heapq.

from heapq import merge

a = [1, 2, 4]
b = [2, 4, 6, 7]

print list(merge(a, b))

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

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

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))

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

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

>>> 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, [])

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

Начиная с версии 3.7, это наиболее популярные методы stdlib для объединения двух (или более) списков в python.

Сноски

1. Это изящное решение из-за его краткости. Но sum выполняет конкатенацию попарно, что означает, что это квадратичная операция, поскольку память должна быть выделена для каждого шага. ДЕЛАТЬ НЕ ИСПОЛЬЗОВАТЬ, если ваши списки большие.

2. См. chain а также chain.from_iterable из документов. Сначала вам нужно import itertools. Конкатенация является линейной в памяти, так что это лучший с точки зрения производительность и совместимость версий. chain.from_iterable был введен в 2.6.

3. Этот метод использует дополнительные обобщения распаковки (PEP 448), но не может обобщить до N списков, если вы сами не распаковываете вручную.

4. a += b и a.extend(b) более или менее эквивалентны для всех практических целей. += при вызове в списке вызовет внутренне list.__iadd__, который расширяет первый список на второй.

Производительность

Объединение двух списков ¹

Объединение N-списков

Графики были созданы с помощью модуля perfplot. код, для вашей справки.

_{1. Методы iadd (+=) и extend работают на месте, поэтому копию необходимо создавать каждый раз перед тестированием. Чтобы быть справедливым, все методы имеют шаг предварительного копирования для левого списка, который можно игнорировать.}

Комментарии к другим решениям

• НЕ ИСПОЛЬЗУЙТЕ МЕТОД ДАНДЕРА list.__add__ напрямую, ни в каком виде. Фактически, избегайте ненужных методов и используйте операторы и функции operator так, как они были разработаны. В Python встроена тщательная семантика, которая сложнее, чем просто прямой вызов dunder. Вот пример. Итак, чтобы подвести итог, a.__add__(b) => ПЛОХО; a + b => ХОРОШО.

• Некоторые ответы здесь предлагают reduce(operator.add, [a, b]) для парной конкатенации - это то же самое, что sum([a, b], []) только более многословно.

• Любой метод, который использует set, удалит дубликаты и потеряет порядок. Используйте с осторожностью.

• for i in b: a.append(i) более многословен и медленнее, чем a.extend(b), который является вызовом одной функции и более идиоматичен. append медленнее из-за семантики, с которой память выделяется и увеличивается для списков. Смотрите здесь для аналогичного обсуждения.

• heapq.merge будет работать, но его вариант использования предназначен для объединения отсортированных списков за линейное время. Использование его в любой другой ситуации - это анти-паттерн.

• yield получение списка элементов из функции является приемлемым методом, но chain делает это быстрее и лучше (у него есть путь к коду в C, поэтому он быстрый).

• operator.add(a, b) является приемлемым функциональным эквивалентом a + b. Это варианты использования в основном для динамической отправки метода. В противном случае предпочтите a + b, который короче и более читабелен, , на мой взгляд . YMMV .

Это довольно просто, и я думаю, что это было даже показано в учебнике:

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

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

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

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

mergedlist = list(set(listone + listtwo))

Python >= 3.5 альтернатива: [*l1, *l2]

Еще одна альтернатива была введена посредством принятия PEP 448 , который заслуживает упоминания.

PEP под названием Дополнительные обобщения распаковки обычно уменьшает некоторые синтаксические ограничения при использовании помеченного {Python} выражения {X0}} в Python; с его помощью объединение двух списков (применимо к любому итерируемому) теперь также можно сделать с помощью:

>>> l1 = [1, 2, 3]
>>> l2 = [4, 5, 6]
>>> joined_list = [*l1, *l2]  # unpack both iterables in a list literal
>>> print(joined_list)
[1, 2, 3, 4, 5, 6]

Эта функциональность была определена для Python 3.5 , она не была перенесена в предыдущие версии семейства 3.x. В неподдерживаемых версиях SyntaxError будет поднят.

Как и в случае с другими подходами, этот элемент создает также мелкую копию элементов в соответствующих списках.

Преимущество в этом подходе состоит в том, что для его выполнения вам действительно не нужны списки - все, что можно будет повторить. Как указано в ОПТОСОЗ:

Это также полезно как более читаемый способ суммирования итераций в список, такой как my_list + list(my_tuple) + list(my_range), который сейчас эквивалентно просто [*my_list, *my_tuple, *my_range].

Так что, хотя добавление с + вызовет TypeError из-за несоответствия типов:

l = [1, 2, 3]
r = range(4, 7)
res = l + r

Следующее не будет:

res = [*l, *r]

Потому что он сначала распакует содержимое итерируемых элементов, а затем просто создаст list из содержимого.

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

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