Eine Anleitung zum Abflachen von Listen und Listen in Python

Die Umwandlung eines zweidimensionalen Arrays in ein eindimensionales Array wird als Abflachung bezeichnet. Es gibt verschiedene Vorgehensweisen, um dieses Problem zu lösen.

In diesem Tutorial werden wir uns einige dieser Methoden genauer ansehen.

Betrachten wir zunächst ein Beispiel:

Eingabe:

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

Ausgabe:

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

#1. Schleifenbasierte Ansätze

Die gebräuchlichste Methode zur Bewältigung dieser Aufgabe ist der Einsatz von Schleifen. Es ist wahrscheinlich, dass die meisten von Ihnen mit dieser Vorgehensweise vertraut sind. Hier sind die einzelnen Schritte zur Lösung dieses Problems mit Hilfe von Schleifen:

• Wir initialisieren eine Liste von Listen mit Testdaten und nennen sie ‚daten‘.
• Anschließend wird eine leere Liste mit dem Namen ‚flache_liste‘ initialisiert.
• Wir iterieren durch die ‚daten‘.
  • Wir entpacken die Elemente der aktuellen Liste.
  • Wir fügen diese der ‚flache_liste‘ mit der ‚append‘-Methode hinzu.
• Wir geben das Endergebnis aus.

Hier ist der entsprechende Code:

      # Initialisierung der Daten und einer leeren Liste
      daten = [[1, 2, 3], [4, 5], [6, 7, 8, 9, 10]]
      flache_liste = []
      
      # Iteration durch die Daten
      for element in daten:
          # Hinzufügen der Elemente zur flachen_liste
          flache_liste += element
      
      # Ausgabe der resultierenden flachen Liste
      print(flache_liste)
      

Anstelle des Verkettungsoperators können wir auch eine andere Schleife nutzen, um Elemente aus Unterlisten zur ‚flache_liste‘ hinzuzufügen. Ebenso lassen sich Listen-Comprehensions anstelle von Schleifen verwenden.

Beide Ansätze führen zum gleichen Ergebnis. Werfen wir einen Blick auf eine weitere Methode, um das Problem zu lösen.

#2. Einsatz von Itertools – Chain

Für diese Methode verwenden wir die Funktion ‚chain‘ aus dem integrierten Modul ‚itertools‘.

Die ‚chain‘-Funktion iteriert über jede Unterliste und liefert die Elemente, bis keine Unterlisten mehr vorhanden sind. Sie gibt ein iterierbares Objekt zurück, das wir anschließend in eine Liste umwandeln müssen.

Hier sind die Schritte zur Lösung des Problems:

• Wir initialisieren eine Liste von Listen mit Testdaten und nennen sie ‚daten‘.
• Wir erstellen ein abgeflachtes, iterierbares Objekt mithilfe von ‚itertools.chain(*daten)‘.
• Wir wandeln das resultierende iterierbare Objekt in eine Liste um.
• Wir geben die abgeflachte Liste aus.

Hier ist der entsprechende Code:

      # Importieren des Moduls
      import itertools
      
      # Initialisierung der Daten
      daten = [[1, 2, 3], [4, 5], [6, 7, 8, 9, 10]]
      
      # Abflachen der Liste und Speichern des Ergebnisses
      flache_liste = itertools.chain(*daten)
      
      # Umwandeln des iterierbaren Objekts in eine Liste und Ausgabe
      print(list(flache_liste))
      

#3. Rekursive Abflachung mehrstufiger Listen

Bisher haben wir uns mit der Abflachung von Listen mit einer Ebene beschäftigt. Die oben genannten Methoden sind für Listen mit mehreren Ebenen nicht geeignet. Betrachten wir das folgende Beispiel:

Eingabe:

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

Ausgabe:

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

Da die Tiefe der Liste im Voraus nicht bekannt ist, ist es notwendig, das Problem mithilfe von Rekursion zu lösen.

• Wir initialisieren die Daten, wie im Beispiel gezeigt, und nennen sie ‚daten‘.
• Wir initialisieren eine leere Liste namens ‚flache_liste‘.
• Wir erstellen eine Funktion mit dem Namen ‚abflachen_liste‘.
  • Wir iterieren durch die Elemente der übergebenen Liste.
  • Wenn ein Element eine Liste ist, rufen wir die Funktion ‚abflachen_liste‘ rekursiv mit diesem Element auf.
  • Wenn ein Element keine Liste ist, hängen wir dieses Element an ‚flache_liste‘ an.
• Wir rufen die Funktion ‚abflachen_liste‘ mit den ‚daten‘ auf.
• Die Funktion fügt alle Elemente der abgeflachten Liste in ‚flache_liste‘ ein.
• Wir geben die ‚flache_liste‘ aus, um das Ergebnis zu überprüfen.

Das sind einige Schritte. Aber keine Sorge, die Umsetzung in Code dauert nicht lange:

    # Initialisierung der Daten und der leeren Liste
    daten = [1, [2, 3, [4, 5]], 6, [[7], [8, 9]]]
    flache_liste = []
    
    # Definition der Funktion
    def abflachen_liste(daten):
        # Iteration durch die Daten
        for element in daten:
            # Überprüfung, ob das Element eine Liste ist
            if type(element) == list:
                # Rekursiver Aufruf der Funktion mit dem aktuellen Element
                abflachen_liste(element)
            else:
                flache_liste.append(element)
    
    # Abflachen der gegebenen Liste
    abflachen_liste(daten)
    
    # Ausgabe der abgeflachten Liste
    print(flache_liste)
    

Es ist wichtig zu beachten, dass wir die vorhandene Liste nicht transformiert haben, sondern stattdessen eine neue Liste mit den Elementen erstellt haben.

Fazit

Ich hoffe, dieses Tutorial hat Ihnen gefallen. Es gibt sicherlich weitere Möglichkeiten, eine Liste in Python abzuflachen, aber die hier gezeigten sind meiner Meinung nach die einfachsten und am leichtesten zu verstehen.

Viel Spaß beim Programmieren! 🙂