5 Wege, Listen in Python zu kombinieren | Leitfaden für Anfänger

1. Einführung

Python ist eine äußerst beliebte Programmiersprache mit einfacher und verständlicher Syntax sowie einer reichen Bibliothek. Unter diesen ist die „Liste“ einer der am häufigsten verwendeten Datentypen für die Verwaltung und Manipulation von Daten. Die Liste ist eine bequeme Struktur, um mehrere Daten zusammenzufassen und zu handhaben, und ein unverzichtbarer Bestandteil der Python-Programmierung.

Insbesondere das „Kombinieren von Listen“, bei dem mehrere Listen zu einer zusammengefasst werden, ist eine grundlegende Operation, um die Effizienz der Datenmanipulation zu steigern. Durch ein angemessenes Verständnis dieser Operation kann die Geschwindigkeit der Datenverarbeitung und die Kürze des Codes erheblich verbessert werden.

In diesem Artikel erklären wir detailliert die Methoden zum Kombinieren von Listen in Python. Um es auch für Anfänger verständlich zu machen, stellen wir umfassend von grundlegenden Methoden über fortgeschrittene Techniken bis hin zu Unterschieden in der Leistung und Hinweisen vor. Damit Sie je nach Zweck die optimale Methode zum Kombinieren auswählen können, erklären wir es sorgfältig mit konkreten Code-Beispielen, bitte lesen Sie bis zum Ende.

Im nächsten Abschnitt schauen wir uns detailliert die fünf wichtigsten Methoden zum Kombinieren von Listen in Python an.

2. Fünf Hauptmethoden zum Zusammenführen von Listen

Python gibt es mehrere Methoden, um Listen zu kombinieren. Jede Methode hat ihre eigenen Merkmale, und die Verwendung sowie die geeigneten Situationen unterscheiden sich. In diesem Abschnitt erklären wir die fünf Hauptmethoden zum Zusammenführen von Listen mit konkreten Code-Beispielen.

2.1 append() Methode

Merkmale

append() Methode ist eine grundlegende Methode, um ein einzelnes Element ans Ende einer Liste hinzuzufügen. Da diese Methode die Liste direkt manipuliert und ändert, wird die ursprüngliche Liste aktualisiert.

Beispiel zur Verwendung

In dem folgenden Code wird append() verwendet, um ein neues Element zur Liste hinzuzufügen.

list1 = [1, 2, 3]
list1.append(4)
print(list1)  ## Ausgabe: [1, 2, 3, 4]

Beachten Sie jedoch, dass beim Hinzufügen einer gesamten Liste eine verschachtelte Liste erstellt wird.

list1 = [1, 2, 3]
list1.append([4, 5])
print(list1)  ## Ausgabe: [1, 2, 3, [4, 5]]

Hinweise

append() eignet sich zum Hinzufügen eines einzelnen Elements, aber für das Zusammenführen ganzer Listen ist es effektiver, andere Methoden zu verwenden.

2.2 extend() Methode

Merkmale

extend() Methode ist eine Methode, um eine andere Liste oder ein Iterables (wie Tupel oder Mengen) ans Ende der Liste zu entfalten und hinzuzufügen. Sie ist nützlich, wenn man Listen ohne Verschachtelung kombinieren möchte.

Beispiel zur Verwendung

In dem folgenden Code wird extend() verwendet, um Listen zu kombinieren.

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)
print(list1)  ## Ausgabe: [1, 2, 3, 4, 5, 6]

Hinweise

• extend() ändert die ursprüngliche Liste direkt.
• Für das Kombinieren verschachtelter Listen ist eine andere Methode erforderlich.

2.3 insert() Methode

Merkmale

insert() Methode wird verwendet, um Elemente an einer bestimmten Position in der Liste einzufügen. Sie ist nützlich, wenn das Ziel Einfügen statt Kombinieren ist.

Beispiel zur Verwendung

In dem folgenden Code wird insert() verwendet, um ein Element an einer bestimmten Position in der Liste einzufügen.

list1 = [1, 2, 4]
list1.insert(2, 3)
print(list1)  ## Ausgabe: [1, 2, 3, 4]

Hinweise

Häufige Verwendung von insert() kann die Verarbeitungsgeschwindigkeit verringern, wenn die Liste viele Elemente hat.

2.4 + Operator

Merkmale

+ Operator kombiniert zwei Listen zu einer neuen Liste. Die ursprünglichen Listen werden nicht geändert, und eine neue Liste wird zurückgegeben.

Beispiel zur Verwendung

In dem folgenden Code wird der + Operator verwendet, um Listen zu kombinieren.

list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined = list1 + list2
print(combined)  ## Ausgabe: [1, 2, 3, 4, 5, 6]

Hinweise

• Da eine neue Liste erstellt wird, kann der Speicherverbrauch zunehmen.
• Die ursprünglichen Listen werden nicht geändert.

2.5 Verwendung von Slices

Merkmale

Mit Slices kann man neue Elemente an beliebigen Positionen in der Liste einfügen oder kombinieren. Es ist eine sehr flexible Methode.

Beispiel zur Verwendung

In dem folgenden Code werden Slices verwendet, um Listen zu kombinieren.

list1 = [1, 2, 5]
list1[2:2] = [3, 4]
print(list1)  ## Ausgabe: [1, 2, 3, 4, 5]

Hinweise

Beim Verwenden von Slices ist eine genaue Angabe des Index erforderlich. Eine unangemessene Angabe kann zu unerwarteten Ergebnissen führen.

3. Empfohlene Verbindungsarten je nach Verwendungszweck

Es gibt verschiedene Möglichkeiten, Listen zu verbinden, aber es ist wichtig, die geeignete Methode je nach spezifischem Anwendungsfall oder Situation auszuwählen. In diesem Abschnitt erklären wir detailliert, welche Methode man basierend auf repräsentativen Szenarien wählen sollte.

3.1 Bei der Kombination kleiner Listen

Empfohlene Methode: +-Operator

Bei der Kombination kleiner Listen ist der +-Operator die einfachste und effizienteste Methode. Diese Methode erzeugt eine neue Liste, was auch geeignet ist, wenn die ursprünglichen Listen nicht geändert werden sollen.

Beispiel

list1 = [1, 2, 3]
list2 = [4, 5, 6]
result = list1 + list2
print(result)  ## Ausgabe: [1, 2, 3, 4, 5, 6]

Vorteile

• Lesbarer Syntax.
• Bei kleinen Daten ausreichende Performance.

Hinweise

• Da eine neue Liste erstellt wird, ungeeignet für große Datenmengen.

3.2 Bei der Kombination großer Datenmengen

Empfohlene Methode: extend()-Methode

Bei der Kombination großer Datenmengen ist die extend()-Methode effizient. Da die ursprüngliche Liste direkt aktualisiert wird, kann der Speicherverbrauch reduziert werden.

Beispiel

list1 = [i for i in range(100000)]
list2 = [j for j in range(100000)]
list1.extend(list2)
print(len(list1))  ## Ausgabe: 200000

Vorteile

• Geeignet für die Verarbeitung großer Datenmengen.
• Gute Speichereffizienz.

Hinweise

• Da die ursprüngliche Liste geändert wird, ungeeignet, wenn Änderungen vermieden werden sollen.

3.3 Wenn Elemente an einer bestimmten Position eingefügt werden sollen

Empfohlene Methode: insert()-Methode oder Slicing

Wenn Elemente an einer bestimmten Position eingefügt werden sollen, verwendet man die insert()-Methode oder Slicing. Dies ist praktisch, wenn die Einfügungsposition klar ist.

Beispiel (insert)

list1 = [1, 2, 4]
list1.insert(2, 3)
print(list1)  ## Ausgabe: [1, 2, 3, 4]

Beispiel (Slicing)

list1 = [1, 2, 5]
list1[2:2] = [3, 4]
print(list1)  ## Ausgabe: [1, 2, 3, 4, 5]

Vorteile

• Elemente an beliebiger Position einfügen möglich.
• Beim Slicing können mehrere Elemente auf einmal eingefügt werden.

Hinweise

• Bei Listen mit vielen Elementen kann die Verarbeitungsgeschwindigkeit abnehmen.

3.4 Im Fall wiederholter Hinzufügungen

Empfohlene Methode: append()-Methode

Bei der schrittweisen Hinzufügung von Elementen in einer Schleife ist append() optimal. Es ermöglicht die effiziente Hinzufügung einzelner Elemente zur Liste.

Beispiel

list1 = []
for i in range(5):
    list1.append(i)
print(list1)  ## Ausgabe: [0, 1, 2, 3, 4]

Vorteile

• Einfach und verständlich.
• Geeignet für die Verarbeitung einzelner Elemente.

Hinweise

• Nicht geeignet für das Verbinden ganzer Listen.

3.5 Wenn mehrere Verbindungsarten kombiniert werden sollen

Durch die Kombination mehrerer Methoden wird flexiblere Datenmanipulation möglich. Zum Beispiel kann Slicing und extend() kombiniert werden, um mehrere Elemente effizient an einer bestimmten Position hinzuzufügen.

Beispiel

list1 = [1, 5]
list2 = [2, 3, 4]
list1[1:1] = list2
print(list1)  ## Ausgabe: [1, 2, 3, 4, 5]

Zusammenfassung

• Kleine Daten: +-Operator ist einfach und empfehlenswert.
• Große Daten: extend() ist angemessen unter Berücksichtigung der Speichereffizienz.
• Hinzufügung einzelner Elemente: append() ist optimal.
• Einfügung an bestimmter Position: insert() oder Slicing verwenden.
• Hinzufügung mehrerer Elemente an bestimmter Position: Slicing ist flexibel und effektiv.

4. Leistungsvergleich

In Python kann die Leistung je nach Methode zum Zusammenführen von Listen variieren. Bei kleinen Datenmengen fällt der Leistungsunterschied kaum ins Gewicht, aber mit zunehmender Datenmenge wird der Unterschied spürbar. In diesem Abschnitt vergleichen wir die Leistung repräsentativer Zusammenführungsmethoden.

4.1 Testmethode und Voraussetzungen

Um die Leistung zu vergleichen, führen wir den Code unter den folgenden Bedingungen aus.

• Listengröße: Eine Liste mit 100.000 Elementen verwenden.
• Vergleichsparameter: Die Ausführungszeit (Verarbeitungszeit) messen.
• Umgebung: Messung mit dem time-Modul der Python-Standardbibliothek.

Basierend auf dem folgenden Code vergleichen wir die Ausführungszeiten des +-Operators, der extend()-Methode, der append()-Methode und des Slices.

Beispielcode

import time

## Testlisten
list1 = [i for i in range(100000)]
list2 = [j for j in range(100000)]

## + Operator
start = time.time()
combined = list1 + list2
print("Plus:", time.time() - start)

## extend()-Methode
start = time.time()
list1.extend(list2)
print("Extend:", time.time() - start)

## append()-Methode (Hinzufügen in Schleife)
list1 = [i for i in range(100000)]
start = time.time()
for item in list2:
    list1.append(item)
print("Append in Loop:", time.time() - start)

## Slice
list1 = [i for i in range(100000)]
start = time.time()
list1[len(list1):] = list2
print("Slice:", time.time() - start)

4.2 Leistungsergebnisse

Ein Beispiel für die Ausführungsresultate wird unten gezeigt (Unterschiede je nach Umgebung können auftreten).

| Methode | Ausführungszeit (Sekunden) |
|–||
|+-Operator | 0.08 |
|extend()| 0.03 |
|append()(Schleife) | 0.25 |
| Slice | 0.04 |

4.3 Erläuterung der Ergebnisse

+ Operator

• Geschwindigkeit: Mittel.
• Merkmale: Da eine neue Liste erstellt wird, kann der Speicherverbrauch zunehmen.
• Anwendungsfälle: Geeignet für die Verkettung kleiner Listen.

extend() Methode

• Geschwindigkeit: Sehr hoch.
• Merkmale: Ändert die ursprüngliche Liste direkt, daher guter Speichereffizienz.
• Anwendungsfälle: Optimal für die Verkettung großer Datenmengen.

append() Methode (Schleifenverwendung)

• Geschwindigkeit: Sehr langsam.
• Merkmale: Fügt Elemente einzeln hinzu, daher langsame Verarbeitung.
• Anwendungsfälle: Geeignet, wenn Daten einzeln generiert werden, aber nicht für große Mengen.

Slice

• Geschwindigkeit: Hoch.
• Merkmale: Hohe Flexibilität, praktisch zum Einfügen an spezifischen Positionen.
• Anwendungsfälle: Effektiv zum Einfügen mehrerer Elemente an spezifischen Positionen.

4.4 Welche Methode sollte gewählt werden?

Kleine Listen:

• Empfohlene Methode: + Operator oderextend().
• Grund: Der Speicherverbrauch ist kein großes Problem, und die Syntax ist knapp.

Große Listen:

• Empfohlene Methode: extend().
• Grund: Schnell und speichereffizient.

Hinzufügen von Elementen an spezifischer Position:

• Empfohlene Methode: Slice.
• Grund: Hohe Flexibilität und effizientes Einfügen mehrerer Elemente.

5. Hinweise und häufige Fehler beim Zusammenführen von Listen

Das Zusammenführen von Listen ist eine nützliche Operation, aber wenn sie nicht richtig verwendet wird, kann sie zu unerwarteten Ergebnissen führen. In diesem Abschnitt erklären wir die Punkte, auf die beim Zusammenführen von Listen zu achten ist, sowie häufige Fehler und deren Behebung.

5.1 Verwechslung von append() und extend()

Problem

append() und extend() haben ähnliche Namen und werden daher leicht verwechselt. Besonders fehleranfällig ist es, wenn man eine gesamte Liste hinzufügen möchte.

Beispiel

list1 = [1, 2, 3]
list2 = [4, 5]

list1.append(list2)
print(list1)  ## Ausgabe: [1, 2, 3, [4, 5]]

In diesem Fall wird die gesamte Liste list2 verschachtelt hinzugefügt.

Lösung

Wenn Sie die gesamte Liste entfalten und hinzufügen möchten, verwenden Sie extend().

list1 = [1, 2, 3]
list2 = [4, 5]

list1.extend(list2)
print(list1)  ## Ausgabe: [1, 2, 3, 4, 5]

5.2 Speicherverbrauch des + Operators

Problem

Beim Verwenden des + Operators wird eine neue Liste erstellt. Daher kann beim Zusammenführen sehr großer Listen der Speicherverbrauch zunehmen.

Beispiel

list1 = [i for i in range(1000000)]
list2 = [j for j in range(1000000)]

combined = list1 + list2  ## Eine neue Liste wird erstellt

Bei dieser Operation werden zusätzlich zu list1 und list2 eine neue Liste combined im Speicher erstellt, was zu einer hohen Speicherbelastung führt.

Lösung

Für das Zusammenführen großer Datenmengen kann der Speicherverbrauch durch die Verwendung von extend() verbessert werden.

5.3 Indexfehler bei insert() oder Slicing

Problem

Beim Verwenden von insert() oder Slicing-Operationen kann die Angabe eines ungültigen Index zu unerwarteten Ergebnissen führen.

Beispiel

list1 = [1, 2, 3]
list1.insert(10, 4)
print(list1)  ## Ausgabe: [1, 2, 3, 4]

In diesem Beispiel wird kein Fehler ausgelöst, auch wenn Index 10 nicht existiert, und das Element wird ans Ende hinzugefügt.

Lösung

Überprüfen Sie die Länge der Liste und geben Sie einen geeigneten Index an, oder erwägen Sie die Verwendung von Slicing.

5.4 Nebenwirkungen mutierbarer Listen

Problem

append() und extend() ändern die ursprüngliche Liste direkt. Daher können bei Referenzierung derselben Liste an mehreren Stellen unerwartete Nebenwirkungen auftreten.

Beispiel

list1 = [1, 2, 3]
list2 = list1  ## list1 und list2 referenzieren dieselbe Liste
list1.append(4)
print(list2)  ## Ausgabe: [1, 2, 3, 4]

Lösung

Kopieren Sie die Liste, um zu verhindern, dass die ursprüngliche Liste geändert wird.

list1 = [1, 2, 3]
list2 = list1[:]
list1.append(4)
print(list2)  ## Ausgabe: [1, 2, 3]

5.5 Inkonsistenz der Datentypen

Problem

Wenn die zu kombinierenden Daten nicht den erwarteten Typ haben, kann ein Fehler auftreten.

Beispiel

list1 = [1, 2, 3]
list1.extend(4)  ## TypeError: 'int' object is not iterable

Lösung

Stellen Sie sicher, dass die hinzuzufügenden Daten iterierbar sind (z. B. Liste, Tupel usw.).

list1 = [1, 2, 3]
list1.extend([4])  ## Korrekte Methode

5.6 Zusammenfassung

• Unterschied zwischen append() und extend() verstehen und in den richtigen Situationen verwenden ist wichtig.
• Speicherverbrauch berücksichtigen und Situationen erkennen, in denen extend() dem + Operator vorgezogen werden sollte.
• Beim Verwenden von Slicing oder insert() auf den Index achten, damit Elemente am vorgesehenen Ort hinzugefügt werden.
• Um Nebenwirkungen zu vermeiden, die Liste kopieren nicht vergessen.
• Um unerwartete Fehler beim Zusammenführen von Listen zu vermeiden, ist es wichtig, den Typ der Eingabedaten im Voraus zu überprüfen.

6. Zusammenfassung

Die Verkettung von Listen in Python ist eine unverzichtbare Fähigkeit, um Daten effizient zu verwalten und zu manipulieren. In diesem Artikel haben wir die fünf wichtigsten Methoden zur Verkettung von Listen detailliert erläutert, einschließlich ihrer Anwendungsbereiche, Leistung und Vorsichtsmaßnahmen. In diesem Abschnitt blicken wir auf den bisherigen Inhalt zurück und überprüfen erneut, wie man die richtige Methode zur Listenverkettung wählt.

6.1 Rückblick auf die Merkmale der Verkettungsmethoden

1. append() Methode

• Merkmale: Fügt ein einzelnes Element ans Ende der Liste hinzu.
• Anwendungsbeispiele: Ideal, wenn Elemente einzeln hinzugefügt werden sollen.
• Vorsichtsmaßnahmen: Nicht geeignet zum Verkettung ganzer Listen.

2. extend() Methode

• Merkmale: Entpackt eine andere Liste oder ein Iterables und fügt es ans Ende der ursprünglichen Liste hinzu.
• Anwendungsbeispiele: Für die effiziente Verkettung großer Datenmengen.
• Vorsichtsmaßnahmen: Die ursprüngliche Liste wird geändert.

3. insert() Methode

• Merkmale: Fügt ein einzelnes Element an einer bestimmten Position ein.
• Anwendungsbeispiele: Wenn Elemente an einer bestimmten Position in der Liste hinzugefügt werden sollen.
• Vorsichtsmaßnahmen: Bei häufiger Verwendung kann die Verarbeitungsgeschwindigkeit abnehmen.

4. + Operator

• Merkmale: Verkettet zwei Listen und erstellt eine neue Liste.
• Anwendungsbeispiele: Praktisch für die Verkettung kleiner Listen.
• Vorsichtsmaßnahmen: Bei großen Datenmengen verschlechtert sich die Speichereffizienz.

5. Slicing

• Merkmale: Fügt mehrere Elemente an beliebiger Position ein und verketten.
• Anwendungsbeispiele: Wenn flexible Operationen erforderlich sind.
• Vorsichtsmaßnahmen: Es ist notwendig, den Index korrekt anzugeben.

6.2 Empfohlene Methoden je nach Anwendung

• Kleine Datenmengen: Der +-Operator ist einfach und geeignet.
• Große Datenmengen: extend() ist aufgrund der guten Speichereffizienz empfehlenswert.
• Hinzufügen eines Elements: append() ist in Schleifenverarbeitungen usw. geeignet.
• Einfügen an einer bestimmten Position: Verwenden Sie insert() oder Slicing.
• Hinzufügen mehrerer Elemente an einer bestimmten Position: Slicing ist flexibel und effektiv.

6.3 Vorsichtsmaßnahmen bei der Verkettung

• Verstehen Sie den Unterschied zwischen append() und extend() und verwenden Sie sie angemessen.
• Achten Sie bei großen Datenmengen auf die Leistung und priorisieren Sie extend().
• Operationen, die eine neue Liste erstellen (+-Operator) erfordern Aufmerksamkeit auf den Speicherverbrauch.
• Um das Risiko von Nebenwirkungen zu vermeiden, verwenden Sie Slicing beim Kopieren von Listen.
• Um Fehler durch Typinkompatibilität zu verhindern, stellen Sie sicher, dass die zu verknüpfenden Daten iterierbar sind.

6.4 Nächste Schritte

Diesen Artikel als Referenz nutzend, üben Sie das Manipulieren von Listen in Python praktisch. Wählen Sie die Verkettungsmethode passend zu Ihrem Zweck und lernen Sie, effizienten Code zu schreiben. Das ist wichtig.

Empfohlene Übungen:

1. Versuchen Sie jede Verkettungsmethode aus:

• Vergleichen Sie die Ausführungsgeschwindigkeit für kleine und große Listen.

1. Testen Sie absichtlich Fehlerfälle:

• Führen Sie Operationen mit Typinkompatibilitäten oder ungültigen Indizes aus, um Fehler zu verstehen.

1. Denken Sie an flexible Operationen:

• Implementieren Sie benutzerdefinierte Verkettungsprozesse durch Kombination von Slicing und extend().

Durch ein tieferes Verständnis der Listenverkettung können Sie effizienteren und fehlerärmeren Code schreiben.

Häufig gestellte Fragen (FAQ)

Q1: Was ist der Unterschied zwischen append() und extend()?

A1:

• append(): Fügt ein Element ans Ende der Liste hinzu. Wenn das Element eine Liste ist, wird es verschachtelt hinzugefügt.
  Beispiel:

  list1 = [1, 2, 3]
  list1.append([4, 5])
  print(list1)  ## Ausgabe: [1, 2, 3, [4, 5]]

• extend(): Entpackt eine andere Liste oder ein Iterierbares (z. B. Tupel oder Menge) und fügt die Elemente ans Ende der Liste hinzu. Es wird nicht verschachtelt.
  Beispiel:

  list1 = [1, 2, 3]
  list1.extend([4, 5])
  print(list1)  ## Ausgabe: [1, 2, 3, 4, 5]

Q2: Welche Methode ist optimal zum Zusammenführen großer Datenmengen?

A2:
Beim Zusammenführen großer Datenmengen ist extend() die optimale Wahl. Da die ursprüngliche Liste direkt geändert wird, wird im Gegensatz zum +-Operator keine neue Liste erstellt, was den Speicherverbrauch reduziert.Beispiel:

list1 = [i for i in range(1000000)]
list2 = [j for j in range(1000000)]

list1.extend(list2)  ## Speichereffizient

Q3: Wie kann man Listen mit Slicing zusammenführen?

A3:
Mit Slicing können Elemente an einer bestimmten Position in der Liste eingefügt oder zusammengeführt werden. Es ist nützlich, um eine andere Liste in einen Teil der Liste einzufügen, wie im Folgenden.Beispiel:

list1 = [1, 5]
list1[1:1] = [2, 3, 4]
print(list1)  ## Ausgabe: [1, 2, 3, 4, 5]

Slicing ist flexibel und eignet sich zum einmaligen Einfügen mehrerer Elemente. Achten Sie jedoch darauf, den Index nicht falsch anzugeben.

Q4: Sollte man den + -Operator oder extend() wählen?

A4:

• Beim Zusammenführen kleiner Listen ist der + -Operator knapp und geeignet.
  Beispiel:

  list1 = [1, 2]
  list2 = [3, 4]
  result = list1 + list2
  print(result)  ## Ausgabe: [1, 2, 3, 4]

• Bei großen Listen ist extend() in Bezug auf Speichereffizienz und Geschwindigkeit überlegen.

Q5: Welche häufigen Fehler gibt es beim Zusammenführen von Listen?

A5:
Folgende Fehler treten häufig auf.

1. TypeError: ‚int‘ object is not iterable

• Dies tritt auf, wenn ein Nicht-Iterierbares (z. B. eine Ganzzahl) an extend() übergeben wird.
  Lösung: Geben Sie ein Iterierbares (z. B. Liste oder Tupel) weiter.
  Beispiel:

   list1 = [1, 2, 3]
   list1.extend([4])  ## Korrekte Verwendung

2. Unerwartete Erzeugung verschachtelter Listen

• Bei Verwendung von append() für eine Liste wird die gesamte Liste als ein Element behandelt.
  Lösung: Verwenden Sie extend(), um Verschachtelung zu vermeiden.

Q6: Welche Methode zum Zusammenführen von Listen ist die schnellste?

A6:
Für hohe Geschwindigkeit ist extend() am besten geeignet. Besonders beim Zusammenführen großer Datenmengen ist extend() effizienter als der +-Operator.Beispiel:
Hier ist ein Beispiel für einen Leistungsvergleich (abhängig von der Umgebung).