Filtre Python()

filter() intégré de Python La fonction est utilisée pour filtrer les éléments qui passent une condition de filtrage. Il prend deux arguments :function et iterable . Le function attribue une valeur booléenne à chaque élément du iterable pour vérifier si l'élément passera ou non le filtre. Il renvoie un itérateur avec les éléments qui passent la condition de filtrage.

Le filter() méthode a la syntaxe suivante :

filter(function, iterable)

Plongeons-nous dans quelques exemples du filter() fonction :

Exemples d'utilisation :filter() une liste Python

Le filter(function, iterable) function prend une fonction en entrée qui prend en argument (un élément de liste) et renvoie une valeur booléenne indiquant si cet élément de liste doit passer le filtre. Tous les éléments qui passent le filtre sont renvoyés sous la forme d'un nouveau iterable objet (un objet filtre).

Vous pouvez utiliser le lambda instruction de fonction pour créer la fonction là où vous la transmettez comme argument. La syntaxe de la fonction lambda est lambda x:expression et cela signifie que vous utilisez x comme argument d'entrée et que vous renvoyez l'expression comme résultat (qui peut ou ne peut pas utiliser x pour décider de la valeur de retour). Pour plus d'informations, consultez mon article de blog détaillé sur la fonction lambda.

lst = [8, 2, 6, 4, 3, 1]

# Filter all elements <8
small = filter(lambda x: x<8, lst)
print(list(small))


# Filter all even elements
even = filter(lambda x: x%2==0, lst)
print(list(even))

# Filter all odd elements
odd = filter(lambda x: x%2, lst)
print(list(odd))

La sortie est :

# Elements <8
[2, 6, 4, 3, 1]

# Even Elements
[8, 2, 6, 4]

# Odd Elements
[3, 1]

Le filter() la fonction renvoie un objet filtre qui est un iterable . Pour le convertir en liste, vous utilisez le list(...) constructeur.

Article connexe :

• Comment filtrer à l'aide de la fonction lambda

Vidéo :Comment filtrer une liste en Python ?

Comment pouvez-vous filtrer une liste en Python en utilisant une condition arbitraire ? La vidéo suivante vous guidera à travers les différentes options :

Alternative :filtrer avec la compréhension de liste

La façon la plus Pythonic de filtrer une liste - à mon avis - est la déclaration de compréhension de liste [x for x in list if condition] . Vous pouvez remplacer condition par n'importe quelle fonction de x vous souhaitez utiliser comme condition de filtrage.

Par exemple, si vous souhaitez filtrer tous les éléments inférieurs à, disons, 10, vous utiliserez l'instruction de compréhension de liste [x for x in list if x<10] pour créer une nouvelle liste avec tous les éléments de liste inférieurs à 10.

Voici trois exemples de filtrage d'une liste :

• Obtenir les éléments inférieurs à huit :[x for x in lst if x<8] .
• Obtenir les éléments pairs :[x for x in lst if x%2==0] .
• Obtenir des éléments impairs :[x for x in lst if x%2] .

lst = [8, 2, 6, 4, 3, 1]

# Filter all elements <8
small = [x for x in lst if x<8]
print(small)


# Filter all even elements
even = [x for x in lst if x%2==0]
print(even)

# Filter all odd elements
odd = [x for x in lst if x%2]
print(odd)

La sortie est :

# Elements <8
[2, 6, 4, 3, 1]

# Even Elements
[8, 2, 6, 4]

# Odd Elements
[3, 1]

C'est le moyen le plus efficace de filtrer une liste et c'est aussi le plus pythonique. Si vous cherchez des alternatives, continuez à lire car je vais vous expliquer chaque nuance des listes de filtrage en Python dans ce guide complet.

Filtrer efficacement les listes en Python :filter() vs List Comprehension

[Spoiler] Qu'est-ce qui est le plus rapide pour filtrer une liste :filter() vs list comprehension ? Pour les grandes listes avec un million d'éléments, le filtrage des listes avec la compréhension de liste est 40 % plus rapide que le filter() intégré méthode.

Pour répondre à cette question, j'ai écrit un court script qui teste les performances d'exécution du filtrage de grandes listes de tailles croissantes à l'aide du filter() et les méthodes de compréhension de liste.

Ma thèse est que la méthode de compréhension de liste devrait être légèrement plus rapide pour les listes de grande taille, car elle exploite l'implémentation cPython efficace de la compréhension de liste et n'a pas besoin d'appeler une fonction supplémentaire.

J'ai utilisé mon ordinateur portable avec un processeur Intel(R) Core(TM) i7-8565U 1,8 GHz (avec Turbo Boost jusqu'à 4,6 GHz) et 8 Go de RAM.

Ensuite, j'ai créé 100 listes avec les deux méthodes avec des tailles allant de 10 000 éléments à 1 000 000 éléments. En tant qu'éléments, j'ai simplement incrémenté les nombres entiers de un à partir de 0.

Voici le code que j'ai utilisé pour mesurer et tracer les résultats :quelle méthode est la plus rapide :filter() ou liste de compréhension ?

import time


# Compare runtime of both methods
list_sizes = [i * 10000 for i in range(100)]
filter_runtimes = []
list_comp_runtimes = []

for size in list_sizes:

    lst = list(range(size))
    
    # Get time stamps
    time_0 = time.time()
    list(filter(lambda x: x%2, lst))
    time_1 = time.time()
    [x for x in lst if x%2]
    time_2 = time.time()

    # Calculate runtimes
    filter_runtimes.append((size, time_1 - time_0))
    list_comp_runtimes.append((size, time_2 - time_1))


# Plot everything
import matplotlib.pyplot as plt
import numpy as np

f_r = np.array(filter_runtimes)
l_r = np.array(list_comp_runtimes)

print(filter_runtimes)
print(list_comp_runtimes)

plt.plot(f_r[:,0], f_r[:,1], label='filter()')
plt.plot(l_r[:,0], l_r[:,1], label='list comprehension')

plt.xlabel('list size')
plt.ylabel('runtime (seconds)')

plt.legend()
plt.savefig('filter_list_comp.jpg')
plt.show()

Le code compare les temps d'exécution du filter() fonction et la variante de compréhension de liste pour filtrer une liste. Notez que le filter() renvoie un objet filtre, vous devez donc le convertir en liste en utilisant le list() constructeur.

Voici le tracé résultant qui compare le temps d'exécution des deux méthodes. Sur l'axe des x, vous pouvez voir la taille de la liste de 0 à 1 000 000 éléments. Sur l'axe y, vous pouvez voir le temps d'exécution en secondes nécessaire pour exécuter les fonctions respectives.

Le graphique résultant montre que les deux méthodes sont extrêmement rapides pour quelques dizaines de milliers d'éléments. En fait, ils sont si rapides que le time() fonction du module de temps ne peut pas capturer le temps écoulé.

Mais à mesure que vous augmentez la taille des listes à des centaines de milliers d'éléments, la méthode de compréhension de liste commence à gagner :

Pour les grandes listes avec un million d'éléments, le filtrage des listes avec la compréhension de liste est 40 % plus rapide que le filter() intégré méthode.

La raison en est l'implémentation efficace de la déclaration de compréhension de liste. Une observation intéressante est cependant la suivante. Si vous ne convertissez pas la fonction de filtrage en liste, vous obtenez le résultat suivant :

Soudain le filter() La fonction a une durée d'exécution constante proche de 0 seconde, quel que soit le nombre d'éléments dans la liste. Pourquoi cela se produit-il ?

L'explication est simple :la fonction filter renvoie un itérateur, pas une liste. L'itérateur n'a pas besoin de calculer un seul élément jusqu'à ce qu'il soit demandé de calculer le next() élément. Donc, le filter() La fonction calcule l'élément suivant uniquement si cela est nécessaire. Ce n'est que si vous le convertissez en liste qu'il doit calculer toutes les valeurs. Sinon, il ne calcule pas réellement une seule valeur à l'avance.

Vidéo associée :filter() en Python

Articles associés :

• Comment filtrer une liste Python de listes ?
• Compréhension des listes :liste de listes Python
• Filtre() vs List Comprehension
• Compréhension des listes imbriquées
• Le guide ultime des listes Python
• Compréhension des listes