Możliwe jest również utworzenie generatora, który po prostu iteruje nad elementami z obu list za pomocą itertools.chain(). Pozwala to na łączenie list (lub dowolnych iterowalnych) w celu przetworzenia bez kopiowania elementów do nowej Listy:

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

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

Wprowadzono inną alternatywę poprzez akceptację PEP 448 co zasługuje na wzmiankę.

PEP, zatytułowany dodatkowe uogólnienia rozpakowywania, ogólnie zmniejszono pewne ograniczenia składniowe podczas używania wyrazu * w Pythonie; wraz z nim łączenie dwóch list (dotyczy każdej iteracyjnej) można teraz również wykonać za pomocą:

>>> 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 funkcjonalność został zdefiniowany dla Pythona 3.5 nie został on ponownie zaimportowany do poprzednich wersji w rodzinie 3.x. W nieobsługiwanych wersjach zostanie podniesione SyntaxError.

Podobnie jak w przypadku innych podejść, to także tworzy płytką kopię elementów z odpowiednich list.

Plusem tego podejścia jest to, że naprawdę nie potrzebujesz list, aby je wykonać, wszystko, co jest iteracyjne, wystarczy. Jak podano w PEP:

Jest to również przydatne jako bardziej czytelny sposób sumowania iterabli w lista, np. my_list + list(my_tuple) + list(my_range), która jest teraz odpowiednik tylko [*my_list, *my_tuple, *my_range].

Więc dodanie z + wywoła TypeError ze względu na niedopasowanie typu:

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

Nie będzie:

res = [*l, *r]

Ponieważ najpierw rozpakuje zawartość iterabli, a następnie po prostu utworzy list z zawartości.

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

mergedlist = list(set(listone + listtwo))

Możesz również użyć list.extend() metoda w celu dodania list na końcu innego:

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

listone.extend(listtwo)

Jeśli chcesz zachować oryginalną listę w Nienaruszonym Stanie, możesz utworzyć nowy obiekt list, a extend obie listy do niego:

mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)

Jak połączyć dwie listy w Pythonie?

Od wersji 3.9 są to najpopularniejsze metody stdlib do łączenia dwóch (lub więcej) list w Pythonie.

Przypisy

1. Jest to sprytne rozwiązanie ze względu na swoją zwięzłość. Ale sum wykonuje konkatenację w sposób parami, co oznacza, że jest to operacja kwadratowa jako pamięć musi być przydzielona dla każdego kroku. DO Nie stosować, jeśli Twoje listy są duże.

2. Zobacz chain oraz chain.from_iterable od lekarzy. Najpierw musisz import itertools. Konkatenacja jest liniowa w pamięci, więc jest to najlepsze pod względem wydajność i kompatybilność wersji. chain.from_iterable został wprowadzony w 2.6.

3. Metoda ta wykorzystuje dodatkowe uogólnienia rozpakowywania (PEP 448), ale nie może generalizuj do n list, chyba że ręcznie rozpakujesz każdą z nich samodzielnie.

4. a += b oraz a.extend(b) są mniej lub bardziej równoważne dla wszystkich praktycznych celów. += po wywołaniu na liście będzie wywoływać wewnętrznie list.__iadd__, który rozszerza pierwszą Listę o drugą.

Wydajność

2-Konkatenacja Listy¹

Nie ma dużej różnicy między tymi metodami, ale to ma sens, biorąc pod uwagę, że wszystkie mają ten sam porządek złożoności (liniowy). Nie ma szczególnego powodu, by preferować jedno nad drugim. z wyjątkiem kwestii stylu.

N-Lista Konkatenacja

Wykresy zostały wygenerowane za pomocą modułu perfplot. kod, w celach informacyjnych.

_{1. Na iadd (+=) i extend metody działają na miejscu, więc kopia musi być generowana za każdym razem przed testowaniem. Aby wszystko było uczciwe, wszystkie metody mają krok przed kopiowaniem listy po lewej stronie, który można zignorować.}

Komentarze do innych Rozwiązania

• Nie używaj metody DUNDERA list.__add__ bezpośrednio w żaden sposób, w żadnym kształcie ani formie. W rzeczywistości, trzymaj się z dala od metod dundera i używaj operatorów i funkcji operator, do których zostały zaprojektowane. Python ma do nich dokładną semantykę, która jest bardziej skomplikowana niż bezpośrednie wywołanie dundera. Oto przykład . Podsumowując, a.__add__(b) => zły; a + b => dobry.

• Niektóre odpowiedzi tutaj oferują {[16] } do łączenia par -- to jest to samo co sum([a, b], []) tylko bardziej wyraziste.

• Każda metoda wykorzystująca set zrzuci duplikaty i straci kolejność. Stosować ostrożnie.

• for i in b: a.append(i) jest bardziej słowny i wolniejszy niż a.extend(b), co jest pojedynczym wywołaniem funkcji i jest bardziej idiomatyczne. append jest wolniejszy ze względu na semantykę, z którą pamięć jest przydzielana i rozwijana dla list. Zobacz tutaj dla podobnej dyskusji.

• heapq.merge będzie działać, ale jego przypadek użycia jest do scalania posortowane listy w czasie liniowym. Używanie go w każdej innej sytuacji jest anty-wzorcem.

• yielding list elements z funkcji jest akceptowalną metodą, ale chain robi to szybciej i lepiej(ma ścieżkę kodu w C, więc jest szybka).

• operator.add(a, b) jest akceptowalnym funkcjonalnym odpowiednikiem a + b. To przypadki użycia są głównie dla dynamicznej wysyłki metod. W przeciwnym razie preferuj a + b, który jest krótszy i bardziej czytelny, moim zdaniem. YMMV.

Jest to dość proste, a myślę, że zostało to nawet pokazane w tutorial :

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

To pytanie bezpośrednio pyta o połączenie dwóch list. Jednak jest to dość wysokie w wyszukiwaniu, nawet jeśli szukasz sposobu łączenia wielu list (w tym przypadku, gdy dołączasz do list zerowych).

Myślę, że najlepszą opcją jest użycie list comprehensions:

>>> 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żna 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 również działa poprawnie, gdy a jest [] lub [[1,2,3]].

Jednak można to zrobić bardziej efektywnie za pomocą 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().

Update

Alternatywa zasugerowana przez Patricka Collinsa w komentarzach może również działać dla Ciebie:

sum(a, [])

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)

Również, jeśli chcesz, aby wartości w Scalonej liście były unikalne, możesz zrobić:

c = list(set(a + b))

Warto zauważyć, że funkcja itertools.chain przyjmuje 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']

If an iterable (tuple, list, generator, etc.) jest wejściem, można zastosować metodę 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']

W Pythonie 3.3+ możesz użyć 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]

Jeśli chcesz scalić obie listy w posortowanej formie, 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))

Dla przypadków z małą liczbą list można po prostu dodać listy razem lub użyć in-place unpacking (dostępne w Pythonie-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]

Jako bardziej ogólny sposób dla przypadków z większą liczbą list, jako podejście pythoniczne można użyć chain.from_iterable()¹ Funkcja z modułu itertoold. Również na podstawie ta odpowiedź Ta funkcja jest najlepsza; a przynajmniej bardzo przydatna do spłaszczania 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]

Jeśli nie możesz użyć operatora plus (+), możesz użyć operator import:

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]

Jeśli chcesz połączyć dwie uporządkowane listy ze skomplikowanymi regułami sortowania, być może będziesz musiał sam to zrobić, jak w poniższym kodzie (używając 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])

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

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

list(set(listone) | set(listtwo))

Powyższy kod, nie zachowuje porządku, usuwa duplikaty z każdej listy (ale nie z połączonej listy)

Jak już zauważyło wielu, itertools.chain() jest to droga, jeśli trzeba zastosować dokładnie to samo traktowanie do obu list. W moim przypadku miałem etykietę i flagę, które różniły się od jednej listy do drugiej, więc potrzebowałem czegoś nieco bardziej złożonego. Jak się okazuje, za kulisami itertools.chain() po prostu wykonuje następujące czynności:

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

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

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

Najważniejsze jest to, że listy są po prostu specjalnym przypadkiem iterowalnych, które są obiektami jak każdy inny; i że pętle for ... in w Pythonie mogą pracować ze zmiennymi krotkowymi, więc łatwo jest zapętlić wiele zmiennych w tym samym czasie.

Użyj prostego rozumienia listy:

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

Ma wszystkie zalety najnowszego podejścia polegającego na użyciu dodatkowych uogólnień Rozpakowujących - tzn. można w ten sposób łączyć dowolną liczbę różnych iterabli (na przykład listy, krotki, zakresy i generatory) - i nie ogranicza się do Pythona 3.5 lub nowszego.

Jeśli używasz NumPy, możesz połączyć dwie tablice zgodnych wymiarów za pomocą tego polecenia:

numpy.concatenate([a,b])

Bardzo zwięzłym sposobem łączenia listy list jest

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

Co daje nam

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

Więc są dwa proste sposoby.

1. za pomocą +: tworzy nową listę z podanych List

Przykład:

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. użycie extend : dodaje nową listę do istniejącej listy. Oznacza to, że nie tworzy oddzielnej listy.

Przykład:

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

Widzimy więc, że spośród dwóch najpopularniejszych metod, {[3] } jest skuteczna.

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

 c=a+b
 print(c)

Wyjście:

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

W powyższym kodzie operator "+" jest używany do łączenia dwóch list w jedną listę.

INNE ROZWIĄZANIE:

 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)

Wyjście:

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

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

Wyjście:

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]

Zakładam, że chcesz jednej z dwóch metod:

Zachowaj zduplikowane elementy

Jest to bardzo proste, wystarczy połączyć jak ciąg znaków:

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

Następnie, jeśli chcesz wyeliminować duplikaty elementów

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

Możesz użyć funkcji union () w Pythonie.

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

Zasadniczo to, co robi, to usuwanie jednego z każdego duplikatu z dwóch list. Ponieważ listy nie mają żadnych duplikatów, po prostu zwraca połączoną wersję tych dwóch list.