Verwendung der Python-Filterfunktion

Einführung

Die in Python eingebaute filter()-Funktion kann verwendet werden, um einen neuen Iterator aus einer vorhandenen Iterablen (z. B. einer Liste oder einem Wörterbuch) zu erstellen, der mit Hilfe einer von uns bereitgestellten Funktion effizient Elemente herausfiltert. Eine Iterable ist ein Python-Objekt, über das „iteriert“ werden kann, das heißt, es gibt Elemente in einer solchen Reihenfolge zurück, dass wir es in einer for-Schleife verwenden können.

Die grundlegende Syntax für die filter()-Funktion ist:

filter(function, iterable)

Dies gibt ein Filterobjekt zurück, das eine Iterable ist. Wir können eine Funktion wie list() verwenden, um eine Liste aller Elemente zu erstellen, die in einem Filterobjekt zurückgegeben werden.

Die filter()-Funktion bietet eine Möglichkeit, Werte zu filtern, die oft effizienter sein kann als ein Listenverständnis, besonders wenn wir anfangen, mit größeren Datensätzen zu arbeiten. Zum Beispiel erstellt ein Listenverständnis eine neue Liste, was die Laufzeit für diese Verarbeitung erhöht. Das bedeutet, dass wir, nachdem unser Listenverständnis seinen Ausdruck beendet hat, zwei Listen im Speicher haben werden. Mit filter() wird jedoch ein einfaches Objekt erzeugt, das einen Verweis auf die ursprüngliche Liste, die bereitgestellte Funktion und einen Index für die Stelle in der ursprünglichen Liste enthält, was weniger Speicherplatz beansprucht.

In diesem Tutorial werden wir vier verschiedene Arten der Verwendung von filter() betrachten: mit zwei verschiedenen iterierbaren Strukturen, mit einer lambda Funktion und ohne definierte Funktion.

Verwendung von filter() mit einer Funktion

Das erste Argument von filter() ist eine Funktion, mit der wir entscheiden, ob wir jedes Element einschließen oder herausfiltern. Die Funktion wird für jedes Element in der als zweites Argument übergebenen Iterable einmal aufgerufen und gibt jedes Mal False zurück, wobei der Wert weggelassen wird. Da es sich bei diesem Argument um eine Funktion handelt, können wir entweder eine normale Funktion übergeben oder wir können lambda-Funktionen verwenden, insbesondere wenn der Ausdruck weniger komplex ist.

Nachfolgend ist die Syntax eines lambda mit filter():

filter(lambda item: item expression, iterable)

Bei einer Liste, wie der folgenden, können wir eine lambda-Funktion mit einem Ausdruck einbinden, gegen den wir jedes Element der Liste auswerten wollen:

creature_names = 

Um diese Liste zu filtern, um die Namen unserer Aquarienbewohner zu finden, die mit einem Vokal beginnen, können wir die folgende lambda-Funktion ausführen:

print(list(filter(lambda x: x.lower() in 'aeiou', creature_names)))

Hier deklarieren wir ein Element in unserer Liste als x. Dann stellen wir unseren Ausdruck so ein, dass er auf das erste Zeichen jeder Zeichenkette (oder das Zeichen „Null“) zugreift, also x. Indem wir die Groß- und Kleinschreibung jedes der Namen verringern, stellen wir sicher, dass die Buchstaben mit der Zeichenkette in unserem Ausdruck übereinstimmen, also 'aeiou'.

Schließlich übergeben wir die Iterable creature_names. Wie im vorherigen Abschnitt wenden wir list() auf das Ergebnis an, um aus dem zurückgegebenen Iterator filter() eine Liste zu erzeugen.

Die Ausgabe sieht dann wie folgt aus:

Output

Das gleiche Ergebnis kann mit einer von uns definierten Funktion erreicht werden:

creature_names = def names_vowels(x): return x.lower() in 'aeiou'filtered_names = filter(names_vowels, creature_names)print(list(filtered_names))

Unsere Funktion names_vowels definiert den Ausdruck, den wir zum Filtern von creature_names implementieren werden.

Auch hier würde die Ausgabe wie folgt aussehen:

Output

Insgesamt erreichen wir mit lambda-Funktionen das gleiche Ergebnis, wie wenn wir eine reguläre Funktion verwenden. Die Notwendigkeit, eine reguläre Funktion zu definieren, wächst mit der Komplexität der Ausdrücke zum Filtern unserer Daten, was wahrscheinlich die bessere Lesbarkeit unseres Codes fördert.

Verwenden von None mit filter()

Wir können None als erstes Argument an filter() übergeben, damit der zurückgegebene Iterator jeden Wert herausfiltert, den Python als „falsch“ betrachtet. Im Allgemeinen betrachtet Python alles mit einer Länge von 0 (wie eine leere Liste oder eine leere Zeichenkette) oder numerisch äquivalent zu 0 als falsch, daher die Verwendung des Begriffs „falsy“.“

Im folgenden Fall wollen wir unsere Liste so filtern, dass nur die Nummern der Becken in unserem Aquarium angezeigt werden:

aquarium_tanks = , {}]

In diesem Code haben wir eine Liste mit ganzen Zahlen, leeren Sequenzen und einem booleschen Wert.

filtered_tanks = filter(None, aquarium_tanks)

Wir verwenden die filter()-Funktion mit None und übergeben die aquarium_tanks-Liste als unsere Iterable. Da wir None als erstes Argument übergeben haben, werden wir prüfen, ob die Elemente in unserer Liste als falsch angesehen werden.

print(list(filtered_tanks))

Dann verpacken wir filtered_tanks in eine list()-Funktion, damit sie beim Drucken eine Liste für filtered_tanks zurückgibt.

Hier zeigt die Ausgabe nur die Ganzzahlen. Alle Elemente, die zu False ausgewertet wurden, die in ihrer Länge 0 entsprechen, wurden von filter() entfernt:

Output

Hinweis: Wenn wir list() nicht verwenden und filtered_tanks ausgeben, würden wir ein Filterobjekt etwa so erhalten: <filter object at 0x7fafd5903240>. Das Filterobjekt ist eine Iterable, wir könnten also mit for eine Schleife darüber laufen lassen oder wir können list() verwenden, um es in eine Liste zu verwandeln, was wir hier tun, weil es eine gute Möglichkeit ist, die Ergebnisse zu überprüfen.

Mit None haben wir filter() verwendet, um schnell Elemente aus unserer Liste zu entfernen, die als falsch angesehen wurden.

Using filter() with a List of Dictionaries

Wenn wir eine komplexere Datenstruktur haben, können wir immer noch filter() verwenden, um jedes der Elemente auszuwerten. Wenn wir z. B. eine Liste von Wörterbüchern haben, wollen wir nicht nur über jedes Element in der Liste – eines der Wörterbücher – iterieren, sondern wir wollen vielleicht auch über jedes Schlüssel:Wert-Paar in einem Wörterbuch iterieren, um alle Daten auszuwerten.

Als Beispiel nehmen wir an, wir haben eine Liste mit jedem Lebewesen in unserem Aquarium zusammen mit verschiedenen Details über jedes von ihnen:

aquarium_creatures = 

Wir wollen diese Daten nach einem Suchstring filtern, den wir der Funktion übergeben. Um filter() auf jedes Wörterbuch und jedes Element in den Wörterbüchern zugreifen zu lassen, konstruieren wir eine verschachtelte Funktion, wie die folgende:

def filter_set(aquarium_creatures, search_string): def iterator_func(x): for v in x.values(): if search_string in v: return True return False return filter(iterator_func, aquarium_creatures)

Wir definieren eine filter_set()-Funktion, die aquarium_creatures und search_string als Parameter nimmt. In filter_set() übergeben wir unser iterator_func() als Funktion an filter(). Die Funktion filter_set() gibt den Iterator zurück, der aus filter() resultiert.

Das iterator_func() nimmt x als Argument, das ein Element in unserer Liste (also ein einzelnes Wörterbuch) darstellt.

Als Nächstes greift die for-Schleife auf die Werte in jedem Schlüssel:Wert-Paar in unseren Wörterbüchern zu und verwendet dann eine bedingte Anweisung, um zu prüfen, ob sich das search_string in v befindet, was einen Wert repräsentiert.

Wie in unseren vorherigen Beispielen, wenn der Ausdruck True auswertet, fügt die Funktion das Element zum Filterobjekt hinzu. Dies wird zurückgegeben, sobald die Funktion filter_set() abgeschlossen ist. Wir positionieren return False außerhalb unserer Schleife, damit es jedes Element in jedem Wörterbuch prüft, anstatt nur nach der Prüfung des ersten Wörterbuchs zurückzukehren.

Wir rufen filter_set() mit unserer Liste von Wörterbüchern und dem Suchbegriff auf, für den wir Übereinstimmungen finden wollen:

filtered_records = filter_set(aquarium_creatures, "2") 

Nach Abschluss der Funktion haben wir unser Filterobjekt in der Variablen filtered_records gespeichert, das wir in eine Liste umwandeln und ausdrucken:

print(list(filtered_records)) 

Wir erhalten folgende Ausgabe von diesem Programm:

Output

Wir haben die Liste der Wörterbücher mit dem Suchbegriff 2 gefiltert. Wir sehen, dass die drei Wörterbücher, die eine Tanknummer mit 2 enthalten, zurückgegeben wurden. Durch die Verwendung unserer eigenen verschachtelten Funktion konnten wir auf jedes Element zugreifen und jedes effizient gegen den Suchstring prüfen.

Fazit

In diesem Tutorial haben wir die verschiedenen Möglichkeiten der Verwendung der filter()-Funktion in Python kennengelernt. Nun können Sie filter() mit einer eigenen Funktion, einer lambda Funktion oder mit None verwenden, um nach Elementen in unterschiedlich komplexen Datenstrukturen zu filtern.

Obwohl wir in diesem Tutorial die Ergebnisse von filter() sofort im Listenformat ausgegeben haben, ist es wahrscheinlich, dass wir in unseren Programmen das zurückgegebene filter()-Objekt verwenden und die Daten weiter manipulieren würden.

Wenn Sie mehr über Python erfahren möchten, schauen Sie sich unsere Serie How To Code in Python 3 und unsere Python-Themenseite an.