Comment utiliser la fonction filtre de Python

Introduction

La fonction intégrée Python filter() peut être utilisée pour créer un nouvel itérateur à partir d’une itérable existante (comme une liste ou un dictionnaire) qui filtrera efficacement les éléments en utilisant une fonction que nous fournissons. Un itérable est un objet Python sur lequel on peut  » itérer « , c’est-à-dire qu’il retournera des éléments dans une séquence telle que nous pouvons l’utiliser dans une for boucle.

La syntaxe de base de la fonction filter() est la suivante :

filter(function, iterable)

Elle retournera un objet filtre, qui est un itérable. Nous pouvons utiliser une fonction comme list() pour faire une liste de tous les éléments retournés dans un objet filtre.

La fonction filter() fournit un moyen de filtrer les valeurs qui peut souvent être plus efficace qu’une compréhension de liste, surtout lorsque nous commençons à travailler avec des ensembles de données plus importants. Par exemple, une compréhension de liste crée une nouvelle liste, ce qui augmente le temps d’exécution de ce traitement. Cela signifie qu’après que notre compréhension de liste ait terminé son expression, nous aurons deux listes en mémoire. Cependant, filter() fera un objet simple qui contient une référence à la liste d’origine, la fonction fournie et un indice de l’endroit où aller dans la liste d’origine, ce qui occupera moins de mémoire.

Dans ce tutoriel, nous allons passer en revue quatre façons différentes d’utiliser filter() : avec deux structures itérables différentes, avec une fonction lambda, et sans fonction définie.

Utilisation de filter() avec une fonction

Le premier argument de filter() est une fonction, que nous utilisons pour décider d’inclure ou de filtrer chaque élément. La fonction est appelée une fois pour chaque élément de l’itérable passé comme deuxième argument et chaque fois qu’elle renvoie False, la valeur est abandonnée. Comme cet argument est une fonction, nous pouvons soit passer une fonction normale, soit faire appel aux fonctions lambda, notamment lorsque l’expression est moins complexe.

Voici la syntaxe d’un lambda avec filter() :

filter(lambda item: item expression, iterable)

Avec une liste, comme la suivante, nous pouvons incorporer une fonction lambda avec une expression par rapport à laquelle nous voulons évaluer chaque élément de la liste :

creature_names = 

Pour filtrer cette liste afin de trouver les noms des créatures de notre aquarium qui commencent par une voyelle, nous pouvons exécuter la fonction lambda suivante :

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

Ici, nous déclarons un élément de notre liste comme x. Ensuite, nous définissons notre expression pour accéder au premier caractère de chaque chaîne (ou caractère « zéro »), donc x. En abaissant la casse de chacun des noms, nous nous assurons que cela correspondra aux lettres de la chaîne de notre expression, 'aeiou'.

Enfin, nous passons l’itérable creature_names. Comme dans la section précédente nous appliquons list() au résultat afin de créer une liste à partir de l’itérateur filter() retourne.

La sortie sera la suivante :

Output

Ce même résultat peut être obtenu en utilisant une fonction que nous définissons :

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

Notre fonction names_vowels définit l’expression que nous allons mettre en œuvre pour filtrer creature_names.

De nouveau, le résultat serait le suivant :

Output

Dans l’ensemble, les fonctions lambda permettent d’obtenir le même résultat avec filter() que lorsque nous utilisons une fonction régulière. La nécessité de définir une fonction régulière croît au fur et à mesure que la complexité des expressions pour filtrer nos données augmente, ce qui est susceptible de favoriser une meilleure lisibilité de notre code.

Utiliser None avec filter()

Nous pouvons passer None comme premier argument à filter() pour que l’itérateur retourné filtre toute valeur que Python considère comme « faussée ». Généralement, Python considère tout ce qui a une longueur de 0 (comme une liste vide ou une chaîne vide) ou numériquement équivalent à 0 comme faux, d’où l’utilisation du terme « falsy ». »

Dans le cas suivant, nous voulons filtrer notre liste pour n’afficher que les numéros de réservoir de notre aquarium :

aquarium_tanks = , {}]

Dans ce code, nous avons une liste contenant des entiers, des séquences vides et une valeur booléenne.

filtered_tanks = filter(None, aquarium_tanks)

Nous utilisons la fonction filter() avec None et passons la liste aquarium_tanks comme notre itérable. Comme nous avons passé None comme premier argument, nous allons vérifier si les éléments de notre liste sont considérés comme faux.

print(list(filtered_tanks))

Puis nous enveloppons filtered_tanks dans une fonction list() afin qu’elle renvoie une liste pour filtered_tanks lorsque nous imprimons.

Ici, la sortie ne montre que les entiers. Tous les éléments qui ont évalué False, qui sont équivalents à 0 en longueur, ont été supprimés par filter() :

Output

Note : Si nous n’utilisons pas list() et que nous imprimons filtered_tanks, nous recevrions un objet filtre ressemblant à ceci : <filter object at 0x7fafd5903240>. L’objet filtre est un itérable, nous pourrions donc le parcourir en boucle avec for ou nous pouvons utiliser list() pour le transformer en liste, ce que nous faisons ici car c’est une bonne façon de passer en revue les résultats.

Avec None, nous avons utilisé filter() pour supprimer rapidement de notre liste les éléments considérés comme faux.

Utilisation de filter() avec une liste de dictionnaires

Lorsque nous avons une structure de données plus complexe, nous pouvons toujours utiliser filter() pour évaluer chacun des éléments. Par exemple, si nous avons une liste de dictionnaires, non seulement nous voulons itérer sur chaque élément de la liste – l’un des dictionnaires – mais nous pouvons également vouloir itérer sur chaque paire clé:valeur dans un dictionnaire afin d’évaluer toutes les données.

À titre d’exemple, disons que nous avons une liste de chaque créature de notre aquarium ainsi que différents détails sur chacune d’elles :

aquarium_creatures = 

Nous voulons filtrer ces données par une chaîne de recherche que nous donnons à la fonction. Pour que filter() accède à chaque dictionnaire et à chaque élément des dictionnaires, nous construisons une fonction imbriquée, comme la suivante :

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)

Nous définissons une fonction filter_set() qui prend aquarium_creatures et search_string comme paramètres. Dans filter_set(), nous passons notre iterator_func() comme fonction à filter(). La fonction filter_set() retournera l’itérateur résultant de filter().

La iterator_func() prend x comme argument, qui représente un élément de notre liste (c’est-à-dire un seul dictionnaire).

Puis la boucle for accède aux valeurs de chaque couple clé:valeur de nos dictionnaires, puis utilise une instruction conditionnelle pour vérifier si le search_string se trouve dans v, représentant une valeur.

Comme dans nos exemples précédents, si l’expression évalue True la fonction ajoute l’élément à l’objet filtre. Cette fonction reviendra une fois que la fonction filter_set() sera terminée. Nous positionnons return False en dehors de notre boucle afin qu’elle vérifie chaque élément de chaque dictionnaire, au lieu de retourner après avoir vérifié le premier dictionnaire seul.

Nous appelons filter_set() avec notre liste de dictionnaires et la chaîne de recherche pour laquelle nous voulons trouver des correspondances :

filtered_records = filter_set(aquarium_creatures, "2") 

Une fois la fonction terminée, nous avons notre objet filtre stocké dans la variable filtered_records, que nous transformons en liste et imprimons :

print(list(filtered_records)) 

Nous recevrons la sortie suivante de ce programme :

Output

Nous avons filtré la liste des dictionnaires avec la chaîne de recherche 2. Nous pouvons voir que les trois dictionnaires qui comprenaient un numéro de réservoir avec 2 ont été retournés. L’utilisation de notre propre fonction imbriquée nous a permis d’accéder à chaque élément et de vérifier efficacement chacun d’eux par rapport à la chaîne de recherche.

Conclusion

Dans ce tutoriel, nous avons appris les différentes façons d’utiliser la fonction filter() en Python. Vous pouvez maintenant utiliser filter() avec votre propre fonction, une fonction lambda, ou avec None pour filtrer les éléments dans des structures de données de complexité variable.

Bien que dans ce tutoriel, nous ayons immédiatement imprimé les résultats de filter() sous forme de liste, il est probable que dans nos programmes, nous utilisions l’objet filter() renvoyé et manipulions davantage les données.

Si vous souhaitez en savoir plus sur Python, consultez notre série How To Code in Python 3 et notre page thématique sur Python.

La page d’accueil de Python est en anglais.