1. A propos de la fonction filter()
La fonction filter() est une fonction built-in de Python qui permet de filtrer les éléments d'un itérable (liste, tuple, etc.) en fonction d'une condition définie par une fonction. Elle retourne un objet filter (un itérateur) contenant uniquement les éléments pour lesquels la fonction de filtrage renvoie True. Cette fonction est très utile pour effectuer des opérations de filtrage de manière concise et lisible.
2. Syntaxe et paramètres de base
La syntaxe de la fonction filter() est : filter(fonction, iterable). Le premier paramètre est la fonction de filtrage (peut être None, une fonction nommée, une lambda, etc.) et le second est l'itérable à filtrer.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
# Syntaxe de base de filter() nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # Définition d'une fonction de filtrage def est_pair(n): return n % 2 == 0 # Application de filter() resultat = filter(est_pair, nombres) # Conversion en liste pour affichage liste_resultat = list(resultat) print("Nombres pairs :", liste_resultat) |
Sortie :
|
1 |
Nombres pairs : [2, 4, 6, 8, 10] |
3. Utilisation avec différentes fonctions de filtrage
3.1 Avec une fonction lambda
On peut utiliser une fonction lambda pour définir la condition de filtrage de manière concise, sans avoir à déclarer une fonction séparée.
|
1 2 3 4 5 6 7 8 9 10 |
# Filtrage avec une fonction lambda nombres = [15, 28, 33, 42, 50, 61] # Filtrer les nombres supérieurs à 30 filtre_superieur_30 = filter(lambda x: x > 30, nombres) print("Nombres > 30 :", list(filtre_superieur_30)) # Filtrer les nombres pairs filtre_pairs = filter(lambda x: x % 2 == 0, nombres) print("Nombres pairs :", list(filtre_pairs)) |
Sortie :
|
1 2 |
Nombres > 30 : [33, 42, 50, 61] Nombres pairs : [28, 42, 50] |
3.2 Avec None comme fonction
Lorsqu'on passe None comme fonction, filter() conserve uniquement les éléments qui sont évalués à True (éléments truthy). Cela permet de supprimer facilement les valeurs "fausses" comme 0, None, '', [], etc.
|
1 2 3 4 5 6 |
# Filtrage avec None pour supprimer les valeurs "fausses" valeurs_mixtes = [0, 1, '', 'hello', None, [], [1, 2], False, True] # Filtrer les éléments truthy resultat = filter(None, valeurs_mixtes) print("Éléments truthy :", list(resultat)) |
Sortie :
|
1 |
Éléments truthy : [1, 'hello', [1, 2], True] |
4. Exemples pratiques avancés
4.1 Filtrage de chaînes de caractères
On peut filtrer des chaînes de caractères selon différentes conditions, comme la présence d'une sous-chaîne, la longueur, ou d'autres critères.
|
1 2 3 4 5 6 7 8 9 10 |
# Filtrage de chaînes de caractères mots = ['python', 'java', 'javascript', 'c++', 'php', 'html', 'css'] # Filtrer les mots contenant 'java' contient_java = filter(lambda mot: 'java' in mot, mots) print("Mots avec 'java' :", list(contient_java)) # Filtrer les mots de plus de 4 caractères longueur_sup_4 = filter(lambda mot: len(mot) > 4, mots) print("Mots de plus de 4 caractères :", list(longueur_sup_4)) |
Sortie :
|
1 2 |
Mots avec 'java' : ['java', 'javascript'] Mots de plus de 4 caractères : ['python', 'javascript'] |
4.2 Filtrage d'objets complexes
filter() fonctionne également avec des structures de données complexes, comme des listes de dictionnaires ou d'objets.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
# Filtrage d'une liste de dictionnaires etudiants = [ {'nom': 'Alice', 'note': 15}, {'nom': 'Bob', 'note': 10}, {'nom': 'Charlie', 'note': 18}, {'nom': 'Diana', 'note': 12}, {'nom': 'Eve', 'note': 8} ] # Filtrer les étudiants avec une note >= 12 etudiants_admis = filter(lambda etud: etud['note'] >= 12, etudiants) print("Étudiants admis (note >= 12) :", list(etudiants_admis)) # Filtrer les étudiants dont le nom contient 'a' noms_avec_a = filter(lambda etud: 'a' in etud['nom'].lower(), etudiants) print("Étudiants avec 'a' dans le nom :", list(noms_avec_a)) |
Sortie :
|
1 2 |
Étudiants admis (note >= 12) : [{'nom': 'Alice', 'note': 15}, {'nom': 'Charlie', 'note': 18}, {'nom': 'Diana', 'note': 12}] Étudiants avec 'a' dans le nom : [{'nom': 'Alice', 'note': 15}, {'nom': 'Charlie', 'note': 18}, {'nom': 'Diana', 'note': 12}] |
5. Comparaison avec les compréhensions de liste
Le filtrage peut également être réalisé avec des compréhensions de liste. Voici une comparaison entre les deux approches pour comprendre quand utiliser l'une ou l'autre.
|
1 2 3 4 5 6 7 8 9 10 11 |
nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # Avec filter() et lambda pairs_filter = list(filter(lambda x: x % 2 == 0, nombres)) # Avec une compréhension de liste pairs_comprehension = [x for x in nombres if x % 2 == 0] print("Avec filter() :", pairs_filter) print("Avec compréhension de liste :", pairs_comprehension) print("Les deux méthodes donnent-elles le même résultat ?", pairs_filter == pairs_comprehension) |
Sortie :
|
1 2 3 |
Avec filter() : [2, 4, 6, 8, 10] Avec compréhension de liste : [2, 4, 6, 8, 10] Les deux méthodes donnent-elles le même résultat ? True |
Note : Les compréhensions de liste sont souvent préférées pour leur lisibilité, mais filter() peut être plus performant avec des fonctions de filtrage pré-définies et est utile dans un contexte de programmation fonctionnelle.
6. Bonnes pratiques et pièges à éviter
Lors de l'utilisation de filter(), il faut toujours garder à l'esprit quelques points clés pour éviter les erreurs courantes.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
# Piège : filter() retourne un itérateur, pas une liste nombres = [1, 2, 3, 4] resultat_iterateur = filter(lambda x: x > 2, nombres) print("Type de l'objet retourné :", type(resultat_iterateur)) print("Première conversion en liste :", list(resultat_iterateur)) print("Seconde conversion en liste (itérateur épuisé) :", list(resultat_iterateur)) # Bonne pratique : si besoin de réutiliser le résultat, convertissez-le immédiatement en liste resultat_liste = list(filter(lambda x: x > 2, nombres)) print("Résultat converti en liste :", resultat_liste) print("Réutilisation possible :", resultat_liste) |
Sortie :
|
1 2 3 4 5 |
Type de l'objet retourné : <class 'filter'> Première conversion en liste : [3, 4] Seconde conversion en liste (itérateur épuisé) : [] Résultat converti en liste : [3, 4] Réutilisation possible : [3, 4] |
Remarque
N'oubliez pas que filter() retourne un itérateur qui ne peut être parcouru qu'une seule fois. Si vous avez besoin de réutiliser le résultat plusieurs fois, convertissez-le immédiatement en liste ou en tuple.
