Fondamentalement, je me demande quelle est la méthode la plus efficace pour trouver les éléments d'une liste python avec une valeur supérieure à, disons, n.

Je pense que le moyen le plus simple, mais pas aussi efficace, est comme ci-dessous,

for i in range(len(theList)):
    if theList[i] > n:
        subList.append(theList[i])

De plus, nous avons la seule ligne for comme ci-dessous,

(subList for subList in theList if sublist > n)

(Veuillez me corriger s'il y a un problème avec la syntaxe ci-dessus)

Enfin, nous pouvons utiliser la fonction filter(), ce qui n'est pas agréable à utiliser, du moins pour moi.

Les méthodes ci-dessus étaient toutes les façons que je connais. Si vous connaissez une meilleure méthode, dites-le-moi. Sinon, veuillez expliquer lequel est le meilleur, dans le sens de l'efficacité et du temps d'exécution .

0
Hossein Rahimi 16 mars 2019 à 04:26

2 réponses

Meilleure réponse

Il n'y a pas de réponse toujours juste à cela et il y a eu quelques messages SO sur la vitesse des différentes approches lors de la gestion de la liste, voir par ex. ici, ici ou ici.

Quel est le moyen le plus rapide peut dépendre beaucoup de votre liste. Cela dit, examinons simplement à quelle vitesse les approches suggérées sont rapides.

Pour des comparaisons simples comme celle-ci, vous pouvez utiliser timeit :

1. Cas : La boucle for

for_case = """newList=[]
for x in theList:
    if x > n:
            newList.append(x)"""

2. Cas : compréhension de liste

list_comp = '[x for x in theList if x > n]'

3. Cas : Le filtre (d'une certaine manière peu différent)

filtering = 'list(filter(lambda x: x > n, theList))'

Un peu de préparation :

import timeit
si = 'theList=range(2000);n=1000;'  # using list(range(2000)) has no effect on the ranking

Alors voyons :

timeit.timeit(si+list_comp, number=10000)
Out[21]: 1.3985847820003983
timeit.timeit(si+filtering, number=10000)
Out[22]: 3.315784254024038
timeit.timeit(si+for_case, number=10000)
Out[23]: 2.0093530920275953

Ainsi, au moins sur ma machine, la compréhension de la liste l'enlève, suivie de la boucle for et, au moins dans ce cas, l'indifférent filter est en effet le plus lent.

2
jojo 16 mars 2019 à 02:16

Version de compréhension de la liste:

sublist = [ i for i in the_list if i > n ]

Expression du générateur: (si la liste est de grande taille)

sublist = ( i for i in the_list if i > n )
-1
Ijaz Ahmad Khan 16 mars 2019 à 02:10