Python filter(): Behalte, was du brauchst

Filtern ist eine der häufigsten Aufgaben in Python, deshalb macht Python es dir leicht. Eine der einfachsten Möglichkeiten, Daten zu filtern, ist die eingebaute Funktion filter(). Wie der Name schon sagt, kannst du mit filter() nur die Artikel herausziehen, die eine bestimmte Bedingung (oder Bedingungen) erfüllen.

In diesem Leitfaden erfährst du, wie sie funktioniert, wann du sie einsetzen solltest und wie sie im Vergleich zu anderen Filterwerkzeugen funktioniert. Lies mal!

Was Python filter() macht

filter() kannst du Elemente aus einer Liste, einem Tupel oder einer beliebigen Iterablen herausziehen, aber nur, wenn sie deinen Test bestehen. Du gibst eine Funktion an (manchmal wird sie auch Prädikat genannt), die jedes Element aufnimmt und True oder False zurückgibt. Wenn der Test bestanden wird (sprich: wenn deine Funktion True zurückgibt), behält filter() sie. Andernfalls wird das Element übersprungen. Das ist ziemlich selbsterklärend, also lass uns weitermachen.

Python filter() Syntax

Hier ist das Format:

filter(function, iterable)

• function: Legt die Prüfung fest, die du auf jedes Element anwenden willst. Sie sollte ein Argument annehmen und True oder False zurückgeben.

• iterable: Liefert eine Liste, ein Tupel, einen String oder ein beliebiges Objekt, über das du eine Schleife ziehen kannst.

Wenn du filter() aufrufst, wird ein spezielles Filterobjekt zurückgegeben, nicht direkt eine Liste oder ein Tupel. Um mit den gefilterten Ergebnissen zu arbeiten, verpackst du die Ausgabe normalerweise in eine Liste oder ein Tupel. Diese Entscheidung sorgt dafür, dass filter() effizient bleibt, aber es ist etwas, das du beim Schreiben deines Codes im Hinterkopf behalten solltest.

Python filter() Beispiele

Lass uns ein bisschen üben.

Python filter() mit einer eigenen Funktion

Verwenden wir filter() mit einer Funktion, die wir für uns selbst schreiben.

Angenommen, du willst nur die geraden Zahlen aus einer Liste behalten:

def is_even(num):
    return num % 2 == 0

numbers = [1, 2, 3, 4, 5, 6]
result = filter(is_even, numbers)
print(list(result))

Dies wird gedruckt:

[2, 4, 6]

Beachte, wie is_even prüft, ob eine Zahl durch 2 teilbar ist. filter() nutzt unsere benutzerdefinierte Funktion, um jedes Element zu testen und die zu behalten, die unseren Test bestehen.

Python filter() mit Lambda-Funktionen

Natürlich braucht nicht jeder Filter eine vollständige Funktionsdefinition. Manchmal ist deine Filterregel so einfach oder so spezifisch für eine Stelle, dass die Definition einer benannten Funktion zu viel Arbeit ist.

Hier ist dasselbe Beispiel mit geraden Zahlen, aber mit einem Lambda für einen präzisen In-Place-Test:

numbers = [1, 2, 3, 4, 5, 6] 
result = filter(lambda x: x % 2 == 0, numbers) 
print(list(result))

Du erhältst die gleiche Ausgabe wie zuvor.

Die Verwendung von Lambdas mit filter() ist besonders dann üblich, wenn du deinen Code kurz und konzentriert halten willst. Sie eignet sich hervorragend für einmalige Filteraufgaben, denn so kannst du deine Regel genau dort ausdrücken, wo du sie brauchst.

Python filter() mit None als Funktion

Manchmal möchtest du filter() leere oder falsche Werte ausschließen. Dinge wie 0, leere Zeichenketten, None oder False, und wir wollen das tun, ohne eine eigene Funktion zu schreiben.

Python hat dafür einen Trick: Wenn du das Funktionsargument in filter() auf None setzt, entfernt filter() automatisch alle Elemente, die Python als False betrachtet.

Hier ist ein Beispiel:

items = [0, 1, '', 'hello', [], [2, 3], None, False, True] 
result = filter(None, items) 
print(list(result))

Dies wird gedruckt:

[1, 'hello', [2, 3], True]

Textdaten filtern

Jetzt wollen wir filter() auf ein praktisches, alltägliches Problem anwenden. Angenommen, du hast eine Liste von Wörtern und willst nur die, die mit "a" beginnen. Diese Art des gezielten Filterns kommt bei der Textverarbeitung immer wieder vor.

words = ['apple', 'banana', 'apricot', 'cherry', 'avocado'] 
result = filter(lambda word: word.startswith('a'), words) 
print(list(result))

Du bekommst:

['apple', 'apricot', 'avocado']

Filtern mit mehreren Bedingungen

Manchmal werden deine Filterkriterien etwas komplexer. Was ist, wenn du Gegenstände brauchst, die mehrere Bedingungen erfüllen? Hier siehst du, wie du das mit einem Lambda machen kannst. In diesem Beispiel geht es darum, Zahlen zu finden, die gerade und größer als 10 sind.

numbers = [4, 10, 12, 15, 20, 23, 28] 
result = filter(lambda x: x % 2 == 0 and x > 10, numbers) 
print(list(result))

Dies druckt:

[12, 20, 28]

(Wenn ich noch mehr Bedingungen hätte, würde ich der Übersichtlichkeit halber von einem Lambda zu einer benannten Funktion wechseln).

filter() vs. Liste Verstehen

Listen sind eine weitere beliebte Methode, um Elemente auszuwählen. Mit beiden Ansätzen kannst du Daten filtern, aber jeder hat seinen eigenen Stil.

Hier ist wieder das Beispiel mit den geraden Zahlen, diesmal mit einem Listenverständnis:

numbers = [1, 2, 3, 4, 5, 6] 
result = [x for x in numbers if x % 2 == 0] 
print(result)

[2, 4, 6]

Sowohl filter() als auch List Comprehensions erledigen die Arbeit. Listen sind bei einfachen Filtern oft leichter zu lesen, besonders wenn die Regel kurz und einfach ist.

Auf der anderen Seite funktioniert filter() gut, wenn du bereits mit Funktionen arbeitest oder wenn du mehrere Verarbeitungsschritte miteinander verketten willst.

Erweiterte Einsatzmöglichkeiten

Lass uns versuchen, noch ein paar interessante Fälle zu finden:

filter() mit anderen Iterablen

So wie wir es mit Listen gemacht haben, funktioniert filter() auch mit allen iterierbaren Größen, wie Tupeln, Mengen und sogar Generatorausdrücken. Das ist gut zu wissen, denn deine Daten werden nicht immer in Listenform vorliegen.

Hier siehst du, wie du ein Tupel filtern kannst:

numbers = (10, 15, 20, 25, 30) 
result = filter(lambda x: x > 20, numbers) 
print(tuple(result))

Dies wird gedruckt:

(25, 30)

Vergiss nicht, das Filterobjekt in den gewünschten Typ (Liste, Tupel usw.) umzuwandeln, wenn du die Ergebnisse direkt verwenden willst.

Da ich auch Generatoren erwähnt habe, zeige ich der Vollständigkeit halber auch ein Beispiel für das Filtern mit Generatoren:

numbers = (x for x in range(10))
result = filter(lambda x: x % 2 == 0, numbers)
print(list(result))

Dies ist ein Generator, denn diese Zeile: numbers = (x for x in range(10)) erzeugt ein Generator-Objekt. (Es ist faul und generiert nicht alle Werte auf einmal).

Die letzte Zeile: print(list(result)) erzwingt die Auswertung, indem sie das Lazy-Filter-Objekt in eine Liste umwandelt.

Kombination von filter() mit map()

Was ist, wenn du deine Daten sowohl filtern als auch umwandeln willst, z. B. wenn du in unserem nächsten Beispiel nur die geraden Zahlen in einer Liste quadrieren willst?

Python macht es dir leicht, indem es dir erlaubt, filter() und map() zu kombinieren. Zuerst wählt filter() die gewünschten Artikel aus und dann wendet map() eine andere Funktion auf jeden einzelnen an.

So sieht das in der Praxis aus:

numbers = [1, 2, 3, 4, 5, 6] 
evens = filter(lambda x: x % 2 == 0, numbers) 
squared = map(lambda x: x ** 2, evens) 
print(list(squared))

Dies druckt:

[4, 16, 36]

Durch die Verkettung von filter() und map() kannst du übersichtliche, lesbare Datenpipelines erstellen, indem du zuerst die Elemente auswählst, die dich interessieren, und sie dann nach Bedarf umwandelst. Es wird Möglichkeiten geben, dieses Muster in deiner eigenen Arbeit zu verwenden.

Dinge, auf die du achten solltest

So praktisch filter() auch ist, es gibt ein paar Fehler, die Menschen machen:

• filter() gibt ein Filterobjekt zurück, keine Liste. Das kann dich aus dem Konzept bringen, wenn du erwartest, dass du sofort Ergebnisse siehst. Schließe sie immer in eine Liste (oder ein Tupel) ein, wenn du die Ergebnisse sehen oder wiederverwenden willst.

• filter() funktioniert immer nur mit einer Iterablen zur gleichen Zeit. Wenn du nach mehreren Listen filtern willst, musst du sie zusammenfassen oder eine andere Methode verwenden.

• filter() ist faul. Die Daten werden erst dann verarbeitet, wenn du sie in eine Liste oder ein Tupel umwandelst oder eine Schleife über sie ziehst. Behalte dieses Verhalten beim Debuggen im Hinterkopf.

Fazit

Wie du gesehen hast, kannst du mit der Funktion filter() in Python schnell Daten bereinigen, indem du nur das herausziehst, was wichtig ist. filter() hilft dir, wenn du ein einmaliges Lambda schreibst oder eine benannte Funktion einfügst. 

Wenn dir nicht klar ist, wie du filter() nutzen kannst, oder wenn du denkst, dass das einfach genug war und du weiter lernen willst, haben wir tolle Ressourcen, die dir helfen. Ich empfehle unseren Lernpfad Python Programming Fundamentals.