Jak połączyć dwie listy w Pythonie?

Przykład:

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

Spodziewany rezultat:

>>> joinedlist
[1, 2, 3, 4, 5, 6]
2965
y2k 12 listopad 2009, 10:04

22 odpowiedzi

Najlepsza odpowiedź

Możesz użyć operatora +, aby je połączyć:

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

joinedlist = listone + listtwo

Wynik:

>>> joinedlist
[1,2,3,4,5,6]
4278
TrebledJ 7 czerwiec 2019, 06:45

Jeśli chcesz nowej listy, zachowując dwie stare listy:

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

    sorted(joinedList)

    return joinedList
-1
Ukendar Vadivel 31 lipiec 2018, 09:35
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]
-2
Dimitris Fasarakis Hilliard 4 lipiec 2017, 12:00

Możliwe jest również utworzenie generatora, który po prostu iteruje nad przedmiotami na obu listach za pomocą {{ X0}}. Umożliwia to łańcuchowe listy (lub dowolne iterable) razem do przetwarzania bez kopiowania elementów do nowej listy:

import itertools
for item in itertools.chain(listone, listtwo):
    # Do something with each list item
344
Boris 22 listopad 2019, 12:53

pyton >= 3.5 alternatywa: [*l1, *l2]

Inna alternatywa została wprowadzona przez akceptację PEP 448 , co zasługuje na wspomnienie.

PEP, zatytułowany Dodatkowe rozpakowanie uogólnienia , na ogół zmniejszono pewne ograniczenia składniowe podczas stosowania ekspresji w Pythonie {X0}} w Pythonie; Wraz z nim, dołączenie do dwóch list (dotyczy jakichkolwiek iterable) można teraz również wykonać:

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

Ta funkcja została zdefiniowana dla Pythona 3.5 nie został cofnięty do poprzednich wersji w rodzinie {x1}}. W nieobsługiwanych wersjach zostanie podniesiony SyntaxError.

Podobnie jak w przypadku innych podejść, to zbyt tworzy jako płytką kopię elementów w odpowiednich listach.


Upside do tego podejścia jest to, że naprawdę nie potrzebujesz list, aby go wykonać, wszystko, co jest bardzo ważne. Jak stwierdzono w PEP:

Jest to również przydatne jako bardziej czytelny sposób podsumowania iterables w lista, taki jak my_list + list(my_tuple) + list(my_range), który jest teraz odpowiednik po prostu [*my_list, *my_tuple, *my_range].

Więc podczas gdy dodatek z + podniesie TypeError z powodu niedopasowania typu:

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

Następujące nie:

res = [*l, *r]

Ponieważ najpierw rozpakuje zawartość iterables, a następnie wystarczy utworzyć list z zawartości.

341
Boris 22 listopad 2019, 12:44

Możesz użyć zestawów, aby uzyskać scaloną listę unikalnych wartości

mergedlist = list(set(listone + listtwo))
229
thefourtheye 2 kwiecień 2014, 07:28

Możesz również użyć {x0}} w porządku Aby dodać list do końca innego:

listone = [1,2,3]
listtwo = [4,5,6]
mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)
219
4 revs, 3 users 57% 30 maj 2020, 18:02

Jest to dość proste, i myślę, że był nawet pokazany w Tutorial:

>>> listone = [1,2,3]
>>> listtwo = [4,5,6]
>>>
>>> listone + listtwo
[1, 2, 3, 4, 5, 6]
82
Peter Mortensen 17 marzec 2019, 09:15

To pytanie bezpośrednio prosi o dołączenie do dwóch list. Jednak jest dość wysokie w wyszukiwarce, nawet jeśli szukasz sposobu dołączenia do wielu list (w tym przypadku podczas dołączenia do list zerowych).

Myślę, że najlepszą opcją jest użycie kompymsji listy:

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

Możesz również tworzyć generatory:

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

stara odpowiedź

Rozważ to bardziej ogólne podejście:

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

Wyświetli:

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

Uwaga, to działa poprawnie, gdy a jest [] lub [[1,2,3]].

Jednak można to zrobić bardziej efektywnie z itertools:

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

Jeśli nie potrzebujesz list, ale tylko iterable, pomiń list().

Aktualizuj

Alternatywna sugerowana przez Patrick Collins w komentarzach może również pracować dla Ciebie:

sum(a, [])
55
wonder.mice 4 wrzesień 2018, 18:15

Możesz po prostu użyć operatora + lub += w następujący sposób:

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

c = a + b

Lub:

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

c += (a + b)

Ponadto, jeśli chcesz, aby wartości w scalonej liście będzie wyjątkowy, możesz zrobić:

c = list(set(a + b))
43
Peter Mortensen 22 grudzień 2013, 09:21

Dzięki Python 3.3+ możesz użyć Wydajność z:

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]

Lub, jeśli chcesz obsługiwać dowolną liczbę iteratorów:

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]
25
user688635user688635 21 lipiec 2014, 00:53

Jeśli chcesz scalić dwie listy w posortowanym formularzu, możesz użyć funkcji merge z biblioteki heapq.

from heapq import merge

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

print list(merge(a, b))
22
Peter Mortensen 17 marzec 2019, 09:19

Jeśli nie możesz użyć operatora plus ({x0}}), możesz użyć importu operator:

import operator

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

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

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

Alternatywnie, można również użyć __add__ Dunder Funkcja:

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

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

>>> [1, 2, 3, 4, 5, 6]
17
jpihl 4 czerwiec 2019, 07:09

Jako bardziej ogólny sposób na więcej list można umieścić je na liście i użyć funkcji itertools.chain.from_iterable() 1 , na podstawie to odpowiedź jest najlepszym sposobem na mieszanie zagnieżdżonej listy:

>>> 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. Należy pamiętać, że chain.from_iterable() jest dostępny w Pythonie 2.6 i nowszym. W innych wersjach użyj chain(*l).

17
Kasravnd 16 lipiec 2020, 19:46

Jeśli potrzebujesz połączenia dwóch uporządkowanych list z skomplikowanymi regułami sortowania, może być konieczne włączenie go w następujący kod (przy użyciu prostej reguły sortowania dla czytelności :-)).

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])
12
Peter Mortensen 22 grudzień 2013, 09:23

Możesz użyć metody append() zdefiniowanej na obiektach list:

mergedlist =[]
for elem in listone:
    mergedlist.append(elem)
for elem in listtwo:
    mergedlist.append(elem)
7
Dimitris Fasarakis Hilliard 5 maj 2016, 09:05
list(set(listone) | set(listtwo))

Powyższy kod nie zachowuje zamówienia, usuwa duplikat z każdej listy (ale nie z listy połączonej)

7
SuperNova 7 lipiec 2016, 07:42

Jak już wskazano przez wielu, itertools.chain() jest sposobem na przejażdżkę, jeśli trzeba stosować dokładnie te same leczenie obu listy. W moim przypadku miałem etykietę i flagę, która różniła się od jednej listy do drugiej, więc potrzebowałem czegoś nieco bardziej złożonego. Jak się okazuje, za kulisami {X1}} po prostu wykonuje:

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

(patrz https://docs.PYTHON.org/2/library/itertools.html), więc wziąłem inspirację stąd i napisałem coś wzdłuż tych linii:

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
        [...]

Główne punkty do zrozumienia tutaj są te listy są po prostu szczególnym przypadkiem iterable, które są obiektami jak każdy inny; I że for ... in pętle w Pythonie może pracować z zmiennymi krotkami, więc jednocześnie jest proste do pętli na wielu zmiennych.

6
Francesco Marchetti-Stasi 2 listopad 2015, 18:59

Naprawdę zwięzły sposób na połączenie listy list jest

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

Co nam daje

[1, 2, 3, 4, 5, 6, 7, 8, 9]
4
Akash Singh 29 czerwiec 2018, 12:16

W Pythonie możesz połączyć dwie tablice kompatybilnych wymiarów z tym poleceniem

numpy.concatenate([a,b])
4
Cody Gray 26 lipiec 2020, 17:00
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))

Wynik:

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]
-1
JamesVeug 16 luty 2018, 03:46

Warto zauważyć, że funkcja itertools.chain akceptuje zmienną liczbę argumentów:

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

Jeśli itrelable (krotka, lista, generator itp.) Jest wejściem, można użyć metody klasy from_iterable:

>>> il = [['a'], ['b', 'c'], ['d', 'e', 'f']]
>>> [i for i in itertools.chain.from_iterable(il)]
['a', 'b', 'c', 'd', 'e', 'f']
29
Dariusz Walczak 5 luty 2013, 05:01