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

avatar
y2k
12 ноября 2009 в 07:04
3170611
36
3028

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

Пример:

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

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

>>> joinedlist
[1, 2, 3, 4, 5, 6]
Источник
smci
12 сентября 2015 в 07:51
11

Вы хотите просто добавить или хотите объединить два списка в отсортированном порядке ? Какой результат вы ожидаете для [1,3,6] и [2,4,5]? Можно ли предположить, что оба подсписка уже отсортированы (как в вашем примере)?

smci
12 января 2020 в 20:15
1

... также что, если в списках есть дубликаты, например [1,2,5] and [2,4,5,6]? Вы хотите, чтобы дубликаты были включены, исключены или не нужны?

Brendan Metcalfe
25 июня 2020 в 18:48
5

Я сделал на YouTube учебник о 6 способах объединения списков, если кто-то сочтет это полезным youtube.com/watch?v=O5kJ1v9XrDw

Ответы (36)

avatar
Daniel G
12 ноября 2009 в 07:07
4597

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

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

joinedlist = listone + listtwo

Вывод:

>>> joinedlist
[1,2,3,4,5,6]
Daniel F
19 апреля 2012 в 12:34
135

создает ли это глубокую копию listone и добавляет listtwo?

Daniel G
19 апреля 2012 в 14:51
183

@Daniel создаст новый список с мелкой копией элементов в первом списке, за которой следует неглубокая копия элементов во втором списке. Используйте copy.deepcopy для получения глубоких копий списков.

rickcnagy
29 января 2014 в 16:14
262

здесь еще одна полезная деталь: listone += listtwo приводит к listone == [1, 2, 3, 4, 5, 6]

MikeH
19 февраля 2014 в 05:01
18

@ br1ckb0t изменит ли это то, на что указывает listone? Итак: list3 = listone listone+=listtwo List3 тоже изменился?

Guy
19 февраля 2014 в 18:11
4

@MikeH Да, он меняет list3.

rickcnagy
20 февраля 2014 в 18:55
12

он меняет list3. Однако, если это не проблема, проще добавить два списка вместо создания нового.

Pygmalion
8 апреля 2015 в 18:27
3

ВНИМАНИЕ: я не знаю, является ли это особенностью Python3, но в некоторых случаях (массив numpy) [1,2,3] + [4] дает [5,6,7] !!!

153957
16 апреля 2015 в 11:42
5

@Pygmalion Это не относится к Python3, а зависит от того, как массивы NumPy обрабатывают операторы. См. Ответ Дж. Ф. Себастьяна в ответе Роберта Россни на объединение массивов NumPy.

Epsi95
22 января 2021 в 19:55
1

@rickcnagy listone += listtwo следует избегать. list.extend() следует использовать. listone.extend(listtwo)

Anvita Shukla
23 апреля 2021 в 19:13
0

у этого решения есть проблема, заключающаяся в том, что при использовании sort () или других функций списка они работают с отдельными списками в этом вновь созданном списке.

avatar
Ali Hassan
8 марта 2022 в 09:21
-1

Это другое решение

list1 =[1,2,3,4]
list2 =['a','b']
for item in list2:
    list1.append(item)
list1 
avatar
LunaticXXD10
13 января 2022 в 19:00
1

ПРОСТО ИСПОЛЬЗУЙТЕ функцию extend(), и вы будете жить счастливой жизнью

avatar
LunaticXXD10
10 января 2022 в 05:51
0

Вы можете использовать предоставленный метод «продлить».

LIST_1 = [1,2,3]
LIST_2 = [4,5,6]
LIST_1.extend(LIST_2)
print(LIST_1)

Вывод:

[1,2,3,4,5,6]
artemis
13 января 2022 в 03:59
0

Метода extand не существует.

LunaticXXD10
13 января 2022 в 18:58
0

@artemis О, мой плохой, это было «расширение», а не расширение, и я внес исправление в свой код.

avatar
Franz Kurt
29 декабря 2021 в 20:28
0

Наиболее распространенный метод, используемый для объединения списков, — это оператор плюс и встроенный метод append, например:

list = [1,2]

list = list + [3]
# list = [1,2,3]

list.append(3) 
# list = [1,2,3]

list.append([3,4]) 
# list = [1,2,[3,4]]

В большинстве случаев это будет работать, но функция append не расширит список, если он был добавлен. Поскольку этого не ожидается, вы можете использовать другой метод с именем extend, который должен работать со структурами:

list = [1,2]
list.extend([3,4]) 
# list = [1,2,3,4]
avatar
Khan
2 ноября 2021 в 09:54
0

Предоставленные решения относятся к одному списку. В случае, если в списке есть списки и требуется объединение соответствующих списков. Работает операция "+" через цикл for.

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

b=[[0,1,2],[7,8,9]]

for i in range(len(a)):
    cc.append(a[i]+b[i])

вывод: [[1, 2, 3, 0, 1, 2], [4, 5, 6, 7, 8, 9]]

avatar
Dilshan Madhuranga
3 октября 2021 в 09:28
5

Я рекомендую три метода для объединения списка, но наиболее рекомендуется 1-й метод,

# easiest and least complexity method <= recommended

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

newlist = listone + listtwo
print(newlist)

# 2nd easiest method
newlist = listone.copy()
newlist.extend(listtwo)
print(newlist)

Во втором способе я назначаю newlist копии listone, потому что не хочу изменять listone.

# 3rd method
newlist = listone.copy()
for j in listtwo:
    newlist.append(j)

print(newlist)

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

avatar
U12-Forward
12 сентября 2021 в 01:48
2

Вы также можете просто использовать sum.

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> sum([a, b], [])
[1, 2, 3, 4, 5, 6]
>>> 

Это работает для любой длины и любого типа элементов списка:

>>> a = ['a', 'b', 'c', 'd']
>>> b = [1, 2, 3, 4]
>>> c = [1, 2]
>>> sum([a, b, c], [])
['a', 'b', 'c', 'd', 1, 2, 3, 4, 1, 2]
>>> 

Причина, по которой я добавляю [], заключается в том, что аргумент start по умолчанию установлен на 0, поэтому он перебирает список и добавляет к start, но 0 + [1, 2, 3] выдаст ошибку, поэтому если мы установим start в [], это добавит к [], [] + [1, 2, 3] будет работать как положено.

avatar
kannappan
2 сентября 2021 в 09:11
4

Вы можете использовать метод .extend

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

Теперь, когда вы это сделаете,

print(listone)

У вас будет этот список,

[1,2,3,4,5,6]
avatar
say_my_name
2 июня 2021 в 10:04
4

Другой способ:

>>> listone = [1, 2, 3]
>>> listtwo = [4, 5, 6]
>>> joinedlist = [*listone, *listtwo]
>>> joinedlist
[1, 2, 3, 4, 5, 6]
>>> 
avatar
Haris ramzan
17 мая 2021 в 21:02
0

просто добавьте эти два списка //

финалист = список1 + список2

Dominik
17 мая 2021 в 21:19
0

Хотя это может ответить на его вопрос, было бы лучше объяснить его немного подробнее e. г. добавить к нему код.

avatar
mr potato head
17 января 2021 в 00:30
-4

Вы можете использовать функцию union () в Python.

joinedlist = union(listone, listtwo)
print(joinedlist)

По сути, это удаляет по одному из каждого дубликата в двух списках. Поскольку в ваших списках нет дубликатов, он просто возвращает объединенную версию двух списков.

maczos
22 января 2021 в 13:05
1

union не работает со списками, вы можете использовать его с наборами или dict

mr potato head
23 января 2021 в 00:58
1

о да, извините, я не использовал его в течение долгого времени, моя плохая

avatar
Satyajit Satapatathy
14 ноября 2020 в 02:15
0

Я полагаю, вам нужен один из двух методов:

Сохранить повторяющиеся элементы

Это очень просто, просто объедините как строку:

def concat_list(l1,l2):
    l3 = l1+l2
    return l3

Далее, если вы хотите удалить повторяющиеся элементы

def concat_list(l1,l2):
   l3 = []
   for i in [l1,l2]:
     for j in i:   
       if j not in l3:   
         #Check if element exists in final list, if no then add element to list
         l3.append(j)
   return l3
avatar
Code Carbonate
7 июля 2020 в 15:30
1
 a=[1,2,3]
 b=[4,5,6]

 c=a+b
 print(c)

ВЫХОД :

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

В приведенном выше коде оператор "+" используется для объединения двух списков в один.

ДРУГОЕ РЕШЕНИЕ:

 a=[1,2,3]
 b=[4,5,6]
 c=[] #Empty list in which we are going to append the values of list (a) and (b)

 for i in a:
     c.append(i)
 for j in b:
     c.append(j)

 print(c)

ВЫХОД :

>>> [1, 2, 3, 4, 5, 6]
avatar
Gourneau
30 мая 2020 в 18:02
242

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

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

listone.extend(listtwo)

Если вы хотите сохранить исходный список без изменений, вы можете создать новый объект list и extend оба списка к нему:

mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)
Ayush
15 июля 2021 в 09:10
1

Почему в моем случае этот метод возвращает None?

Ayush
15 июля 2021 в 09:15
0

listone = [1,2,3]; listtwo = [4,5,6]; listone.extend(listtwo) это возвращает мне None

Gourneau
16 июля 2021 в 17:33
0

Он выполняет обновление на месте до listone. Так что проверьте, что есть в списке listone

Ayush
17 июля 2021 в 17:45
0

на самом деле я возвращаю выражение, в котором я расширяю список с помощью упомянутого вами метода. Я не переназначаю список, как сказано в этой публикации. Мое выражение похоже на return list1.extend(list2), и это выражение возвращает мне None.

avatar
cs95
1 июня 2019 в 15:20
194

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

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

enter image description here

Сноски

  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__, который расширяет первый список вторым.


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

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

enter image description here

Между этими методами нет большой разницы, но это имеет смысл, учитывая, что все они имеют одинаковый порядок сложности (линейный). Нет особых причин отдавать предпочтение одному другому, кроме как по стилю.

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

enter image description here

Графики были созданы с использованием модуля 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.

endolith
21 августа 2019 в 01:31
0

в ответах на coderhelper.com/q/36863404/125507 можно использовать график perfplot (включая решение numba)

cs95
21 августа 2019 в 17:52
0

@endolith немного завален работой, но я посмотрю, смогу ли я вмешаться. Тай.

GD- Ganesh Deshmukh
19 мая 2020 в 05:06
0

Какой метод лучше, а быстрее - с точки зрения производительности? пожалуйста скажи.

cs95
19 мая 2020 в 20:21
1

@ganeshdeshmukh TL; DR - все они хороши, и какой из них вы выберете, в основном вопрос стиля. "There's not much difference between these methods but that makes sense given they all have the same order of complexity (linear). There's no particular reason to prefer one over the other except as a matter of style. «Решения, не указанные в моем ответе или не подвергшиеся критике в« Комментарии », я рекомендую не использовать.

avatar
Vishvajit Pathak
24 августа 2018 в 16:25
3

Итак, есть два простых пути.

  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. Использование расширения : добавляет новый список к существующему списку. Это означает, что он не создает отдельный список.

Пример:

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.

Tweakimp
11 марта 2019 в 21:49
2

Что, если мне нужно добавить несколько списков, например a + b + c + d + e?

cs95
4 июня 2019 в 03:53
2

@Tweakimp См. Этот ответ, в котором есть несколько вариантов (я рекомендую chain.from_iterable).

avatar
Michael Grossmann
4 августа 2018 в 17:29
8

Если вы используете NumPy, вы можете объединить два массива совместимых размеров с помощью этой команды:

numpy.concatenate([a,b])
cs95
4 июня 2019 в 02:37
8

Вопрос не требует numpy.

Aaron John Sabu
3 февраля 2021 в 21:30
0

@ cs95 он также не «не просит» numpy. Я должен сказать, что это действительно помогло мне, так как оператор плюс не работал в моем приложении

avatar
z33k
4 июня 2018 в 12:49
8

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

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

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

avatar
Akash Singh
26 марта 2018 в 17:48
4

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

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]
cs95
4 июня 2019 в 02:38
0

Не используйте list.__add__, используйте вместо него operator.add. Это более многословный эквивалент sum(list_of_lists, []), что так же плохо. НЕ ИСПОЛЬЗОВАТЬ!

Akash Singh
6 июня 2019 в 22:31
0

@ cs95, можете ли вы объяснить, в чем проблема, используя list .__ add__

cs95
6 июня 2019 в 22:33
1

dunder методы являются «частными методами» и обычно не должны использоваться напрямую (они вызываются другими функциями). Исключения: obj.__class__ и obj.__dict__.

avatar
JamesVeug
16 февраля 2018 в 03:46
-1
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]
avatar
SuperNova
7 июля 2016 в 07:42
7
list(set(listone) | set(listtwo))

Приведенный выше код не сохраняет порядок, удаляет дубликаты из каждого списка (но не из объединенного списка)

avatar
Dimitris Fasarakis Hilliard
25 февраля 2016 в 15:13
417

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

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

PEP, озаглавленный Дополнительные обобщения распаковки , обычно уменьшал некоторые синтаксические ограничения при использовании помеченного звездочкой выражения * в 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.

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


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

Это также полезно как более удобный способ суммирования итераций в список, например 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 из содержимого.

alan
9 апреля 2019 в 16:15
9

Хорошим примером подхода к распаковке, работающего с итеративными типами, являются функции, возвращающие итератор по одному из списков, которые вы объединяете. Например, вы можете перевернуть один из списков, которые вы объединяете: res = [*l1, *reversed(l2)]. Поскольку reversed возвращает итератор, res = l1 + reversed(l2) вызовет ошибку.

Kevin S
8 мая 2019 в 18:16
4

Стоит отметить, что это аналогично объединению словарей в Python. dict3 = {** dict1, ** dict2}. Обратите внимание, что мы используем ** для распаковки словаря, тогда как со списками мы используем * для распаковки.

Marcello Romani
25 февраля 2021 в 10:39
1

Грамматика во мне должна указывать на: * словари

avatar
Francesco Marchetti-Stasi
2 ноября 2015 в 18:59
6

Как уже отмечалось многими, 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 могут работать с кортежными переменными, поэтому можно просто выполнить цикл по нескольким переменным одновременно.

avatar
wonder.mice
9 октября 2015 в 23:21
60

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

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

>>> 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, [])
Dimitris Fasarakis Hilliard
24 июля 2017 в 18:00
5

Примечание Python 3: reduce теперь находится в functools, поэтому вам нужно сначала импортировать его.

avatar
lavee_singh
7 июля 2015 в 13:30
23

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

from heapq import merge

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

print list(merge(a, b))
avatar
kasravnd
6 июля 2015 в 20:06
19

Для случаев с небольшим количеством списков вы можете просто сложить списки вместе или использовать распаковку на месте (доступно в Python-3.5 +):

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

In [2]: listone + listtwo                                                                                                                                                                                   
Out[2]: [1, 2, 3, 4, 5, 6]
                                                                                                                                                                                     
In [3]: [*listone, *listtwo]                                                                                                                                                                                
Out[3]: [1, 2, 3, 4, 5, 6]

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

>>> 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)`.
avatar
jpihl
20 октября 2014 в 09:32
17

Если вы не можете использовать оператор плюс (+), вы можете использовать импорт 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]
Dimitris Fasarakis Hilliard
4 июля 2017 в 12:00
4

схватить дандерс - вообще не лучший подход. Если + отсутствует в таблице, используйте operator.add.

cs01
25 июня 2018 в 19:36
2

Почему оператор "плюс" будет недоступен?

jpihl
26 июня 2018 в 04:30
2

Обычно это не так :), но если вы выполняете конкатенацию списка с функцией карты или хотите сохранить функцию добавления в переменной, вы не можете использовать +.

avatar
user688635
21 июля 2014 в 00:53
28

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

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]
Boris
22 ноября 2019 в 12:49
1

Вы можете использовать itertools.chain (что эквивалентно) вместо определения вашей собственной функции.

avatar
Mr Shark
7 ноября 2013 в 18:04
12

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

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])
cs95
4 июня 2019 в 04:21
0

Или просто используйте heapq.merge.

avatar
mingxiao
16 июля 2013 в 02:02
7

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

mergedlist =[]
for elem in listone:
    mergedlist.append(elem)
for elem in listtwo:
    mergedlist.append(elem)
Ryan Haining
16 июля 2013 в 02:10
9

просто чтобы вы знали, если это то, что вы делаете на практике, это намного медленнее, чем другие предлагаемые методы. см. coderhelper.com/questions/17479361/…

avatar
Amyth
5 марта 2013 в 09:15
45

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

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))
Boris
24 ноября 2019 в 02:29
2

Последняя часть может произвольно переупорядочивать предметы. Если вы хотите сохранить порядок, в CPython 3.6+ вы можете сделать list(dict.fromkeys(a + b))

avatar
Dariusz Walczak
5 февраля 2013 в 05:01
31

Стоит отметить, что функция 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']
avatar
Radagast
20 сентября 2010 в 08:43
244

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

mergedlist = list(set(listone + listtwo))
metasoarous
21 августа 2012 в 00:28
59

Правда, однако, он также удалит дубликаты, если это то, что вас интересует. Добавление списка не сделало бы этого.

Natim
29 января 2013 в 13:12
2

Как это сделать и сохранить информацию для заказа?

Natim
29 января 2013 в 13:13
14

Лучше, чем listone + [x for x in listtwo if x not in listone]

Nir Alfasi
27 апреля 2014 в 04:07
9

+1 ИМХО, это правильный способ «слить» (объединить) списки, в то время как «одобренный» ответ описывает, как объединять / добавлять списки (мультимножество)

SethMMorton
15 декабря 2016 в 20:11
3

Если вы заботитесь о поддержании порядка ввода, то import collections; mergedlist = list(collections.OrderedDict.fromkeys(listone + listtwo)) поможет.

Boris
22 ноября 2019 в 12:40
0

Если вы заботитесь о поддержании порядка, в CPython 3.6+ вы можете сделать mergedlist = list(dict.fromkeys(listone + listtwo))

avatar
Robert Rossney
12 ноября 2009 в 20:01
366

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

import itertools
for item in itertools.chain(listone, listtwo):
    # Do something with each list item
cs95
4 июня 2019 в 14:10
9

chain медленнее (но ненамного) для двух списков, но это самое быстрое решение для объединения нескольких списков (n >> 2).

Moberg
10 апреля 2020 в 17:09
0

@ cs95 медленно по сравнению с чем?

cs95
7 мая 2020 в 09:00
1

@Moberg По сравнению с другими способами объединения списков, для справки, пожалуйста, посмотрите мои тесты здесь.

avatar
Tuure Laurinolli
12 ноября 2009 в 07:07
87

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

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