Wie verkette ich zwei Listen in Python?

Es ist auch möglich, einen Generator zu erstellen, der die Elemente in beiden Listen einfach durchläuft. Auf diese Weise können Sie Listen (oder beliebige Iterationen) für die Verarbeitung 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

Sie können Sätze verwenden, um eine zusammengeführte Liste eindeutiger Werte abzurufen

mergedlist = list(set(listone + listtwo))

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

Obwohl dies eine alte Antwort ist, wurde durch die Annahme von PEP 448 eine andere Alternative eingeführt, die es verdient, erwähnt zu werden.

Das PEP mit dem Titel Additional Unpacking Generalizations reduzierte im Allgemeinen einige syntaktische Einschränkungen, wenn der mit einem Stern versehene Ausdruck * in verwendet wurde Python; Damit kann das Verbinden von zwei Listen (gilt für alle iterierbaren Listen) jetzt auch mit folgenden Methoden durchgeführt werden:

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

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

Diese Funktionalität wurde für Python 3.5 definiert und nicht auf frühere Versionen in der 3.x-Familie zurückportiert. In nicht unterstützten Versionen wird ein SyntaxError ausgelöst.

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

Die Kehrseite dieses Ansatzes ist, dass Sie wirklich keine Listen benötigen, um es auszuführen, alles, was iterabel ist, wird ausreichen. Wie im PEP angegeben:

Dies ist auch nützlich, um Iterables besser lesbar in einer Liste zusammenzufassen, z. B. my_list + list(my_Tuple) + list(my_range), die jetzt nur noch [*my_list, *my_Tuple, *my_range] entspricht.

Während das Hinzufügen von + einen TypeError aufgrund von Typenkonflikten 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 ein list aus dem Inhalt erstellt.

Sie können auch extend verwenden, um einen list an das Ende eines anderen zu setzen:

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

Das ist ganz einfach und ich denke, es wurde sogar in dem 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 intensiv, selbst wenn Sie nach einer Möglichkeit suchen, viele Listen zu verbinden (einschließlich des Falls, wenn Sie Null-Listen 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 ausgeben:

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

Beachten Sie, dass dies auch korrekt funktioniert, wenn a[] oder [[1,2,3]] ist.

Dies kann jedoch mit itertools effizienter durchgeführt werden:

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

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

pdate

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

sum(a, [])

Sie können einfach den Operator + oder += 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 die Werte in der zusammengeführten Liste eindeutig sein sollen, können Sie Folgendes tun:

c = list(set(a + b))

Es ist erwähnenswert, dass die Funktion itertools.chain 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 es sich bei der Eingabe um eine Iterationsdatei (Tupel, Liste, Generator usw.) handelt, kann die Klassenmethode from_iterable 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 Yield from verwenden:

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]

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 eine raffinierte Lösung wegen seiner Prägnanz. sum führt die 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 in den Dokumenten. Sie müssen zuerst _import itertools_. Die Verkettung erfolgt linear im Arbeitsspeicher, daher ist dies in Bezug auf Leistung und Versionskompatibilität das Beste. _chain.from_iterable_ wurde in 2.6 eingeführt.

3. Diese Methode verwendet Additional Unpacking Generalizations (PEP 448) , kann jedoch nur dann auf N Listen verallgemeinern, wenn Sie jede manuell entpacken.

4. _a += b_ und a.extend(b) sind für alle praktischen Zwecke mehr oder weniger gleichwertig. _+=_ ruft beim Aufrufen in einer Liste intern _list.__iadd___ auf, wodurch die erste Liste um die zweite erweitert wird.

Performance

Verkettung von 2 Listen ¹

Verkettung von N-Listen

Diagramme wurden mit dem Modul perfplot erstellt. Code, als Referenz.

_{1. Die Methoden iadd (_+=_) und extend werden direkt ausgeführt. Daher muss vor jedem Test 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 _list.__add___ NICHT direkt in irgendeiner Form. Halten Sie sich in der Tat von Methoden fern und verwenden Sie die Operatoren und operator -Funktionen, für die sie entwickelt wurden. Python enthält eine sorgfältige Semantik, 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]) für die paarweise Verkettung - dies ist dasselbe wie sum([a, b], []) nur wortreicher.

• Jede Methode, die set verwendet, löscht Duplikate und verliert die Reihenfolge. Mit Vorsicht verwenden.

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

• _heapq.merge_ funktioniert, aber sein Anwendungsfall ist das Zusammenführen sortierter Listen in linearer Zeit. Die Verwendung in einer anderen Situation ist ein Anti-Pattern.

• yield Das Auflisten von Elementen aus einer Funktion ist eine akzeptable Methode, aber chain erledigt dies schneller und besser (es hat einen Codepfad in C, daher ist es schnell).

• operator.add(a, b) ist ein akzeptables Funktionsäquivalent zu _a + b_. Es handelt sich hauptsächlich um Anwendungsfälle für den Versand dynamischer Methoden. Ansonsten bevorzuge _a + b_, das meiner Meinung nach kürzer und lesbarer ist . YMMV.

Sie können sich für die Funktion list.extend entscheiden.

_l1 = [1,2,3]
l2 = [4,5,6]
l1.extend(l2)
print l1
_

Ausgabe:

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

Wenn Sie die beiden Listen in sortierter Form zusammenführen möchten, können Sie die Funktion merge aus der Bibliothek heapq 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 operator -Import 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 Funktion __add__dunder verwenden:

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

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

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

Als allgemeine Möglichkeit für weitere Listen können Sie diese in eine Liste einfügen und die Funktion itertools.chain.from_iterable() verwenden.¹ Eine Funktion, die auf dieser Antwort basiert, ist der beste Weg, eine verschachtelte Liste zu vereinfachen:

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

Wenn Sie zwei geordnete Listen mit komplizierten Sortierregeln zusammenführen müssen, müssen Sie sie möglicherweise wie im folgenden Code selbst rollen (mit 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])

Verbinden von zwei Listen in Python:

>>> a = [1, 2, 3, 4]
>>> b = [1, 4, 6, 7]
>>> c = a + b
>>> c
[1, 2, 3, 4, 1, 4, 6, 7]

Wenn Sie keine Vervielfältigung wünschen:

>>> a = [1, 2, 3, 4, 5, 6]
>>> b = [5, 6, 7, 8]
>>> c = list(set(a + b))
>>> c
[1, 2, 3, 4, 5, 6, 7, 8]

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

Sie können die append() -Methode verwenden, die für list -Objekte definiert ist:

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

Wie schon von vielen betont, ist itertools.chain() der richtige Weg, wenn man auf beide Listen genau die gleiche Behandlung anwenden muss . In meinem Fall hatte ich ein Etikett und eine Flagge, die sich von Liste zu Liste unterschieden, also brauchte ich etwas Komplexeres. Wie sich herausstellt, macht itertools.chain() 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 alle anderen handelt. und dass for ... in Schleifen in python mit Tuple-Variablen arbeiten können, so dass es einfach ist, mehrere Variablen gleichzeitig zu schleifen.

Um eine Liste mit einer anderen zu erweitern, gibt es verschiedene Methoden:

>>> listone = [1,2,3]
>>> listome = [4,5,6]
>>>
>>> listone+listome # adding 2 list is actually extending the list
[1, 2, 3, 4, 5, 6]
>>>
>>> listone.extend(listome)
>>> listone
[1, 2, 3, 4, 5, 6]
>>>
>>> listone = [1,2,3]
>>>
>>> listone.__add__(listome)
[1, 2, 3, 4, 5, 6]

for loop kann auch verwendet werden:

>>> for i in listome:
...     listone.append(i)
...
>>> listone
[1, 2, 3, 4, 5, 6]
>>>

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 von Additional Unpacking Generalizations - dh Sie können auf diese Weise eine beliebige Anzahl verschiedener Iterables (z. B. Listen, Tupel, Bereiche und Generatoren) verketten nicht beschränkt auf Python 3.5 oder höher.

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

numpy.concatenate([a,b])

Eine wirklich übersichtliche 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]

Sie können den Operator '+' verwenden, um zwei Listen in Python zu verketten:

>>> listone = [1,2,3]
>>> listtwo = [4,5,6]
>>>
>>> listSum = []
>>> listSum = listone + listtwo
>>> print(listSum)

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

Es gibt also zwei einfache Möglichkeiten.

1. Mit +: Erstellt eine neue Liste aus den bereitgestellten Listen

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. sing extend: Fügt eine neue Liste an eine bestehende 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

So sehen wir, dass von zwei der beliebtesten Methoden extend effizient ist.

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]

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]

Wenn Sie unter Beibehaltung der beiden alten Listen eine neue Liste wünschen:

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

    sorted(joinedList)

    return joinedList