Extraire les valeurs des itérables – Real Python

By | juin 9, 2021

Python pas cher

Python filtre() est une fonction intégrée qui vous permet de traiter un itérable et d'extraire les éléments qui satisfont à une condition donnée. Ce processus est communément appelé filtration opération. Avec filtre(), vous pouvez appliquer un fonction de filtrage à un itérable et produire un nouvel itérable avec les éléments qui satisfont à la condition à portée de main. En Python, filtre() est l'un des outils que vous pouvez utiliser pour la programmation fonctionnelle.

Dans ce didacticiel, vous apprendrez à :

  • Utiliser Python filtre() dans ton code
  • Extrait valeurs nécessaires à partir de vos itérables
  • Combiner filtre() avec d'autre outils fonctionnels
  • Remplacer filtre() avec plus Pythonique outils

Avec ces connaissances, vous serez en mesure d'utiliser filtre() efficacement dans votre code. Alternativement, vous avez le choix d'utiliser des compréhensions de liste ou des expressions génératrices pour écrire plus de code Pythonic et lisible.

Pour mieux comprendre filtre(), il serait utile que vous ayez des connaissances préalables sur les itérables, pour boucles, fonctions et lambda les fonctions.

Codage avec style fonctionnel en Python

Programmation fonctionnelle est un paradigme qui encourage l'utilisation de fonctions pour effectuer presque toutes les tâches d'un programme. Un style purement fonctionnel repose sur des fonctions qui ne modifient pas leurs arguments d'entrée et ne changent pas l'état du programme. Ils prennent juste un ensemble spécifique d'arguments et renvoient le même résultat à chaque fois. Ces types de fonctions sont appelés fonctions pures.

Dans la programmation fonctionnelle, les fonctions opèrent souvent sur des tableaux de données, les transforment et produisent de nouveaux tableaux avec des fonctionnalités supplémentaires. Il y a trois opérations fondamentales dans la programmation fonctionnelle :

  1. Le mappage applique une fonction de transformation à un itérable et produit un nouvel itérable d'éléments transformés.
  2. Le filtrage applique un prédicat, ou une fonction à valeur booléenne, à un itérable et génère un nouvel itérable contenant les éléments qui satisfont à la condition booléenne.
  3. La réduction applique une fonction de réduction à un itérable et renvoie une seule valeur cumulée.

Python n'est pas fortement influencé par les langages fonctionnels mais par les langages impératifs. Cependant, il fournit plusieurs fonctionnalités qui vous permettent d'utiliser un style fonctionnel :

Les fonctions en Python sont des objets de première classe, ce qui signifie que vous pouvez les transmettre comme vous le feriez avec n'importe quel autre objet. Vous pouvez également les utiliser comme arguments et valeurs de retour d'autres fonctions. Les fonctions qui acceptent d'autres fonctions comme arguments ou qui renvoient des fonctions (ou les deux) sont appelées fonctions d'ordre supérieur, qui sont également une caractéristique souhaitable dans la programmation fonctionnelle.

Dans ce didacticiel, vous découvrirez filtre(). Cette fonction intégrée est l'un des outils fonctionnels les plus populaires de Python.

Comprendre le problème de filtrage

Supposons que vous deviez traiter une liste de nombres et renvoyer une nouvelle liste contenant uniquement les nombres supérieurs à 0. Une façon rapide d'aborder ce problème est d'utiliser un pour boucle comme ceci :

>>>

>>> Nombres = [[[[-2, -1, 0, 1, 2]

>>> déf extrait_positif(Nombres):
...     nombres_positifs = []
...     pour numéro dans Nombres:
...         si numéro > 0:  # Condition de filtrage
...             nombres_positifs.ajouter(numéro)
...     revenir nombres_positifs
...

>>> extrait_positif(Nombres)
[1, 2]

La boucle en extrait_positif() itère à travers Nombres et stocke chaque nombre supérieur à 0 dans nombres_positifs. L'énoncé conditionnel filtre les nombres négatifs et 0. Ce type de fonctionnalité est connu sous le nom de filtration.

Les opérations de filtrage consistent à tester chaque valeur dans un itérable avec une fonction de prédicat et à ne retenir que les valeurs pour lesquelles la fonction produit un vrai résultat. Les opérations de filtrage sont assez courantes en programmation, la plupart des langages de programmation fournissent donc des outils pour les aborder. Dans la section suivante, vous découvrirez la façon dont Python filtre les itérables.

Premiers pas avec Python filtre()

Python fournit une fonction intégrée pratique, filtre(), qui fait abstraction de la logique derrière les opérations de filtrage. Voici sa signature :

filtre(une fonction, itérable)

Le premier argument, une fonction, doit être une fonction à argument unique. En règle générale, vous fournissez une fonction de prédicat (valeur booléenne) à cet argument. En d'autres termes, vous fournissez une fonction qui renvoie soit Vrai ou alors Faux selon une condition précise.

Cette une fonction joue le rôle d'un fonction de décision, également connu sous le nom de fonction de filtrage, car il fournit les critères permettant de filtrer les valeurs indésirables de l'itérable d'entrée et de conserver les valeurs souhaitées dans l'itérable résultant. A noter que le terme valeurs indésirables fait référence aux valeurs évaluées à faux lorsque filtre() les traite en utilisant une fonction.

Le deuxième argument, itérable, peut contenir n'importe quel itérable Python, tel qu'une liste, un tuple ou un ensemble. Il peut également contenir des objets générateurs et itérateurs. Un point important concernant filtre() c'est qu'il n'en accepte qu'un itérable.

Pour effectuer le processus de filtrage, filtre() s'applique une fonction à chaque élément de itérable en boucle. Le résultat est un itérateur qui donne les valeurs de itérable Pour qui une fonction renvoie une valeur vraie. Le processus ne modifie pas l'itérable d'entrée d'origine.

Depuis filtre() est écrit en C et est hautement optimisé, sa boucle implicite interne peut être plus efficace qu'un pour boucle concernant le temps d'exécution. Cette efficacité est sans doute l'avantage le plus important de l'utilisation de la fonction en Python.

Un deuxième avantage d'utiliser filtre() sur une boucle est qu'il renvoie un filtre object, qui est un itérateur qui produit des valeurs à la demande, favorisant une stratégie d'évaluation paresseuse. Le retour d'un itérateur fait filtre() plus efficace en mémoire qu'un équivalent pour boucle.

Dans votre exemple sur les nombres positifs, vous pouvez utiliser filtre() avec une fonction de prédicat pratique pour extraire les nombres souhaités. Pour coder le prédicat, vous pouvez utiliser soit un lambda ou une fonction définie par l'utilisateur :

>>>

>>> Nombres = [[[[-2, -1, 0, 1, 2]

>>> # Utilisation d'une fonction lambda
>>> nombres_positifs = filtre(lambda m: m > 0, Nombres)
>>> nombres_positifs

>>> liste(nombres_positifs)
[1, 2]

>>> # Utilisation d'une fonction définie par l'utilisateur
>>> déf est_positif(m):
...     revenir m > 0
...
>>> liste(filtre(est_positif, Nombres))
[1, 2]

Dans le premier exemple, vous utilisez un lambda fonction qui fournit la fonctionnalité de filtrage. L'appel à filtre() applique que lambda fonction à chaque valeur dans Nombres et filtre les nombres négatifs et 0. Depuis filtre() renvoie un itérateur, vous devez appeler liste() pour consommer l'itérateur et créer la liste finale.

Dans le deuxième exemple, vous écrivez est_positif() prendre un nombre comme argument et retourner Vrai si le nombre est supérieur à 0. Sinon, ça revient Faux. L'appel à filtre() s'applique est_positif() à chaque valeur dans Nombres, en filtrant les nombres négatifs. Cette solution est bien plus lisible que sa lambda équivalent.

En pratique, filtre() n'est pas limité aux fonctions booléennes telles que celles des exemples ci-dessus. Vous pouvez utiliser d'autres types de fonctions et filtre() évaluera leur valeur de retour pour la véracité :

>>>

>>> déf identité(X):
...     revenir X
...

>>> identité(42)
42

>>> objets = [[[[0, 1, [], 4, 5, "", Rien, 8]
>>> liste(filtre(identité, objets))
[1, 4, 5, 8]

Dans cet exemple, la fonction de filtrage, identité(), ne revient pas Vrai ou alors Faux explicitement, mais le même argument qu'il prend. Depuis 0, [], "", et Rien sont faux, filtre() utilise leur valeur de vérité pour les filtrer. La liste finale ne contient que les valeurs qui sont vraies en Python.

Enfin, si vous passez Rien à une fonction, ensuite filtre() utilise le fonction d'identité et donne tous les éléments de itérable qui évaluent à Vrai:

>>>

>>> objets = [[[[0, 1, [], 4, 5, "", Rien, 8]

>>> liste(filtre(Rien, objets))
[1, 4, 5, 8]

Dans ce cas, filtre() teste chaque élément de l'itérable d'entrée à l'aide des règles Python que vous avez vues auparavant. Ensuite, il donne les éléments qui évaluent à Vrai.

Jusqu'à présent, vous avez appris les bases de filtre() et comment ça marche. Dans les sections suivantes, vous apprendrez à utiliser filtre() pour traiter les itérables et jeter les valeurs indésirables sans boucle.

Filtrage des itérables avec filtre()

Le travail de filtre() consiste à appliquer une fonction de décision à chaque valeur d'un itérable d'entrée et à renvoyer un nouvel itérable avec les éléments qui réussissent le test. Les sections suivantes fournissent des exemples pratiques afin que vous puissiez vous familiariser avec filtre().

Trouver des nombres premiers

Un autre exemple intéressant pourrait être d'extraire tous les nombres premiers dans un intervalle donné. Pour ce faire, vous pouvez commencer par coder une fonction de prédicat qui prend un entier comme argument et renvoie Vrai si le nombre est premier et Faux autrement. Voici comment procéder :

>>>

>>> importer math

>>> déf is_prime(m):
...     si m <= 1:
...         revenir Faux
...     pour je dans intervalle(2, entier(math.carré(m)) + 1):
...         si m % je == 0:
...             revenir Faux
...     revenir Vrai
...

>>> is_prime(5)
Vrai
>>> is_prime(12)
Faux

La logique de filtrage est maintenant en is_prime(). La fonction itère sur les entiers compris entre 2 et la racine carrée de m. À l'intérieur de la boucle, l'instruction conditionnelle vérifie si le nombre actuel est divisible par un autre dans l'intervalle. Si c'est le cas, la fonction renvoie Faux car le nombre n'est pas premier. Sinon, ça revient Vrai pour signaler que le nombre d'entrée est premier.

Avec is_prime() en place et testé, vous pouvez utiliser filtre() pour extraire les nombres premiers d'un intervalle comme celui-ci :

>>>

>>> liste(filtre(is_prime, intervalle(1, 51)))
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]

Cet appel à filtre() extrait tous les nombres premiers compris entre 1 et 50. L'algorithme utilisé dans is_prime() vient de l'article de Wikipedia sur les tests de primalité. Vous pouvez consulter cet article si vous avez besoin d'approches plus efficaces.

Suppression des valeurs aberrantes dans un échantillon

Lorsque vous essayez de décrire et de résumer un échantillon de données, vous commencez probablement par trouver sa moyenne. La moyenne est une mesure de tendance centrale très populaire et constitue souvent la première approche pour analyser un ensemble de données. Cela vous donne une idée rapide du centre, ou emplacement, des données.

Dans certains cas, la moyenne n'est pas une mesure de tendance centrale assez bonne pour un échantillon donné. Les valeurs aberrantes sont l'un des éléments qui affectent la précision de la moyenne. Les valeurs aberrantes sont des points de données qui diffèrent considérablement des autres observations dans un échantillon ou une population. En dehors de cela, il n'y a pas de définition mathématique unique pour eux dans les statistiques.

Cependant, dans les échantillons normalement distribués, les valeurs aberrantes sont souvent définies comme des points de données situés à plus de deux écarts types par rapport à la moyenne de l'échantillon.

Supposons maintenant que vous ayez un échantillon normalement distribué avec des valeurs aberrantes qui affectent la précision moyenne. Vous avez étudié les valeurs aberrantes et vous savez qu'il s'agit de points de données incorrects. Voici comment vous pouvez utiliser quelques fonctions du statistiques module avec filtre() pour nettoyer vos données :

>>>

>>> importer statistiques comme st
>>> goûter = [[[[dix, 8, dix, 8, 2, 7, 9, 3, 34, 9, 5, 9, 25]

>>> # La moyenne avant de supprimer les valeurs aberrantes
>>> st.moyenne(goûter)
10.692307692307692

>>> stdev = st.stdev(goûter)
>>> nettoyer_échantillon = liste(filtre(lambda X: X <= 2 * stdev, goûter))
>>> nettoyer_échantillon
[10, 8, 10, 8, 2, 7, 9, 3, 9, 5, 9]

>>> # La moyenne après suppression des valeurs aberrantes
>>> st.moyenne(nettoyer_échantillon)
7.2727272727272725

Dans la ligne en surbrillance, le lambda la fonction renvoie Vrai si un point de données donné est inférieur ou égal à deux écarts types et Faux autrement. Lorsque vous filtrez le goûter avec cette fonction, 34 et 25 sont exclus. Après ce nettoyage, la moyenne de l'échantillon a une valeur significativement différente.

Validation des identifiants Python

Vous pouvez aussi utiliser filtre() avec des itérables contenant des données non numériques. Par exemple, supposons que vous deviez traiter une liste de chaînes et extraire celles qui sont des identifiants Python valides. Après avoir fait quelques recherches, vous découvrez que Python str propose une méthode appelée .isidentifier() cela peut vous aider avec cette validation.

Voici comment vous pouvez utiliser filtre() de même que str.isidentifier() pour valider rapidement les identifiants :

>>>

>>> mots = [[[["variable", "déposer#", "entête", "_non_public", "123Classe"]

>>> liste(filtre(str.isidentifier, mots))
['variable', 'header', '_non_public']

Dans ce cas, filtre() s'exécute .isidentifier() sur chaque chaîne de mots. Si la chaîne est un identifiant Python valide, alors il est inclus dans le résultat final. Sinon, le mot est filtré. Notez que vous devez utiliser str accéder .isidentifier() dans l'appel à filtre().

Enfin, un exercice intéressant pourrait être de pousser l'exemple plus loin et de vérifier si l'identifiant est aussi un mot-clé. Vas-y, essaies! Astuce : vous pouvez utiliser .kwlist du mot-clé module.

Trouver des mots palindromes

Un exercice qui se pose souvent lorsque vous vous familiarisez avec les chaînes Python consiste à trouver des mots palindromes dans une liste de chaînes. Un mot palindrome se lit de la même manière en arrière qu'en avant. Des exemples typiques sont « madame » et « voiture de course ».

Pour résoudre ce problème, vous commencerez par coder une fonction de prédicat qui prend une chaîne et vérifie si elle lit la même chose dans les deux sens, en arrière et en avant. Voici une implémentation possible :

>>>

>>> déf is_palindrome(mot):
...     mot_inversé = "".rejoindre(renversé(mot))
...     revenir mot.plus bas() == mot_inversé.plus bas()
...

>>> is_palindrome("Voiture de course")
Vrai
>>> is_palindrome("Python")
Faux

Dans is_palindrome(), vous inversez d'abord l'original mot et rangez-le dans mot_inversé. Ensuite, vous retournez le résultat de la comparaison des deux mots pour l'égalité. Dans ce cas, vous utilisez .plus bas() pour éviter les différences liées au cas. Si vous appelez la fonction avec un mot palindrome, vous obtenez Vrai. Sinon, vous obtenez Faux.

Vous disposez déjà d'une fonction de prédicat fonctionnelle pour identifier les mots palindromes. Voici comment vous pouvez utiliser filtre() pour faire le gros du travail :

>>>

>>> mots = ("filtre", "Ana", "Bonjour", "monde", "Madame", "voiture de course")

>>> liste(filtre(is_palindrome, mots))
['Ana', 'madam', 'racecar']

Frais! Votre combinaison de filtre() et is_palindrome() fonctionne correctement. Il est également concis, lisible et efficace. Bon travail!

Combinant filtre() Avec d'autres outils fonctionnels

Jusqu'à présent, vous avez appris à utiliser filtre() pour exécuter différentes opérations de filtrage sur les itérables. En pratique, vous pouvez combiner filtre() avec d'autres outils fonctionnels pour effectuer de nombreuses tâches différentes sur les itérables sans utiliser de boucles explicites. Dans les deux sections suivantes, vous apprendrez les bases de l'utilisation filtre() de même que carte() et réduire().

Le carré des nombres pairs : filtre() et carte()

Parfois, vous devez prendre un itérable, traiter chacun de ses éléments avec un fonction de transformation, et produire un nouvel itérable avec les éléments résultants. Dans ce cas, vous pouvez utiliser carte(). La fonction a la signature suivante :

carte(une fonction, itérable[[[[ itérable1, ..., itérableN])

Les arguments fonctionnent comme ceci :

  1. une fonction détient la fonction de transformation. Cette fonction doit prendre autant d'arguments que d'itérables que vous passez dans carte().
  2. itérable détient un itérable Python. Notez que vous pouvez fournir plusieurs itérables à carte(), mais c'est facultatif.

carte() s'applique une fonction à chaque élément de itérable pour le transformer en une valeur différente avec des fonctionnalités supplémentaires. Puis carte() produit chaque élément transformé à la demande.

Pour illustrer comment vous pouvez utiliser filtre() de même que carte(), disons que vous devez calculer la valeur au carré de tous les nombres pairs d'une liste donnée. Dans ce cas, vous pouvez utiliser filtre() pour extraire les nombres pairs puis carte() pour calculer les valeurs carrées :

>>>

>>> Nombres = [[[[1, 3, dix, 45, 6, 50]

>>> déf est même(numéro):
...     revenir numéro % 2 == 0
...

>>> nombres pairs = liste(filtre(est même, Nombres))
>>> nombres pairs
[10, 6, 50]

>>> liste(carte(lambda m: m ** 2, nombres pairs))
[100, 36, 2500]

>>> liste(carte(lambda m: m ** 2, filtre(est même, Nombres)))
[100, 36, 2500]

Tout d'abord, vous obtenez les nombres pairs en utilisant filtre() et est même() comme vous l'avez fait jusqu'à présent. Puis tu appelles carte() avec un lambda fonction qui prend un nombre et renvoie sa valeur carrée. L'appel à carte() applique le lambda fonction à chaque nombre dans nombres pairs, vous obtenez donc une liste de nombres pairs carrés. Le dernier exemple montre comment combiner filtre() et carte() en une seule expression.

La somme des nombres pairs : filtre() et réduire()

Un autre outil de programmation fonctionnel en Python est réduire(). contrairement à filtre() et carte(), qui sont toujours des fonctions intégrées, réduire() a été déplacé vers le outils fonctionnels module. Cette fonction est utile lorsque vous devez appliquer une fonction à un itérable et le réduire à une seule valeur cumulée. Ce type d'opération est communément appelé réduction ou pliage.

La signature de réduire() est comme ça:

réduire(une fonction, itérable, initiale)

Voici ce que signifient les arguments :

  1. une fonction contient tout appelable Python qui accepte deux arguments et renvoie une seule valeur.
  2. itérable contient n'importe quel itérable Python.
  3. initiale contient une valeur qui sert de point de départ pour le premier calcul partiel ou la première réduction. C'est un argument optionnel.

Un appel à réduire() commence par postuler une fonction aux deux premiers éléments de itérable. De cette façon, il calcule le premier résultat cumulé, appelé un accumulateur. Puis réduire() utilise l'accumulateur et le deuxième élément dans itérable pour calculer le prochain résultat cumulé. Le processus se poursuit jusqu'à ce que la fonction retourne avec une seule valeur.

Si vous fournissez une valeur à initiale, ensuite réduire() exécute le premier calcul partiel en utilisant initiale et le premier élément de itérable.

Voici un exemple qui combine filtre() et réduire() pour calculer cumulativement la somme totale de tous les nombres pairs d'une liste :

>>>

>>> de outils fonctionnels importer réduire
>>> Nombres = [[[[1, 3, dix, 45, 6, 50]

>>> déf est même(numéro):
...     revenir numéro % 2 == 0
...

>>> nombres pairs = liste(filtre(est même, Nombres))
>>> réduire(lambda une, b: une + b, nombres pairs)
66

>>> réduire(lambda une, b: une + b, filtre(est même, Nombres))
66

Ici, le premier appel à réduire() calcule la somme de tous les nombres pairs qui filtre() fournit. Pour faire ça, réduire() utilise un lambda fonction qui ajoute deux nombres à la fois.

Le dernier exemple montre comment enchaîner filtre() et réduire() pour produire le même résultat que vous avez obtenu avant.

Filtrage des itérables avec filtrefaux()

Dans itertools, vous trouverez une fonction appelée filtrefaux() qui fait l'inverse de filtre(). Il prend un itérable comme argument et renvoie un nouvel itérateur qui renvoie les éléments pour lesquels la fonction de décision renvoie un résultat faux. Si tu utilises Rien comme premier argument de filtrefaux(), alors vous obtenez les éléments qui sont faux.

Le point d'avoir le filtrefaux() fonction est de promouvoir réutilisation du code. Si vous avez déjà mis en place une fonction de décision, vous pouvez l'utiliser avec filtrefaux() pour récupérer les articles refusés. Cela vous évite de coder une fonction de décision inverse.

Dans les sections suivantes, vous allez coder quelques exemples qui montrent comment vous pouvez tirer parti de filtrefaux() pour réutiliser les fonctions de décision existantes et continuer à filtrer.

Filtrage des valeurs NaN

Parfois, lorsque vous travaillez avec l'arithmétique à virgule flottante, vous pouvez être confronté au problème d'avoir des valeurs NaN (pas un nombre). Par exemple, supposons que vous calculiez la moyenne d'un échantillon de données contenant des valeurs NaN. Si vous utilisez Python statistiques module pour ce calcul, alors vous obtenez le résultat suivant :

>>>

>>> importer statistiques comme st

>>> goûter = [[[[10.1, 8.3, 10.4, 8.8, flotter("nan"), 7.2, flotter("nan")]
>>> st.moyenne(goûter)
nan

Dans cet exemple, l'appel à moyenne() Retour nan, ce qui n'est pas la valeur la plus informative que vous puissiez obtenir. Les valeurs NaN peuvent avoir différentes origines. Ils peuvent être dus à des entrées non valides, à des données corrompues, etc. Vous devriez trouver la bonne stratégie pour les traiter dans vos applications. Une alternative pourrait être de les supprimer de vos données.

le math module fournit une fonction pratique appelée isnan() cela peut vous aider avec ce problème. La fonction prend un nombre X comme argument et renvoie Vrai si X est un NaN et Faux autrement. Vous pouvez utiliser cette fonction pour fournir les critères de filtrage dans un filtrefaux() appel:

>>>

>>> importer math
>>> importer statistiques comme st
>>> de itertools importer filtrefaux

>>> goûter = [[[[10.1, 8.3, 10.4, 8.8, flotter("nan"), 7.2, flotter("nan")]

>>> st.moyenne(filtrefaux(math.isnan, goûter))
8,96

Utilisant math.isnan() de même que filtrefaux() vous permet d'exclure toutes les valeurs NaN du calcul de la moyenne. Notez qu'après le filtrage, l'appel à moyenne() renvoie une valeur qui fournit une meilleure description de vos exemples de données.

Codage avec style pythonique

Bien que carte(), filtre(), et réduire() existent depuis longtemps dans l'écosystème Python, liste de compréhensions et expressions de générateur sont devenus des concurrents puissants et pythoniques dans presque tous les cas d'utilisation.

La fonctionnalité fournie par ces fonctions est presque toujours exprimée de manière plus explicite à l'aide d'une expression génératrice ou d'une compréhension de liste. Dans les deux sections suivantes, vous apprendrez comment remplacer un appel à filtre() avec une compréhension de liste ou une expression génératrice. Ce remplacement rendra votre code plus Pythonic.

Remplacement filtre() Avec une compréhension de liste

Vous pouvez utiliser le modèle suivant pour remplacer rapidement un appel à filtre() avec une compréhension de liste équivalente :

# Génération d'une liste avec filter()
liste(filtre(une fonction, itérable))

# Générer une liste avec une compréhension de liste
[[[[Objet pour Objet dans itérable si une fonction(Objet)]

Dans les deux cas, le but final est de créer un objet liste. L'approche de compréhension de liste est plus explicite que son équivalent filtre() construction. Une lecture rapide de la compréhension révèle l'itération ainsi que la fonctionnalité de filtrage dans le si clause.

Utiliser des compréhensions de liste au lieu de filtre() est probablement le chemin emprunté par la plupart des développeurs Python de nos jours. Cependant, les compréhensions de liste présentent certains inconvénients par rapport à filtre(). Le plus notable est le manque d'évaluation paresseuse. De plus, lorsque les développeurs commencent à lire du code qui utilise filtre(), ils savent immédiatement que le code effectue des opérations de filtrage. Cependant, ce n'est pas si évident dans le code qui utilise des compréhensions de liste avec le même objectif.

Un détail à remarquer lors d'un virage filtre() construire dans une liste de compréhension est que si vous passez Rien au premier argument de filtre(), alors la compréhension de liste équivalente ressemble à ceci :

# Génération d'une liste avec filter() et None
liste(filtre(Rien, itérable))

# Compréhension de liste équivalente
[[[[Objet pour Objet dans itérable si Objet]

Dans ce cas, le si clause dans les tests de compréhension de liste Objet pour sa valeur de vérité. Ce test suit les règles Python standard concernant les valeurs de vérité que vous avez déjà vues.

Voici un exemple de remplacement filtre() avec une compréhension de liste pour construire une liste de nombres pairs :

>>>

>>> Nombres = [[[[1, 3, dix, 45, 6, 50]

>>> # Fonction de filtrage
>>> déf est même(X):
...     revenir X % 2 == 0
...

>>> # Utiliser le filtre()
>>> liste(filtre(est même, Nombres))
[10, 6, 50]

>>> # Utiliser une compréhension de liste
>>> [[[[numéro pour numéro dans Nombres si est même(numéro)]
[10, 6, 50]

Dans cet exemple, vous pouvez voir que la variante de compréhension de liste est plus explicite. Il se lit presque comme un anglais simple. La solution de compréhension de liste évite également d'avoir à appeler liste() pour construire la liste finale.

Remplacement filtre() Avec une expression de générateur

Le remplaçant naturel de filtre() est un expression du générateur. C'est parce que filtre() renvoie un itérateur qui produit des éléments à la demande, tout comme le fait une expression de générateur. Les itérateurs Python sont connus pour être efficaces en mémoire. Voilà pourquoi filtre() renvoie désormais un itérateur au lieu d'une liste.

Voici comment vous pouvez utiliser des expressions génératrices pour écrire l'exemple dans la section ci-dessus :

>>>

>>> Nombres = [[[[1, 3, dix, 45, 6, 50]

>>> # Fonction de filtrage
>>> déf est même(X):
...     revenir X % 2 == 0
...

>>> # Utiliser le filtre()
>>> nombres pairs = filtre(est même, Nombres)
>>> nombres pairs

>>> liste(nombres pairs)
[10, 6, 50]

>>> # Utiliser une expression génératrice
>>> nombres pairs = (numéro pour numéro dans Nombres si est même(numéro))
>>> nombres pairs
<objet générateur  à 0x7f586ade04a0>
>>> liste(nombres pairs)
[10, 6, 50]

Une expression génératrice est aussi efficace qu'un appel à filtre() en termes de consommation de mémoire. Les deux outils renvoient des itérateurs qui produisent des éléments à la demande. Utiliser l'un ou l'autre peut être une question de goût, de commodité ou de style. Alors, c'est vous qui décidez !

Conclusion

Python filtre() permet d'effectuer filtration opérations sur les itérables. Ce type d'opération consiste à appliquer une Fonction booléenne aux éléments d'un itérable et en ne conservant que les valeurs pour lesquelles la fonction renvoie un résultat vrai. En général, vous pouvez utiliser filtre() pour traiter les itérables existants et produire de nouveaux itérables contenant les valeurs dont vous avez actuellement besoin.

Dans ce tutoriel, vous avez appris à :

  • Travailler avec Python filtre()
  • Utiliser filtre() à traiter les itérables et gardez les valeurs dont vous avez besoin
  • Combiner filtre() avec carte() et réduire() aborder différents problèmes
  • Remplacer filtre() avec liste de compréhensions et expressions de générateur

Avec ces nouvelles connaissances, vous pouvez maintenant utiliser filtre() dans votre code pour lui donner un style fonctionnel. Vous pouvez également passer à un style plus Pythonic et remplacer filtre() avec des compréhensions de liste ou des expressions génératrices.