Question c_. du jour sur uneList.pop

Bonjour,
en treme de rapidité d'exécution, vaut-il mieux faire uneListe = uneListe[:-1] ou bien uneListe = uneListe.pop(-1) ?

Même question pour uneListe = uneListe[:-3] et for i in range(3): uneListe.pop(-1) .

bonjour,

j'aurais tendance à dire que l'appel à pop est plus rapide. je me base sur le fait qu'une réaffectation de la liste va copier les valeurs en mémoire.

c'est de l'intuition (et en général pour des questions d'optimisation, l'intuition c'est le mal) alors qu'un petit profile ou hotshot, voire même un petit time sur ce cas précis serait plus juste :p

Bonjour,

Petit test:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
from time import clock
 
liste = [i for i in xrange(0, 10000)]
 
t1 = clock()
liste2 = liste[:-1]
t1 = clock()-t1
 
t2 = clock()
liste3 = liste.pop(-1)
t2 = clock()-t2
 
print t1, t2, t2/t1

Résultat: la solution pop est un peu plus lente.

Tyrtamos

Merci pour ces réponses. J'ai repris le test de tyrtamos sous Python 3 de la façon suivante :

Code:

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#! /usr/bin/env python3
 
from time import clock
 
liste = [i for i in range(0, 10000000)]
 
t1 = clock()
liste2 = liste[:-1]
t1 = clock()-t1
 
liste3 = liste
t2 = clock()
liste3.pop(-1)
t2 = clock()-t2
 
print("---",
      "Même liste ?",
      liste2 == liste3,
      "Temps pour liste = liste[:-1]",
      t1,
      "Temps pour liste = liste.pop(-1)",
      t2,
      sep="\n")
 
t1 = clock()
liste2 = liste[:-1000]
t1 = clock()-t1
 
liste3 = liste[:]
t2 = clock()
for i in range(1000): liste3.pop(-1)
t2 = clock()-t2
 
print("---",
      "Même liste ?",
      liste2 == liste3,
      "Temps pour liste = liste[:-100]",
      t1,
      "Temps pour for i in range(100): liste.pop(-1)",
      t2,
      sep="\n")
 
 
t1 = clock()
liste2 = liste[:-9999999]
t1 = clock()-t1
 
liste3 = liste
t2 = clock()
for i in range(9999999): liste3.pop(-1)
t2 = clock()-t2
 
print("---",
      "Même liste ?",
      liste2 == liste3,
      "Temps pour liste = liste[:-9999999]",
      t1,
      "Temps pour for i in range(9999999): liste.pop(-1)",
      t2,
      sep="\n")

J'obtiens :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
---
Même liste ?
True
Temps pour liste = liste[:-1]
0.18
Temps pour liste = liste.pop(-1)
0.0
---
Même liste ?
True
Temps pour liste = liste[:-100]
0.25
Temps pour for i in range(100): liste.pop(-1)
0.0
---
Même liste ?
True
Temps pour liste = liste[:-9999999]
0.09
Temps pour for i in range(9999999): liste.pop(-1)
4.77

En fait, il faut regarder au cas par cas.

L'intuition et les explications de kango semblent bonnes dans les cas usuels où on doit enlever quelques éléments en fin de liste. Mon expérience perso. a été confronté à ces cas là et non au cas particulier que j'ai exhibé dans le dernier test ci-dessus.