Hoe gebruik je de Python filter functie

Inleiding

De ingebouwde Python filter() functie kan worden gebruikt om een nieuwe iterator te maken van een bestaande iterable (zoals een lijst of woordenboek) die efficiënt elementen uitfiltert met behulp van een functie die wij leveren. Een iterable is een Python object dat “iterated over” kan worden, dat wil zeggen, het zal items in een zodanige volgorde teruggeven dat we het kunnen gebruiken in een for loop.

De basissyntaxis voor de filter() functie is:

filter(function, iterable)

Hiermee wordt een filter-object teruggegeven, dat een iterable is. We kunnen een functie als list() gebruiken om een lijst te maken van alle items die in een filterobject worden geretourneerd.

De filter() functie biedt een manier om waarden te filteren die vaak efficiënter kan zijn dan een list comprehension, vooral wanneer we met grotere gegevensverzamelingen beginnen te werken. Een list comprehension zal bijvoorbeeld een nieuwe lijst maken, wat de doorlooptijd voor die verwerking zal verhogen. Dit betekent dat nadat onze list comprehension zijn expressie heeft voltooid, we twee lijsten in het geheugen hebben. Maar filter() maakt een eenvoudig object dat een verwijzing bevat naar de oorspronkelijke lijst, de gegeven functie, en een index van waar we heen moeten in de oorspronkelijke lijst, wat minder geheugen in beslag zal nemen.

In deze tutorial bekijken we vier verschillende manieren om filter() te gebruiken: met twee verschillende iterable structuren, met een lambda functie, en met geen gedefinieerde functie.

Filter() gebruiken met een functie

Het eerste argument voor filter() is een functie, die we gebruiken om te beslissen of elk item moet worden opgenomen of uitgefilterd. De functie wordt eenmaal aangeroepen voor elk item in de iterable die als tweede argument wordt doorgegeven en elke keer als hij False teruggeeft, wordt de waarde weggelaten. Aangezien dit argument een functie is, kunnen we ofwel een normale functie doorgeven of we kunnen gebruik maken van lambda functies, vooral wanneer de expressie minder complex is.

Volgende is de syntaxis van een lambda met filter():

filter(lambda item: item expression, iterable)

Bij een lijst, zoals de volgende, kunnen we een lambda functie inbouwen met een expressie waartegen we elk item uit de lijst willen evalueren:

creature_names = 

Om deze lijst te filteren om de namen van onze aquariumbeesten te vinden die met een klinker beginnen, kunnen we de volgende lambda functie uitvoeren:

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

Hier verklaren we een item in onze lijst als x. Vervolgens stellen we onze expressie in om toegang te krijgen tot het eerste teken van elke string (of teken “nul”), dus x. Door de hoofdletters van elk van de namen te verlagen wordt ervoor gezorgd dat dit overeenkomt met de letters in onze expressie, 'aeiou'.

Ten slotte geven we de iterable creature_names door. Net als in de vorige sectie passen we list() toe op het resultaat om een lijst te maken van de iterator filter() geeft terug.

De output zal de volgende zijn:

Output

Ditzelfde resultaat kan worden bereikt met een functie die we definiëren:

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

Onze functie names_vowels definieert de expressie die we zullen implementeren om creature_names te filteren.

Opnieuw zou de uitvoer er als volgt uitzien:

Output

Over het geheel genomen bereiken lambda functies hetzelfde resultaat met filter() als wanneer we een reguliere functie gebruiken. De noodzaak om een reguliere functie te definiëren neemt toe naarmate de complexiteit van de expressies voor het filteren van onze gegevens toeneemt, wat waarschijnlijk de leesbaarheid van onze code ten goede komt.

Gebruik geen met filter()

We kunnen None als eerste argument doorgeven aan filter() om de teruggestuurde iterator alle waarden te laten filteren die Python als “falsy” beschouwt. Over het algemeen beschouwt Python alles met een lengte van 0 (zoals een lege lijst of lege string) of numeriek gelijkwaardig aan 0 als false, vandaar het gebruik van de term “falsy.”

In het volgende geval willen we onze lijst filteren om alleen de tanknummers bij ons aquarium te tonen:

aquarium_tanks = , {}]

In deze code hebben we een lijst die gehele getallen, lege reeksen en een booleaanse waarde bevat.

filtered_tanks = filter(None, aquarium_tanks)

We gebruiken de filter() functie met None en geven de aquarium_tanks lijst door als onze iterable. Aangezien we None als eerste argument hebben doorgegeven, zullen we controleren of de items in onze lijst als false worden beschouwd.

print(list(filtered_tanks))

Dan wikkelen we filtered_tanks in een list() functie zodat deze een lijst voor filtered_tanks retourneert wanneer we afdrukken.

Hier toont de uitvoer alleen de gehele getallen. Alle items die geëvalueerd zijn met False, die equivalent zijn aan 0 in lengte, zijn verwijderd door filter():

Output

Note: Als we list() niet gebruiken en filtered_tanks afdrukken, zouden we een filterobject krijgen dat er ongeveer zo uitziet: <filter object at 0x7fafd5903240>. Het filterobject is een iterable, dus we kunnen er doorheen lussen met for of we kunnen list() gebruiken om er een lijst van te maken, wat we hier doen omdat het een goede manier is om de resultaten te bekijken.

Met None hebben we filter() gebruikt om snel items van onze lijst te verwijderen die als onwaar werden beschouwd.

Filter() gebruiken met een lijst van woordenboeken

Wanneer we een complexere gegevensstructuur hebben, kunnen we nog steeds filter() gebruiken om elk van de items te evalueren. Bijvoorbeeld, als we een lijst van woordenboeken hebben, willen we niet alleen itereren over elk item in de lijst – een van de woordenboeken – maar we willen misschien ook itereren over elk sleutel:waarde paar in een woordenboek om alle gegevens te evalueren.

Als voorbeeld, laten we zeggen dat we een lijst hebben van elk schepsel in ons aquarium, samen met verschillende details over elk van hen:

aquarium_creatures = 

We willen deze gegevens filteren op een zoekstring die we aan de functie meegeven. Om filter() toegang te geven tot elk woordenboek en elk item in de woordenboeken, construeren we een geneste functie, zoals de volgende:

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)

We definiëren een filter_set() functie die aquarium_creatures en search_string als parameters neemt. In filter_set() geven we onze iterator_func() als functie door aan filter(). De functie filter_set() geeft de iterator terug die het resultaat is van filter().

De iterator_func() neemt x als argument, dat een item in onze lijst voorstelt (dat wil zeggen, een enkel woordenboek).

Volgende de for-lus benadert de waarden in elk sleutel:waarde-paar in onze woordenboeken en gebruikt dan een voorwaardelijke verklaring om te controleren of de search_string in v staat, die een waarde vertegenwoordigt.

Net als in onze vorige voorbeelden, als de expressie evalueert naar True voegt de functie het item toe aan het filterobject. Dit zal terugkeren zodra de filter_set() functie is voltooid. We plaatsen return False buiten onze lus, zodat het elk item in elk woordenboek controleert, in plaats van terug te keren na het controleren van alleen het eerste woordenboek.

We roepen filter_set() op met onze lijst van woordenboeken en de zoekstring waarvoor we overeenkomsten willen vinden:

filtered_records = filter_set(aquarium_creatures, "2") 

Als de functie is voltooid, hebben we ons filterobject opgeslagen in de filtered_records variabele, die we in een lijst veranderen en afdrukken:

print(list(filtered_records)) 

We krijgen de volgende uitvoer van dit programma:

Output

We hebben de lijst met woordenboeken gefilterd met de zoekstring 2. We kunnen zien dat de drie woordenboeken die een tanknummer met 2 bevatten, zijn geretourneerd. Door onze eigen geneste functie te gebruiken, konden we elk item openen en efficiënt controleren aan de hand van de zoekstring.

Conclusie

In deze tutorial hebben we de verschillende manieren geleerd om de filter() functie in Python te gebruiken. Nu kun je filter() gebruiken met je eigen functie, een lambda functie, of met None om te filteren op items in verschillende complexiteiten van datastructuren.

Hoewel we in deze tutorial de resultaten van filter() onmiddellijk in lijst-formaat hebben afgedrukt, is het waarschijnlijk dat we in onze programma’s het geretourneerde filter() object zouden gebruiken en de data verder zouden manipuleren.

Als u meer wilt leren over Python, bekijk dan onze How To Code in Python 3 serie en onze Python topic pagina.