Discussion :

[Sve@r]

Bonjour

Tout est dans le titre. Soit une liste "liste" qu'on désire traiter à l'envers. Y a-t-il une utilité d'utiliser reversed(liste) alors qu'on a liste[::-1] ???
Surtout que reversed() n'est qu'un générateur. Donc si on veut traiter la liste inversée d'un bloc, il faudra écrire [x for x in reversed(liste)] c'est à dire établir une seconde liste à partir du générateur alors que liste[::-1] est déjà une liste toute faite et donc semble plus indiquée...

Je me suis posé la question suite à cette discussion dans laquelle j'ai vu quelqu'un proposer liste [::-1] et où ma solution basée sur reverse() était plus lourde.

Merci de votre concours.

[tyrtamos]

Bonjour,

Question intéressante!

Un petit test de rapidité (Python 2.7):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import random
random.seed()
import time
 
n = 1000
liste = [random.randint(0, 1000000) for i in xrange(0, n)]
 
m = 1000000
t1 = time.clock()
for i in xrange(0, m):
    liste1 = list(reversed(liste))
t1 = time.clock()-t1
print t1
 
t2 = time.clock()
for i in xrange(0, m):
    liste2 = liste[::-1]
t2 = time.clock()-t2
print t2
 
t3 = time.clock()
for i in xrange(0, m):
    liste3 = [elem for elem in reversed(liste)]
t3 = time.clock()-t3
print t3

Résultat:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
8.7287309896
2.59176160548
56.2658522154

On pourrait, bien sûr, essayer différentes configurations n et m pour vérifier si l'une des solutions s'améliore avec la taille de la liste par exemple.

Conclusion:
- le meilleur, c'est liste[::-1]
- après, c'est list(reversed(liste)): 2 à 5 fois moins rapide
- mais le plus mauvais, et de loin, c'est: [elem for elem in reversed(liste)]

En fait, on n'a pas toujours le choix: reversed a l'avantage de renvoyer les éléments un par un, et quelquefois, c'est de ça dont on a besoin.

[Kurodiam]

Tu parles en terme de vitesse(donc performance) mais ceci s'appliquerait bien en effet si on manipule un grand fichier .L'option avec reversed() donne un code condensé , mais on a parfois comme tu l'as dit pas le choix (si on trouve rien d'autres comme solution) .

[Sve@r]

Un petit test de rapidité (Python 2.7):...

Conclusion:
- le meilleur, c'est liste[::-1]
- après, c'est list(reversed(liste)): 2 à 5 fois moins rapide
- mais le plus mauvais, et de loin, c'est: [elem for elem in reversed(liste)]

Excellent
Et en plus j'ai découvert time.clock()

J'adore ce forum

Fort de ton aide (surtout sur le 3° essai), je viens de reprendre 400 sources et j'ai checké partout où j'écrivais [for ... in ...] (heureusement "vi" a des regex de folie pour ce genre de recherche) pour regarder si parfois ça pouvait s'écrire list(...) et j'en ai trouvé quelques uns

En fait, on n'a pas toujours le choix: reversed a l'avantage de renvoyer les éléments un par un, et quelquefois, c'est de ça dont on a besoin.

Comme un générateur - Si on n'a pas besoin d'avoir forcément la liste entière en mémoire à cet endroit là...
Merci à tous

[fred1599]

Celle-ci devrait être pas mal non plus je pense...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
def test(myList):
    for i in xrange(len(myList), -1, -1):
        yield myList[i]

À voir

EDIT: C'est tout vu! c'est fin pourri

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
from time import clock
from random import randint
 
def displayTime(func):
    res = "Fonction {name}: {time} secondes"
    def wrap(varList):
        start = clock()
        for i in xrange(1000000):
            func(varList)
        t = clock() - start
        print res.format(name=func.__name__, time=t)
    return wrap
 
def execute(iterable, *func):
    for f in func:
        yield f(iterable)
 
@displayTime
def test_1(myList):
    return myList[::-1]
 
@displayTime
def test_2(myList):
    return list(reversed(myList))
 
@displayTime
def test_3(myList):
    def wrp():
        for i in xrange(len(myList)-1, -1, -1):
            yield myList[i]
    return list(wrp())
 
myList = [randint(0, 1000000) for i in xrange(1000)]
 
test_3(myList)
test_2(myList)
test_1(myList)

Résultats:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
fred1599@fred1599-Aspire-5741G:~$ python test.py
Fonction test_3: 121.73 secondes
Fonction test_2: 19.6 secondes
Fonction test_1: 7.96 secondes

Par contre si j'utilise que le générateur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
@displayTime
def test_4(myList):
    for i in xrange(len(myList)-1, -1, -1):
        yield myList[i]

On cartonne tout

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
fred1599@fred1599-Aspire-5741G:~$ python test.py
Fonction test_4: 0.57 secondes