Wie verkette ich zwei Listen in Python?

Beispiel:

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

Erwartetes Ergebnis:

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

Sie können den +Operator verwenden, um sie zu kombinieren:

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

joinedlist = listone + listtwo

Ausgabe:

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

Es ist auch möglich, einen Generator zu erstellen, der einfach die Elemente in beiden Listen mit iteriert itertools.chain(). Auf diese Weise können Sie Listen (oder beliebige iterierbare) zur Verarbeitung miteinander verketten, ohne die Elemente in eine neue Liste zu kopieren:

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

Python- >= 3.5Alternative:[*l1, *l2]

Eine andere Alternative wurde eingeführt, über deren Annahme PEP 448Erwähnung verdient.

Das PEP mit dem Titel " Zusätzliche Entpackungsverallgemeinerungen" reduzierte im Allgemeinen einige syntaktische Einschränkungen, wenn der markierte *Ausdruck in Python verwendet wurde. Damit können Sie jetzt auch zwei Listen verbinden (gilt für alle iterierbaren) mit:

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

Diese Funktionalität wurde für Python definiert3.5 und nicht auf frühere Versionen der 3.xFamilie zurückportiert . In nicht unterstützten Versionen SyntaxErrorwird a ausgelöst.

Wie bei den anderen Ansätzen wird auch hier eine flache Kopie der Elemente in den entsprechenden Listen erstellt.

Der Vorteil dieses Ansatzes ist, dass Sie wirklich keine Listen benötigen, um ihn auszuführen. Alles, was iterierbar ist, reicht aus. Wie im PEP angegeben:

Dies ist auch nützlich, um Iterables besser in einer Liste zusammenzufassen, wie sie my_list + list(my_tuple) + list(my_range)jetzt nur noch entspricht [*my_list, *my_tuple, *my_range].

Also, während Addition mit +eine TypeErroraufgrund von Typinkongruenz auslösen würde:

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

Folgendes wird nicht:

res = [*l, *r]

weil es zuerst den Inhalt der iterables entpackt und dann einfach einen listaus dem Inhalt erstellt.

Sie können Sets verwenden, um eine zusammengeführte Liste eindeutiger Werte zu erhalten

mergedlist = list(set(listone + listtwo))

Sie können die list.extend()Methode auch verwenden , um listam Ende eines anderen ein hinzuzufügen :

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

listone.extend(listtwo)

Wenn Sie die ursprüngliche Liste beibehalten möchten, können Sie ein neues listObjekt und extendbeide Listen erstellen :

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

Wie verkette ich zwei Listen in Python?

Ab Version 3.7 sind dies die beliebtesten stdlib-Methoden zum Verketten von zwei (oder mehr) Listen in Python.

Fußnoten

1. Dies ist aufgrund seiner Prägnanz eine raffinierte Lösung. Führt sumdie Verkettung jedoch paarweise durch, was bedeutet, dass dies eine quadratische Operation ist, da für jeden Schritt Speicher zugewiesen werden muss. NICHT VERWENDEN, wenn Ihre Listen groß sind.

2. Siehe chain und chain.from_iterable aus den Dokumenten. Sie müssen import itertoolszuerst. Die Verkettung ist im Speicher linear, daher ist dies die beste Leistung und Versionskompatibilität. chain.from_iterablewurde in 2.6 eingeführt.

3. Diese Methode verwendet zusätzliche Entpackungsverallgemeinerungen (PEP 448) , kann jedoch nur dann auf N Listen verallgemeinern, wenn Sie jede manuell entpacken.

4. a += bund a.extend(b)sind für alle praktischen Zwecke mehr oder weniger gleichwertig. +=Beim Aufruf einer Liste wird intern aufgerufen list.__iadd__, wodurch die erste Liste um die zweite erweitert wird.

Performance

2-Listen-Verkettung ¹

Es gibt keinen großen Unterschied zwischen diesen Methoden, aber das ist sinnvoll, da sie alle die gleiche Reihenfolge der Komplexität (linear) haben. Es gibt keinen besonderen Grund, einen anderen vorzuziehen, außer aus Gründen des Stils.

N-List-Verkettung

Mit dem Perfplot- Modul wurden Diagramme erstellt . Code als Referenz.

_{1. Die iadd( +=) und extendMethoden arbeiten an Ort und Stelle, daher muss jedes Mal vor dem Testen eine Kopie erstellt werden. Um die Dinge fair zu halten, haben alle Methoden einen Vorkopierschritt für die linke Liste, der ignoriert werden kann.}

Kommentare zu anderen Lösungen

• VERWENDEN SIE DIE DUNDER-METHODE NICHT list.__add__direkt in irgendeiner Form. Halten Sie sich von Dunder-Methoden fern und verwenden Sie die Operatoren und operatorFunktionen, für die sie entwickelt wurden. In Python ist eine sorgfältige Semantik enthalten, die komplizierter ist, als nur den Dunder direkt aufzurufen. Hier ist ein Beispiel . Also, um zusammenzufassen, a.__add__(b)=> BAD; a + b=> GUT.

• Einige Antworten hier bieten reduce(operator.add, [a, b])eine paarweise Verkettung - dies ist das Gleiche wie sum([a, b], [])nur wortreicher.

• Bei jeder verwendeten Methode setwerden Duplikate gelöscht und die Reihenfolge verloren. Mit Vorsicht verwenden.

• for i in b: a.append(i)ist wortreicher und langsamer als a.extend(b), was ein einzelner Funktionsaufruf und idiomatischer ist. appendist aufgrund der Semantik, mit der Speicher für Listen zugewiesen und erweitert wird, langsamer. Siehe hier für eine ähnliche Diskussion.

• heapq.mergewird funktionieren, aber sein Anwendungsfall ist das Zusammenführen sortierter Listen in linearer Zeit. Die Verwendung in jeder anderen Situation ist ein Anti-Muster.

• yieldDas Auflisten von Listenelementen aus einer Funktion ist eine akzeptable Methode, dies chaingeschieht jedoch schneller und besser (es hat einen Codepfad in C, ist also schnell).

• operator.add(a, b)ist ein akzeptables funktionales Äquivalent zu a + b. Die Anwendungsfälle betreffen hauptsächlich den Versand dynamischer Methoden. Ansonsten lieber, a + bwas meiner Meinung nach kürzer und lesbarer ist . YMMV.

Das ist ganz einfach und ich denke, es wurde sogar im Tutorial gezeigt :

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

Bei dieser Frage geht es direkt darum, zwei Listen zu verbinden. Die Suche ist jedoch ziemlich hoch, selbst wenn Sie nach einer Möglichkeit suchen, viele Listen zu verbinden (einschließlich des Falls, wenn Sie Nulllisten verbinden).

Ich denke, die beste Option ist die Verwendung von Listenverständnissen:

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

Sie können auch Generatoren erstellen:

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

Alte Antwort

Betrachten Sie diesen allgemeineren Ansatz:

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

Wird ausgegeben:

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

Beachten Sie , dass dies auch richtig funktioniert , wenn aist []oder [[1,2,3]].

Dies kann jedoch effizienter durchgeführt werden mit itertools:

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

Wenn Sie kein list, sondern nur ein iterierbares Element benötigen , lassen Sie es weg list().

Aktualisieren

Die von Patrick Collins in den Kommentaren vorgeschlagene Alternative könnte auch für Sie funktionieren:

sum(a, [])

Sie können den Operator +oder einfach +=wie folgt verwenden:

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

c = a + b

Oder:

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

c += (a + b)

Wenn Sie möchten, dass die Werte in der zusammengeführten Liste eindeutig sind, können Sie Folgendes tun:

c = list(set(a + b))

Es ist erwähnenswert, dass die itertools.chainFunktion eine variable Anzahl von Argumenten akzeptiert:

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

Wenn eine iterable (Tupel, Liste, Generator usw.) die Eingabe ist, kann die from_iterableKlassenmethode verwendet werden:

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

Mit Python 3.3+ können Sie die Ausbeute verwenden von :

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]

Oder wenn Sie eine beliebige Anzahl von Iteratoren unterstützen möchten:

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]

Wenn Sie die beiden Listen in sortierter Form zusammenführen möchten, können Sie die mergeFunktion aus der heapqBibliothek verwenden.

from heapq import merge

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

print list(merge(a, b))

Wenn Sie den Plus-Operator ( +) nicht verwenden können , können Sie den operatorImport verwenden:

import operator

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

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

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

Alternativ können Sie auch die __add__ Dunder- Funktion verwenden:

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

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

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

Als allgemeinere Methode für mehr Listen können Sie sie in eine Liste einfügen und die Funktion itertools.chain.from_iterable()¹ verwenden, die auf der Grundlage dieser Antwort die beste Methode zum Abflachen einer verschachtelten Liste darstellt:

>>> 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. Beachten Sie, dass dies chain.from_iterable()in Python 2.6 und höher verfügbar ist. In anderen Versionen verwenden chain(*l).}

Wenn Sie zwei geordnete Listen mit komplizierten Sortierregeln zusammenführen müssen, müssen Sie sie möglicherweise selbst wie im folgenden Code rollen (unter Verwendung einer einfachen Sortierregel zur besseren Lesbarkeit :-)).

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

Sie können die append()für listObjekte definierte Methode verwenden :

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

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

Der obige Code behält die Reihenfolge nicht bei und entfernt Duplikate aus jeder Liste (jedoch nicht aus der verketteten Liste).

Wie bereits von vielen betont, itertools.chain()ist dies der richtige Weg, wenn auf beide Listen genau die gleiche Behandlung angewendet werden muss. In meinem Fall hatte ich ein Etikett und eine Flagge, die sich von einer Liste zur anderen unterschieden, also brauchte ich etwas etwas komplexeres. Wie sich herausstellt, itertools.chain()geschieht hinter den Kulissen einfach Folgendes:

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

(siehe https://docs.python.org/2/library/itertools.html ), also habe ich mich von hier inspirieren lassen und etwas in diese Richtung geschrieben:

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

Die wichtigsten Punkte, die hier zu verstehen sind, sind, dass Listen nur ein Sonderfall von iterable sind, bei denen es sich um Objekte wie jedes andere handelt. und dass for ... inSchleifen in Python mit Tupelvariablen arbeiten können, so dass es einfach ist, mehrere Variablen gleichzeitig zu durchlaufen.

Verwenden Sie ein einfaches Listenverständnis:

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

Es bietet alle Vorteile des neuesten Ansatzes der Verwendung zusätzlicher Generalisierungen zum Entpacken - dh Sie können auf diese Weise eine beliebige Anzahl verschiedener Iterables (z. B. Listen, Tupel, Bereiche und Generatoren) verketten - und ist nicht auf Python 3.5 oder höher beschränkt .

Eine wirklich präzise Möglichkeit, eine Liste von Listen zu kombinieren, ist

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

was uns gibt

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

In Python können Sie mit diesem Befehl zwei Arrays kompatibler Dimensionen verketten

numpy.concatenate([a,b])

Es gibt also zwei einfache Möglichkeiten.

1. Verwenden+ : Es wird eine neue Liste aus den bereitgestellten Listen erstellt

Beispiel:

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

2. Verwenden von "Erweitern" : Hängt eine neue Liste an eine vorhandene Liste an. Das heißt, es wird keine separate Liste erstellt.

Beispiel:

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

Wir sehen also, dass von zwei der beliebtesten Methoden extendeffizient ist.

Es gibt mehrere Möglichkeiten, Listen in Python zu verketten.

l1 = [1,2,3,4]
l2 = [3,4,5,6]

1. new_list = l1.extend(l2)
2. new_list = l1 + l2
3. new_list = [*l1, *l2]

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

Ausgabe:

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]

Wenn Sie eine neue Liste wünschen, während Sie die beiden alten Listen beibehalten:

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

    sorted(joinedList)

    return joinedList

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]

Sie können dem Code folgen

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

for i in listone:
    listtwo.append(i)
print(listtwo)

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