Skip to content

lab2.dev is launched! Build python web apps with plain English, no code required.

Python Liste flatten: Vereinfachen Sie Ihren Code mit diesen Tipps

Oluwaseun Adeojo
Name
Oluwaseun Adeojo

Updated on

Das Verflachen einer Liste in Python ist eine häufige Aufgabe, mit der Programmierer konfrontiert werden. Egal, ob Sie es mit einer Liste von Listen oder einer verschachtelten Liste zu tun haben, die Notwendigkeit, diese Strukturen in eine einzelne Liste zu verflachen, ist eine Herausforderung, die oft auftritt. Dieser Artikel führt Sie durch verschiedene Methoden zur Verflachung einer Liste in Python, einschließlich List Comprehension, itertools und numpy.

Python bietet als High-Level-Programmiersprache zahlreiche integrierte Funktionen und Module, die die Manipulation von Listen zum Kinderspiel machen. Bei der Verflachung von Listen gibt es jedoch keine integrierte "flatten"-Funktion. Aber keine Sorge, Python bietet mehrere andere Möglichkeiten, um dies zu erreichen, und wir werden sie in diesem Artikel erkunden.

Möchten Sie schnell Datenvisualisierungen aus einem Python Pandas Dataframe ohne Code erstellen?

PyGWalker ist eine Python-Bibliothek für die explorative Datenanalyse mit Visualisierung. PyGWalker (opens in a new tab) kann Ihren Workflow zur Datenanalyse und Datenvisualisierung in Jupyter Notebook vereinfachen, indem es Ihren Pandas-Datenrahmen (und Polars-Datenrahmen) in eine Tableau-ähnliche Benutzeroberfläche für die visuelle Exploration umwandelt.

PyGWalker zur Datenvisualisierung (opens in a new tab)

Verständnis der Verflachung von Listen in Python

Bevor wir uns mit den Methoden zur Verflachung einer Liste beschäftigen, ist es wichtig zu verstehen, was Verflachung von Listen bedeutet. Das Verflachen einer Liste oder eines anderen Iterables bedeutet, ein mehrdimensionales oder verschachteltes Iterable in eine eindimensionale Liste umzuwandeln.

Betrachten wir zum Beispiel die folgende verschachtelte Liste: [[1, 2, 3], [4, 5], [6, 7, 8, 9]]. Die verflachte Version dieser Liste wäre: [1, 2, 3, 4, 5, 6, 7, 8, 9]. Wie Sie sehen können, wird die verschachtelte Struktur entfernt und es bleibt eine einzelne Liste mit allen Elementen übrig.

Das Verflachen einer Liste ist eine häufige Operation bei der Datenmanipulation und -vorverarbeitung, insbesondere bei Aufgaben der Datenwissenschaft und des maschinellen Lernens. Es ist auch eine beliebte Frage in Programmierinterviews, daher kann es sehr vorteilhaft sein, dieses Konzept zu beherrschen.

Verflachung einer Liste mit List Comprehension

List Comprehension ist eine kompakte Möglichkeit, Listen in Python zu erstellen. Es ist ein syntaktisches Konstrukt, das es Ihnen ermöglicht, Listen aus vorhandenen Listen (oder anderen Iterables) basierend auf einer Bedingung zu erstellen. List Comprehension kann auch verwendet werden, um eine Liste in Python zu verflachen.

So können Sie eine Liste mithilfe von List Comprehension verflachen:

nested_list = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
flattened_list = [item for sublist in nested_list for item in sublist]
print(flattened_list)

In diesem Code durchläuft die List Comprehension jede Unterliste in der verschachtelten Liste und dann jedes Element in der Unterliste. Das Ergebnis ist eine neue Liste, die alle Elemente aus den Unterlisten enthält.

List Comprehension ist ein pythonischer Weg, um eine Liste zu verflachen, und ist im Allgemeinen schneller als herkömmliche for-Schleifen aufgrund der Optimierungen im Python-Interpreter.

Verwendung von itertools zum Verflachen einer Liste

Das Python-Modul itertools bietet eine Reihe von Werkzeugen zum Umgang mit Iteratoren. Unter diesen Werkzeugen befindet sich die Funktion chain(), die zum Verflachen einer Liste verwendet werden kann.

Die Funktion itertools.chain() nimmt mehrere Iterables als Argumente und gibt einen einzelnen Iterator zurück, der den Inhalt der Eingaben als einzigen Stream von Elementen erzeugt. Dadurch eignet sie sich perfekt zum Verflachen einer Liste.

Hier ein Beispiel, wie man `itertools.chain()

()` verwendet, um eine Liste zu verflachen:

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

In diesem Code wird der * Operator verwendet, um die verschachtelte Liste als Argumente an die chain() Funktion zu übergeben. Die chain() Funktion kombiniert dann alle Unterlisten zu einer einzigen Liste.

Die Methode itertools.chain() ist ein mächtiges Werkzeug zum Verflachen von Listen, insbesondere bei der Arbeit mit großen Datensätzen, da sie einen Iterator zurückgibt und keinen Speicher wie List Comprehension oder for-Schleifen verbraucht.

Verflachung einer Liste mit numpy

numpy ist eine beliebte Python-Bibliothek für numerische Operationen. Sie bietet eine Funktion namens flatten(), die zum Verflachen eines Arrays verwendet werden kann. Obwohl numpy hauptsächlich für numerische Berechnungen verwendet wird, kann die Funktion flatten() auch zum Verflachen einer Liste von Listen verwendet werden.

Hier ein Beispiel, wie man die flatten() Funktion von numpy verwendet, um eine Liste zu verflachen:

import numpy as np
 
nested_list = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
flattened_list = np.array(nested_list).flatten().tolist()
print(flattened_list)

In diesem Code wird zuerst die verschachtelte Liste mit der Funktion np.array() in ein numpy-Array umgewandelt. Dann wird die flatten() Funktion auf das numpy-Array aufgerufen, um es zu verflachen. Schließlich wird das verflachte numpy-Array mit der Funktion tolist() wieder in eine Liste umgewandelt.

Obwohl die flatten() Funktion von numpy praktisch ist, sollte beachtet werden, dass sie möglicherweise nicht die effizienteste Methode zum Verflachen einer Liste ist, insbesondere für nicht-numerische Daten, da die Konvertierung in ein numpy-Array kostspielig sein kann.

Im nächsten Teil dieses Artikels werden wir weitere Methoden zur Verflachung einer Liste in Python erkunden, einschließlich rekursiver Verflachung und mehr. Bleiben Sie dran!

Rekursive Verflachung in Python

Rekursives Aufflachen ist eine weitere Methode, um eine Liste in Python aufzuflachen. Diese Methode ist besonders nützlich, wenn man es mit tief verschachtelten Listen zu tun hat. Die Idee ist, über die Elemente der Liste zu iterieren und für jedes Element, falls es eine Liste ist, diese rekursiv aufzulösen; andernfalls wird es zum Ergebnis hinzugefügt.

Hier ist ein Beispiel, wie man rekursives Aufflachen in Python implementieren kann:

def flatten_list(verschachtelte_liste):
    ergebnis = []
    for i in verschachtelte_liste:
        if isinstance(i, list):
            ergebnis.extend(flatten_list(i))
        else:
            ergebnis.append(i)
    return ergebnis
 
verschachtelte_liste = [[1, 2, [3, 4]], [5, 6], [7, [8, [9]]]]
aufgeflachte_liste = flatten_list(verschachtelte_liste)
print(aufgeflachte_liste)

In diesem Code wird die Funktion flatten_list definiert, um eine Liste als Eingabe zu nehmen und eine aufgeflachte Liste zurückzugeben. Die Funktion iteriert über die Elemente der Eingabeliste und ruft, falls ein Element eine Liste ist, sich selbst rekursiv auf, um diese Liste aufzulösen.

Rekursives Aufflachen ist eine leistungsstarke Methode, um eine Liste aufzulösen, aber es ist zu beachten, dass es zu einem Stackoverflow-Fehler kommen kann, wenn die Liste zu stark verschachtelt ist.

Eine Liste mithilfe der eingebauten Funktionen von Python aufflachen

Obwohl Python keine eingebaute 'flatten'-Funktion hat, bietet es mehrere eingebaute Funktionen, die kombiniert werden können, um eine Liste aufzulösen. Eine solche Kombination ist die sum()-Funktion und List Comprehension.

So kann man die eingebauten Funktionen von Python verwenden, um eine Liste aufzulösen:

verschachtelte_liste = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
aufgeflachte_liste = sum(verschachtelte_liste, [])
print(aufgeflachte_liste)

In diesem Code wird die sum()-Funktion verwendet, um die Elemente der verschachtelten Liste aufzusummieren. Das zweite Argument der sum()-Funktion ist eine leere Liste, die als Anfangswert der Summe dient. Die sum()-Funktion fügt dann die Unterlisten zusammen, um eine einzige Liste zu bilden.

Obwohl diese Methode einfach ist und nur eingebaute Funktionen verwendet, ist sie nicht so effizient wie die anderen Methoden, über die wir gesprochen haben, insbesondere für große Listen, da sie jedes Mal eine neue Liste erstellt, wenn sie zwei Listen zusammenfügt.

Nun beantworten wir einige häufig gestellte Fragen zum Thema Aufflachen einer Liste in Python.

FAQ

  1. Was bedeutet "Aufflachen einer Liste" in Python?

Das Aufflachen einer Liste in Python bedeutet, eine mehrdimensionale oder verschachtelte Liste in eine eindimensionale Liste umzuwandeln. Diese Operation ist in der Datenmanipulation und Vorverarbeitung häufig anzutreffen.

  1. Wie kann ich itertools verwenden, um eine Liste in Python aufzulösen?

Du kannst die chain()-Funktion aus dem itertools-Modul verwenden, um eine Liste in Python aufzulösen. Die chain()-Funktion nimmt mehrere Iterable als Argumente und gibt einen einzigen Iterator zurück, der den Inhalt der Eingaben als einzigen Strom von Elementen erzeugt.

  1. Was ist der Unterschied zwischen flatten() und flat() in Python?

Die flatten()-Funktion ist eine Methode von numpy-Arrays, die eine Kopie des Arrays in eine Dimension zusammenführt. Andererseits ist flat ein Attribut von numpy-Arrays, das einen Iterator über das Array zurückgibt. Dieser Iterator verhält sich ähnlich wie der eingebaute Iterator von Python, kann aber verwendet werden, um die Array-Elemente zu modifizieren.

Fazit

In diesem Artikel haben wir verschiedene Methoden behandelt, um eine Liste in Python aufzulösen, einschließlich List Comprehension, itertools, numpy und rekursivem Aufflachen. Außerdem haben wir einige häufig gestellte Fragen zum Thema Aufflachen von Listen in Python beantwortet. Indem du diese Methoden verstehst, kannst du deinen Code vereinfachen und seine Leistung verbessern, wenn du es mit Listen zu tun hast.