Das Flatten einer Liste, also das Umwandeln einer verschachtelten Liste in eine Liste mit nur einer Ebene, ist eine häufige Aufgabe in Python. Dieser Artikel untersucht verschiedene Techniken zur Erreichung dieses Ziels und kategorisiert sie nach ihrer Flatten-Tiefe: flach und tief.
Inhaltsverzeichnis
Flaches Flatten
Flaches Flatten entfernt nur eine Ebene der Verschachtelung. Es ist ideal, wenn Sie eine Liste von Listen haben, diese inneren Listen aber keine weiteren verschachtelten Strukturen enthalten. Es gibt zwei effiziente Methoden:
List Comprehension: Dies bietet eine prägnante und lesbare Lösung:
nested_list = [[1, 2, 3], [4, 5], [6]]
flat_list = [item for sublist in nested_list for item in sublist]
print(flat_list) # Ausgabe: [1, 2, 3, 4, 5, 6]
itertools.chain.from_iterable: Für größere Listen bietet dieser Ansatz aufgrund seiner optimierten Iteration eine bessere Leistung:
from itertools import chain
nested_list = [[1, 2, 3], [4, 5], [6]]
flat_list = list(chain.from_iterable(nested_list))
print(flat_list) # Ausgabe: [1, 2, 3, 4, 5, 6]
Einschränkungen: Flaches Flatten kann Listen mit verschachtelten Listen innerhalb verschachtelter Listen nicht vollständig flatten. Beispielsweise:
nested_list = [[1, 2, [3, 4]], [5, 6]]
flat_list = [item for sublist in nested_list for item in sublist]
print(flat_list) # Ausgabe: [1, 2, [3, 4], 5, 6]
Die innere Liste [3, 4] bleibt verschachtelt.
Tiefes Flatten
Tiefes Flatten verarbeitet rekursiv verschachtelte Listen beliebiger Tiefe. Es gibt zwei Hauptansätze:
Rekursive Funktion: Diese elegante Lösung verwendet Rekursion, um die verschachtelte Struktur zu durchlaufen:
def flatten(nested_list):
flat_list = []
for item in nested_list:
if isinstance(item, list):
flat_list.extend(flatten(item))
else:
flat_list.append(item)
return flat_list
nested_list = [[1, 2, [3, 4]], [5, 6, [7, [8, 9]]]]
flat_list = flatten(nested_list)
print(flat_list) # Ausgabe: [1, 2, 3, 4, 5, 6, 7, 8, 9]
Iterativer Ansatz (mit einem Stack): Rekursion kann bei extrem tiefer Verschachtelung zu Stack-Overflow-Fehlern führen. Ein iterativer Ansatz mit einem Stack bietet Robustheit:
def flatten_iterative(nested_list):
flat_list = []
stack = [nested_list]
while stack:
current = stack.pop()
if isinstance(current, list):
stack.extend(current)
else:
flat_list.append(current)
return flat_list
nested_list = [[1, 2, [3, 4]], [5, 6, [7, [8, 9]]]]
flat_list = flatten_iterative(nested_list)
print(flat_list) # Ausgabe: [1, 2, 3, 4, 5, 6, 7, 8, 9]
Fazit
Die Wahl zwischen flachem und tiefem Flatten hängt ganz von der Struktur Ihrer verschachtelten Listen ab. Flaches Flatten reicht für die Verschachtelung auf einer Ebene aus und bietet prägnante, effiziente Lösungen. Für beliebig verschachtelte Listen ist jedoch ein tiefes Flatten, vorzugsweise mit dem iterativen stackbasierten Ansatz für Robustheit, notwendig.