[python{2.7,3.4} Amélioration des temps de traitement

**avi3000** · 08/08/2014, 18h13

Bonjour,

J'ai effectué un petit test comparatif sur un afficheur de news en mode console sur archlinux avec différents langages et outils dont vous trouverez le résultat ci-dessous.

Il en ressort que le temps de chargement de python3 est relativement long, comparé aux autres environnements, notamment python2.7 .

Dans l'attente de vos observations, suggestions, solutions et propositions.

Code Résultats des benchs :

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
Bench n°1: 100 lancement sur 1 rss local
c module :      0.128
c compilé jit : 0.28 
lua :           0.36
awk :           0.43
sed :           0.58
python2 :       0.95
bash :          1.35
python3 :       6.60
 
 
Bench n°2: 1 lancement sur 300 rss concaténés
c module :      0.065
c compilé jit : 0.065
python2 :       0.068
python3 :       0.12
awk :           0.18
lua :           0.35
sed :           0.58
bash :          3.05
 
 
Bench n°3: 100 lancements sur 300 rss concaténés
c module :      5.82
c compilé jit : 5.86 
python2 :       6.25
python3 :        12s
awk :            18s
lua :            33s
sed :            58s
bash :           73s (20 lancements)

python3.4 : cat zz.txt | ./news3.py

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
#!/usr/bin/env python3
 
import sys
 
red  = "\033[31m"
bleu = "\033[34m"
gris = "\033[37m"
defo = "\033[0m"
buf = False
l = []
 
xml = sys.stdin.read().splitlines()
for z in xml :
    z = z.lstrip()
    if z[0:7] == "<title>" : 
        if buf :
            l.append('\n')
            l.append(z[7:-8].replace('’', 'ʼ'))
        else :
            buf = True
            l.append("\n\t\t>> News Archlinux.fr <<\n")
    elif z[0:9] == "<pubDate>" : 
        l.append(' || ')
        l.append(bleu)
        l.append(z[14:-25])
        l.append('\n')
    elif z[0:15] == "<description><!" :
        l.append(gris)
        l.append(z[22:-17].replace('’', 'ʼ').replace('>', '>').replace('…', '...'))
        l.append(defo)
        l.append('\n')
 
print(*l, sep='')

python2.7 : cat zz.txt | ./news27.py

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
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
 
import sys
 
red  = "\033[31m"
bleu = "\033[34m"
gris = "\033[37m"
defo = "\033[0m"
buf = False
buf2 = ''
 
xml = sys.stdin.read().splitlines()
for z in xml :
    z = z.lstrip()
    if z[0:7] == "<title>" : 
        if buf :
            print '\n{} || '.format(z[7:-8].replace('’', 'ʼ')),
        else :
            buf = True
            print "\n\t\t>> News Archlinux.fr <<"
    elif z[0:9] == "<pubDate>" : 
        print bleu + z[14:-25]
    elif z[0:15] == "<description><!" :
        print gris + z[22:-17].replace('’', 'ʼ').replace('>', '>').replace('…', '...') + defo
 
print

**deusyss** · 11/08/2014, 07h49

Salut,

Concernant ton code, il est optimisable.

Par exemple, à quoi sert ".replace('>','>') ??? Tu perds deja du temps à cet endroit.

Tu en perds également en accédant plusieurs fois à Z[0: x]. Deja la notation Z[: x] est plus pythonique, mais surtout, à chaque acces, tu change x, imposant une relecture. Lit Z[:7] et place le dans une variable avant ton if. Ensuite utilise ta variable dans les predicats. Oui pour les 2 et 3eme predicats, la comparaison n'est pas sur un mot complet mais une portion de mot, mais cela est bien suffisant je pense (au moins pour les deux premiers); et cela te permettra encore de gagner du temps d'exécution.

Sinon concernant ta question première, il faut savoir que certaines fonctionnalités Python 3.X ont été réécrite et/ou fusionnées depuis la branche 2.X. Je pense que l'explication vient de là, car ce n'est pas la première fois que je constate ce genre de différence de temps d’exécution (dans les deux sens, je précise). C'est sur ce genre de petite chose qu'on tombe en essayant de migrer de la branche 2 à la branche 3.

La solution utilisée généralement consiste à analyser le code section par section, afin d'isoler les différentes partie posant problème au niveau timing, et à réécrire, si possible, cette section.

**avi3000** · 13/08/2014, 20h31

Bonsoir

Envoyé par deusyss

Par exemple, à quoi sert ".replace('>','>')

Le gestionnaire a interprété la notation xml : replace('&#62 ;', '>')

Envoyé par deusyss

Tu en perds également en accédant plusieurs fois à Z[0: x]. Deja la notation Z[: x] est plus pythonique.

et Z[: x] est 4% plus rapide en test unitaire.

Envoyé par deusyss

Concernant ton code, il est optimisable.

Je l'ai optimisé suivant tes conseils, mais comme c'est un test comparatif, j'ai également optimisé les autres langages.
Peu de changement dans le classement, python 3.4 est nettement plus lent (dans mes tests) que python 2.7.
Les 2 versions de python sont plus lentes (dans mes tests) que perl et lua.

Code Nouveau Résultat des benchs : :

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
Bench n°1: 100 lancement sur 1 rss local avec affichage
c module :      0.128
c compilé jit : 0.28 
lua :           0.32
awk :           0.43
perl :          0.50
sed :           0.58
python2 :       0.95
bash :          1.35
python3 :       1.60
 
 
Bench n°2: 200 lancement sur 1 rss local        # time for i in {1..200};do cat zz|./script >/dev/null;done
c module :      0.275
lua :           0.46
c compilé jit : 0.65 
awk :           0.94
perl :          0.95
sed :           1.05
python2 :       1.91
bash :          1.53
python3a :      3.24
python3b :      3.25
 
 
Bench n°3: 100 lancements sur 300 rss concaténés         # time for i in {1..100};do cat zy|./script >file;done
c module :      1.23
c compilé jit : 1.37 
perl :          3.96
python2 :       5.33
lua :           6.65 26s
python3a :      9.27 13s
python3b :     10.23 13s
awk :            13s
sed :            49s
bash :           56s (20 lancements)
 
 
Bench n°4: 1 lancement sur 3000 rss concaténés           # sans affichage
c module :      0.111
c compilé jit : 0.120
perl :          0.362 0.521
python2 :       0.445 0.593
lua :           0.661 2.532
python3a :      0.768 1.056
python3b :      0.870 1.116
awk :           1.251
sed :           4.918
 
Python 2.7.8 (default, Jul  1 2014, 17:30:21) 
[GCC 4.9.0 20140604 (prerelease)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import timeit
>>> timeit.timeit("while i>0: i-=1","i=10**7")
0.3921658992767334
>>> timeit.timeit("while i>0: i-=1","i=10**7")
0.3980870246887207
>>> 
 
Python 3.4.1 (default, May 19 2014, 17:23:49) 
[GCC 4.9.0 20140507 (prerelease)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import timeit
>>> timeit.timeit("while i>0: i-=1","i=10**7")
0.7147223350002605
>>> timeit.timeit("while i>0: i-=1","i=10**7")
0.71387163899999
>>>

Code python2 :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#!/usr/bin/env python2         
# -*- coding: utf-8 -*-        
 
import sys
 
for z in sys.stdin.read().splitlines() : 
    y = z[:5]                  
    if y == "<rss " :          
        print("\n\t\t>> News Archlinux.fr <<\n")
    elif y == "\t\t<ti" :      
        tit = z[9:-8].replace('’', 'ʼ') 
    elif y == "\t\t<pu" :      
        pub = z[16:-25]        
    elif y == "\t\t<de" :      
        print('{} || \033[34m{}\n\033[37m{}\033[0m\n'.format(tit, pub, z[24:-17].replace('’', 'ʼ').replace('>', '>').replace('…', '...')))

Code python3a :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/usr/bin/env python          
 
import sys
 
for z in sys.stdin.read().splitlines() : 
    y = z[:5]                  
    if y == "<rss " :          
        print("\n\t\t>> News Archlinux.fr <<\n")
    elif y == "\t\t<ti" :      
        tit = z[9:-8].replace('&#8217 ;', 'ʼ')
    elif y == "\t\t<pu" :      
        pub = z[16:-25]        
    elif y == "\t\t<de" :      
        print('{} || \033[34m{}\n\033[37m{}\033[0m\n'.format(tit, pub, z[24:-17].replace('&#8217 ;', 'ʼ').replace('&#62 ;', '>').replace('&#8230 ;', '...')))

Code python3b :

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
#!/usr/bin/env python          
 
import sys
 
bleu = "\033[34m"              
gris = "\033[37m"              
defo = "\033[0m"               
l = []
 
for z in sys.stdin.read().splitlines() : 
    y = z[:5]
    if y == "<rss " :          
        print("\n\t\t>> News Archlinux.fr <<\n")
    elif y == "\t\t<ti" :      
        l.append(z[9:-8].replace('&#8217 ;', 'ʼ'))
    elif y == "\t\t<pu" :      
        l.append(' || ')       
        l.append(bleu)         
        l.append(z[16:-25])    
        l.append('\n')         
    elif y == "\t\t<de" :      
        l.append(gris)
        l.append(z[24:-17].replace('&#8217 ;', 'ʼ').replace('&#62 ;', '>').replace('&#8230 ;', '...'))
        l.append(defo)         
        l.append('\n\n')       
 
print(*l, sep='')

**fred1599** · 13/08/2014, 21h30

python est un langage qui permet de comparer des algorithmes entre eux, de construire et de tester des implémentations. Optimiser quelques millièmes de secondes en cherchant à corriger une implantation CPython est totalement inutile, il y a des mecs bien plus calés que nous pour trouver et modifier tout cela.
Si ça n'a pas été fait, c'est que ça n'en valait pas le coup.

Si vraiment tu veux gagner du temps de réponse, maintenant que ton algorithme est construit, tu peux le faire en C, C++, voir cython par exemple (il y en a d'autres évidemment plus performant que python).

Personnellement j'aime bien cython, boost et de plus en plus lua.

**avi3000** · 13/08/2014, 22h47

Envoyé par fred1599

python est un langage qui permet de comparer des algorithmes entre eux, de construire et de tester des implémentations. Optimiser quelques millièmes de secondes en cherchant à corriger une implantation CPython est totalement inutile, il y a des mecs bien plus calés que nous pour trouver et modifier tout cela.
Si ça n'a pas été fait, c'est que ça n'en valait pas le coup.

Si vraiment tu veux gagner du temps de réponse, maintenant que ton algorithme est construit, tu peux le faire en C, C++, voir cython par exemple (il y en a d'autres évidemment plus performant que python).

Personnellement j'aime bien cython, boost et de plus en plus lua.

J'ai du mal m'exprimer:
Comparer les temps d'exécution de C et python ne me parait pas présenter beaucoup d'intérêt. Pas besoin de test, pour savoir lequel est le plus rapide.
En revanche comparer les temps d'exécution de Python2, Python3, Perl, Lua me parait intéressant.

Dans les tests que j'ai faits (petit programme de rien du tout et tests unitaires), Python2 est toujours plus rapide que Python3.
Personnellement, je trouve ça décevant.

Code C :

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
38
39
40
41
42
43
44
45
46
47
48
49
50
#!/usr/bin/tcc -run 
 
#include <stdio.h>
#include <string.h>
 
#define MAX_LINE_SIZE   1024
#define BLEU            "\e[34m"
#define GRIS            "\e[37m"
#define DEFO            "\e[0m"
 
void replace(char *z, char *cible, char rep ) { 
     char buf[MAX_LINE_SIZE];
     char *y; 
 
     while ( y = strstr(z, cible) ) { 
          y[0] = rep;
          strcpy(buf, y+strlen(cible));
          strcpy(y+1, buf);
     }   
}
 
int main() {
     char line[MAX_LINE_SIZE];
     char y[6]; y[5] = '\0';
     char *z; 
     int on_one = 1;
 
     while ( fgets(line, MAX_LINE_SIZE, stdin) ) { 
        memcpy(y, line, 5); 
        if ( strcmp(y, "<rss ") == 0 ) { 
            printf("\n\t\t>> News Archlinux.fr <<\n\n");
        }   
        else if ( strcmp(y, "\t\t<ti") == 0 ) { 
            line[strlen(line)-9] = '\0';
            replace(line, "&#8217 ;", '\'' ); 
            printf("%s", line+9);
        }   
        else if ( strcmp(y, "\t\t<pu") == 0 ) { 
            line[strlen(line)-26] = '\0';
            printf(" || %s%s%s\n", BLEU, line+16, DEFO);
        }   
        else if ( strcmp(y, "\t\t<de") == 0 ) { 
            line[strlen(line)-27] = '\0';
            replace(line, "&#8217 ;", '\'' ); 
            replace(line, "&#62 ;", '>' ); 
            printf("%s%s[...]%s\n\n", GRIS, line+24, DEFO);
        }   
     }   
     return 0;
}

**wiztricks** · 14/08/2014, 10h55

Salut,

Envoyé par avi3000

En revanche comparer les temps d'exécution de Python2, Python3, Perl, Lua me parait intéressant.

Dans les tests que j'ai fait (petit programme de rien du tout et tests unitaires), Python2 est toujours plus rapide que Python3.
Personnellement, je trouve ça décevant.

Si vous vous contentez de comparer un bout de code vous allez avoir une vue limitée aux fonctions utilisées par ce code de l'implémentation "en dessous".

Pour benchmarker, il faudrait élargir l'ensemble des fonctions testées.
Le résultat sera plus dispersé: des "plus" dans certains cas et des "moins" dans d'autres.
Faites quelques recherches sur Google pour récupérer les résultats de ces benchmarks: çà ne s'organise pas sur un coin de table, assurez vous de leur sérieux!

Si vos tests durent un pouième mais nécessitent de charger l'interpréteur Python, vous avez déjà une forte variabilité due aux chargements de Python et de ses bibliothèques qui biaisera les résultats sans être nécessairement significatifs.

- W

**avi3000** · 14/08/2014, 11h27

Bonjour,

Que python3 soit plus efficace pour faire des choses compliquées, c'est parfait.

Mais est-il normal qu'une simple boucle while soit quasiment 2 fois plus rapide en python2?

Etant un esprit simple, programmant simplement des applications simples, je ne voit pas trop le progrès.
Je suis certainement trop cartésien.

Code :

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

1
2
3
4
5
6
7
8
9
Python 2.7.8 (default, Jul  1 2014, 17:30:21) 
[GCC 4.9.0 20140604 (prerelease)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import timeit
>>> timeit.timeit("while i>0: i-=1","i=10**7")
0.3921658992767334
>>> timeit.timeit("while i>0: i-=1","i=10**7")
0.3980870246887207
>>>

Code :

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

1
2
3
4
5
6
7
8
9
Python 3.4.1 (default, May 19 2014, 17:23:49) 
[GCC 4.9.0 20140507 (prerelease)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import timeit
>>> timeit.timeit("while i>0: i-=1","i=10**7")
0.7147223350002605
>>> timeit.timeit("while i>0: i-=1","i=10**7")
0.71387163899999
>>>

Envoyé par wiztricks

Si vos tests durent un pouième mais nécessitent de charger l'interpréteur Python

Ce qui explique mes tests avec 1, 100, 200 ou 300 lancements.
Comparer les temps de chargement d'un interpréteur ou d'un compilateur en ligne, est peut-être une imbécilité, mais j'ai la faiblesse de m'y intéresser.

**deusyss** · 14/08/2014, 13h06

Envoyé par wiztricks

Si vos tests durent un pouième mais nécessitent de charger l'interpréteur Python, vous avez déjà une forte variabilité due aux chargements de Python et de ses bibliothèques qui biaisera les résultats sans être nécessairement significatifs.

C'est souvent une chose à laquelle on ne pense pas toujours. Merci de le rappeler

**wiztricks** · 14/08/2014, 16h12

Salut,

Envoyé par avi3000

Que python3 soit plus efficace pour faire des choses compliquées, c'est parfait.

Mais est-il normal qu'une simple boucle while soit quasiment 2 fois plus rapide en python2?

Votre démarche est louable.
Je vous signalais juste qu'elle est pleines d’embûches et qu'il n'est pas si facile de "faire bien".

Dans le genre "piège", un programmeur Python écrira rarement:

Code :

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

1
2
3
4
def foo():
     n = 10**7
     while n > 0:
          n -= 1

il préférera utiliser irange/range:

Code :

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

1
2
3
def bar():
      for n in range(10**7):
          pass

Et si on mesure avec timeit.timeit(stmt=bar, number=1), on trouve:

3.3 : 0.2318027138357479
2.7 : 0.2993959420401513 (remplacer range par xrange).

Pour l'instant, c'est mieux "on est content"...
Puis on va ajouter du boulot et çà pourra être "moins bien".

On va en conclure quoi?

- W

**avi3000** · 14/08/2014, 20h50

Envoyé par wiztricks

Et si on mesure avec timeit.timeit(stmt=bar, number=1), on trouve:

3.3 : 0.2318027138357479
2.7 : 0.2993959420401513 (remplacer range par xrange).

Pour l'instant, c'est mieux "on est content"...
Puis on va ajouter du boulot et çà pourra être "moins bien".

On va en conclure quoi?

- W

Que c'est de la triche parce que ta fonction ne fait rien !

C'est bien de me rappeler qu'une boucle for / range() est plus rapide qu'un while avec incrémentation, je l'avais oublié.
Je fais mes tests sur un linux 3.16, les versions de python sont indiquées dans les résultats.
Un précision qui a peut-être son importance, la fonction range est implémentée dans ma version python 2.7.8.

J'ai donc mouliné ton code et python 2 est toujours devant, de peu, mais devant quand même.

Code python2 :

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
Python 2.7.8 (default, Jul  1 2014, 17:30:21)
[GCC 4.9.0 20140604 (prerelease)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> def foo () :
...      for n in range(10**7) :
...           pass 
... 
>>> import timeit
>>> timeit.timeit(stmt=foo, number=1)
0.2579009532928467
>>> timeit.timeit(stmt=foo, number=1)
0.24813485145568848
>>> timeit.timeit(stmt=foo, number=1)
0.24727916717529297
>>> timeit.timeit(stmt=foo, number=1)
0.24480009078979492
>>>

Code python3 :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Python 3.4.1 (default, May 19 2014, 17:23:49)
[GCC 4.9.0 20140507 (prerelease)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> def foo () :
...      for n in range(10**7) :
...           pass
...
>>> import timeit
>>> timeit.timeit(stmt=foo, number=1)
0.2786895510000704
>>> timeit.timeit(stmt=foo, number=1)
0.2769160020000072
>>> timeit.timeit(stmt=foo, number=1)
0.2759325209999588
>>>

Moins de 10% d'écart, je suis à çà de désinstaller python2.

Plus compliqué, une incrémentation dans la boucle, histoire d'avoir une fonction qui serve à quelque chose.

Code python2 :

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
Python 2.7.8 (default, Jul  1 2014, 17:30:21)
[GCC 4.9.0 20140604 (prerelease)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> def foo () :
...      i=0
...      for n in range(10**7) :
...           i += 1
...
>>> import timeit
>>> timeit.timeit(stmt=foo, number=1)
0.43460798263549805
>>> timeit.timeit(stmt=foo, number=1)
0.43344807624816895
>>> timeit.timeit(stmt=foo, number=1)
0.41942501068115234
>>>

Code python3 :

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
Python 3.4.1 (default, May 19 2014, 17:23:49)
[GCC 4.9.0 20140507 (prerelease)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> def foo () :
...      i=0
...      for n in range(10**7) :
...           i += 1
...
>>> import timeit
>>> timeit.timeit(stmt=foo, number=1)
0.6095207000000755
>>> timeit.timeit(stmt=foo, number=1)
0.6193184910000582
>>> timeit.timeit(stmt=foo, number=1)
0.6233823640000082
>>>

Patatras, la mouche dans le lait, le cheveu sur la soupe !
python2 un tiers plus rapide ou python3 moitié plus lent, je vous laisse choisir.

J'en conclus que python3 est moins rapide sur cette incrémentation.
J'en conclus également que python3 est presque aussi rapide que python2 ... pour ne rien faire !

Pour le reste mon interrogation persiste, elle est même pas loin de s'aggraver.

**wiztricks** · 14/08/2014, 21h42

Salut,

J'essaie de vous expliquer que ces micro-benchmarks n'ont pas grand intérêt car ils ne permettent pas de conclure et ouvrent la porte à du grand n'importe quoi.
A part vous dire çà, je ne passerai pas plus de temps sur ce sujet: trop de boulot pour peu de résultats tangibles.
Désolé.

- W

Invité · 14/08/2014, 22h18

Bonsoir,

Moi, j'aurais juste une question qui n'a rien à voir avec la soupe.

timeit.timeit(stmt=callable) n'est indiqué nulle part dans la doc officielle.

Comment avez-vous trouvé cette possibilité ?

En lisant le code source du module timeit ?

En tout cas, pour le tuyau :

@+.

**avi3000** · 14/08/2014, 22h33

Envoyé par tarball69

Bonsoir,

timeit.timeit(stmt=callable) n'est indiqué nulle part dans la doc officielle.

Comment avez-vous trouvé cette possibilité ?

dans les réponses de wiztricks !

Envoyé par wiztricks

J'essaie de vous expliquer que ces micro-benchmarks n'ont pas grand intérêt car ils ne permettent pas de conclure et ouvrent la porte à du grand n'importe quoi.

Où sont les arguments ?

Si python3 est dans les mêmes temps sur le traitement de l'unicode, pour le traitement des puissances le ratio et de 1 à 3,5 !!

Le problème est que tous ces petits tests de rien du tout concluent tous dans le même sens.

Code tests :

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
Python 2.7.8 (default, Jul  1 2014, 17:30:21)
[GCC 4.9.0 20140604 (prerelease)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> def foo () :
...      i=0
...      for n in range(10**7) :
...           i += 1
...
>>> import timeit
>>> timeit.timeit(stmt=foo, number=1)
0.43460798263549805
>>> timeit.timeit(stmt=foo, number=1)
0.43344807624816895
>>> timeit.timeit(stmt=foo, number=1)
0.41942501068115234
>>>
 
Python 3.4.1 (default, May 19 2014, 17:23:49)
[GCC 4.9.0 20140507 (prerelease)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> def foo () :
...      i=0
...      for n in range(10**7) :
...           i += 1
...
>>> import timeit
>>> timeit.timeit(stmt=foo, number=1)
0.6095207000000755
>>> timeit.timeit(stmt=foo, number=1)
0.6193184910000582
>>> timeit.timeit(stmt=foo, number=1)
0.6233823640000082
>>>
 
 
Python 2.7.8 (default, Jul  1 2014, 17:30:21)
[GCC 4.9.0 20140604 (prerelease)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> def foo () :
...      for n in range(10**7) :
...           pass
...
>>> import timeit
>>> timeit.timeit(stmt=foo, number=1)
0.2579009532928467
>>> timeit.timeit(stmt=foo, number=1)
0.24813485145568848
>>> timeit.timeit(stmt=foo, number=1)
0.24727916717529297
>>> timeit.timeit(stmt=foo, number=1)
0.24480009078979492
>>>
 
Python 3.4.1 (default, May 19 2014, 17:23:49)
[GCC 4.9.0 20140507 (prerelease)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> def foo () :
...      for n in range(10**7) :
...           pass
...
>>> import timeit
>>> timeit.timeit(stmt=foo, number=1)
0.2786895510000704
>>> timeit.timeit(stmt=foo, number=1)
0.2769160020000072
>>> timeit.timeit(stmt=foo, number=1)
0.2759325209999588
>>>
 
 
Python 2.7.8 (default, Jul  1 2014, 17:30:21)
[GCC 4.9.0 20140604 (prerelease)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> def foo () :
...      i=10
...      for n in range(10**7) :
...           j = i**5
...
>>> import timeit
>>> timeit.timeit(stmt=foo, number=1)
0.8299188613891602
>>> timeit.timeit(stmt=foo, number=1)
0.8282570838928223
>>> timeit.timeit(stmt=foo, number=1)
0.8228349685668945
>>>
 
Python 3.4.1 (default, May 19 2014, 17:23:49)
[GCC 4.9.0 20140507 (prerelease)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> def foo () :
...      i=10
...      for n in range(10**7) :
...           j = i**5
...
>>> import timeit
>>> timeit.timeit(stmt=foo, number=1)
2.892750603999957
>>> timeit.timeit(stmt=foo, number=1)
2.891723878999983
>>> timeit.timeit(stmt=foo, number=1)
2.889941599999929
>>>
 
 
Python 2.7.8 (default, Jul  1 2014, 17:30:21)
[GCC 4.9.0 20140604 (prerelease)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> def foo () :
...     i=0
...     for n in range(10**7) :
...         if i == 0 :
...             i = 1
...         else :
...             i = 0
...
>>> import timeit
>>> timeit.timeit(stmt=foo, number=1)
0.47496700286865234
>>> timeit.timeit(stmt=foo, number=1)
0.47234201431274414
>>> timeit.timeit(stmt=foo, number=1)
0.44492101669311523
>>>
 
Python 3.4.1 (default, May 19 2014, 17:23:49)
[GCC 4.9.0 20140507 (prerelease)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> def foo () :
...     i=0
...     for n in range(10**7) :
...         if i == 0 :
...             i = 1
...         else :
...             i = 0
...
>>> import timeit
>>> timeit.timeit(stmt=foo, number=1)
0.6134780769998542
>>> timeit.timeit(stmt=foo, number=1)
0.6131948579995878
>>> timeit.timeit(stmt=foo, number=1)
0.6179328769994754
>>>
 
 
Python 2.7.8 (default, Jul  1 2014, 17:30:21)
[GCC 4.9.0 20140604 (prerelease)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> def foo () :
...     i=b'a'
...     for n in range(10**7) :
...         if i == b'a' :
...             i = b'b'
...         else :
...             i = b'a'
...
>>> import timeit
>>> timeit.timeit(stmt=foo, number=1)
0.5112879276275635
>>> timeit.timeit(stmt=foo, number=1)
0.4996612071990967
>>> timeit.timeit(stmt=foo, number=1)
0.49184417724609375
>>>
 
Python 3.4.1 (default, May 19 2014, 17:23:49)
[GCC 4.9.0 20140507 (prerelease)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> def foo () :
...     i=b'a'
...     for n in range(10**7) :
...         if i == b'a' :
...             i = b'b'
...         else :
...             i = b'a'
...
>>> import timeit
>>> timeit.timeit(stmt=foo, number=1)
0.5920504750001783
>>> timeit.timeit(stmt=foo, number=1)
0.5973300589994324
>>> timeit.timeit(stmt=foo, number=1)
0.5917335349995483
>>>
 
 
Python 2.7.8 (default, Jul  1 2014, 17:30:21)
[GCC 4.9.0 20140604 (prerelease)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> def foo () :
...     i = 'abcdefghijkmlnopqrstu'
...     for n in range(10**7) :
...         if i == 'abcdefghijkmlnopqrstu' :
...             i = 'zzcdefghijkmlnopqrstub'
...         else :
...             i = 'abcdefghijkmlnopqrstu'
...
>>> import timeit
>>> timeit.timeit(stmt=foo, number=1)
0.49675703048706055
>>> timeit.timeit(stmt=foo, number=1)
0.5195529460906982
>>> timeit.timeit(stmt=foo, number=1)
0.4936959743499756
>>>
 
Python 2.7.8 (default, Jul  1 2014, 17:30:21)
[GCC 4.9.0 20140604 (prerelease)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> def foo () :
...     i = u'abcdefghijkmlnopqrstu'
...     for n in range(10**7) :
...         if i == u'abcdefghijkmlnopqrstu' :
...             i = u'zzcdefghijkmlnopqrstub'
...         else :
...             i = u'abcdefghijkmlnopqrstu'
...
>>> import timeit
>>> timeit.timeit(stmt=foo, number=1)
0.5757241249084473
>>> timeit.timeit(stmt=foo, number=1)
0.5701348781585693
>>> timeit.timeit(stmt=foo, number=1)
0.597790002822876
>>>
 
Python 3.4.1 (default, May 19 2014, 17:23:49)
[GCC 4.9.0 20140507 (prerelease)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> def foo () :
...     i = 'abcdefghijkmlnopqrstu'
...     for n in range(10**7) :
...         if i == 'abcdefghijkmlnopqrstu' :
...             i = 'zzcdefghijkmlnopqrstub'
...         else :
...             i = 'abcdefghijkmlnopqrstu'
...
>>> import timeit
>>> timeit.timeit(stmt=foo, number=1)
0.5813169960001687
>>> timeit.timeit(stmt=foo, number=1)
0.5853672539997206
>>> timeit.timeit(stmt=foo, number=1)
0.5891314910004439
>>>

**fred1599** · 14/08/2014, 23h54

Le problème est que tous ces petits tests de rien du tout concluent tous dans le même sens.

Oui celui que j'ai indiqué plus haut

Envoyé par fred1599

Maintenant si tu es vraiment déçu, alors plus qu'à reprendre python 2.x, mais je ne pense pas que ton test fera avancer le schmilblick

Python pourrait être deux fois plus lent, que je prendrais le même plaisir à coder avec, ce qui m'intéresse c'est résoudre un problème et vérifier que mon algorithme fonctionne en codant rapidement (syntaxe simple). Après soit les performances du langages me conviennent, soit je prend un autre langage...

Invité · 15/08/2014, 07h02

Envoyé par avi3000

dans les réponses de wiztricks !

Ah ça y est, vu, OK.

Merci -W

@+.

**wiztricks** · 15/08/2014, 10h55

Envoyé par tarball69

Moi, j'aurais juste une question qui n'a rien à voir avec la soupe.

timeit.timeit(stmt=callable) n'est indiqué nulle part dans la doc officielle.

Comment avez-vous trouvé cette possibilité ?

La doc. officielle est (toujours) le source

Mais je ne sais pas pourquoi la documentation "utilisateur" ne mentionne pas cette possibilité.
i.e. est-ce un oubli ou y-a-t-il de bonnes raisons pour ne pas faire publicité de...

Un autre point de vue est de se mettre à la place d'un programmeur Python: passer en paramètre str ou callable vient tout seul, il suffit de laisser ses doigts taper...
C'est ce qui rend la construction:

Code :

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

1
2
for n in range(10**7):
     ...

plus "correcte" que:

Code :

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

1
2
3
n = 10**7
while n > 0:
      n -= 1

qui est une construction C traduite mot à mot en Python.

- W

Invité · 15/08/2014, 11h23

Envoyé par wiztricks

La doc. officielle est (toujours) le source

Oui bah, s'il faut se taper le code source de chaque API que nos programmes consomment, on va ressembler à des baudruches !

Mais je ne sais pas pourquoi la documentation "utilisateur" ne mentionne pas cette possibilité.
i.e. est-ce un oubli ou y-a-t-il de bonnes raisons pour ne pas faire publicité de...

Pour le coup, j'ai lu le code source : je ne vois pas en quoi ça gênerait ?

C'est pris en compte au même titre que stmt=str().

Un autre point de vue est de se mettre à la place d'un programmeur Python: passer en paramètre str ou callable vient tout seul, il suffit de laisser ses doigts taper...

Non, là, je ne suis absolument pas d'accord : il relève du choix de l'équipe de dév. de décider de ce que l'on implante ou pas dans une fonctionnalité donnée.

Et justement, une bonne doc se doit de respecter l'implémentation telle qu'elle a été réalisée, au pouième près (d'autant plus lorsqu'elle intègre la doc officielle d'un langage).

Pour avoir écumé pas mal d'API de toutes sortes, je sais d'expérience qu'il n'est jamais acquis d'avance que telle ou telle option soit mise en oeuvre par défaut.

Pour ma part, lorsque la doc stipule :

To give the timeit module access to functions you define, you can pass a setup parameter which contains an import statement:

Code :

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

1
2
3
4
5
6
7
def test():
    """Stupid test function"""
    L = [i for i in range(100)]
 
if __name__ == '__main__':
    import timeit
    print(timeit.timeit("test()", setup="from __main__ import test"))

Je ne perds pas mon temps à tâtonner en me disant : "peut-être qu'ils ont fait ci ou fait ça ?"

J'applique les consignes - point barre.

Ce serait une horreur si on devait conjecturer (ou spéculer) sans cesse comme cela à chaque API que l'on consomme.

En tout cas, merci pour le tuyau, ça me facilite le code.

@+.

**wiztricks** · 15/08/2014, 15h35

Envoyé par tarball69

Non, là, je ne suis absolument pas d'accord : il relève du choix de l'équipe de dév. de décider de ce que l'on implante ou pas dans une fonctionnalité donnée.

Et justement, une bonne doc se doit de respecter l'implémentation telle qu'elle a été réalisée, au pouième près (d'autant plus lorsqu'elle intègre la doc officielle d'un langage).

Pour un langage comme Pyhon, la documentation est orientée "cas d'utilisations".
La documentation de l'API est généralement "light".
C'est un choix des développeurs qui est cohérent avec les attentes de la population des utilisateurs de Python qui sont peu souvent des "programmeurs".

Lire les sources lorsqu'on a des questions "avancées" est parfois incontournable.
Et comme Python est un langage à lire, çà ne pose pas vraiment de problèmes.
De plus, c'est une mine de bons exemples pour les débutants.

- W

Invité · 15/08/2014, 16h12

Envoyé par wiztricks

Pour un langage comme Pyhon, la documentation est orientée "cas d'utilisations".
La documentation de l'API est généralement "light".

On peut être light sans omettre des fonctionnalités nettement plus intéressantes que timeit.timeit("fonction()", setup="from __main__ import fonction")

Je trouve ça gros qu'ils aient préféré cette notation à celle-ci : timeit.timeit(fonction)

A moins qu'ils n'aient implémenté cette petite option supplémentaire après coup, mais bon, quand même.

C'est un choix des développeurs qui est cohérent avec les attentes de la population des utilisateurs de Python qui sont peu souvent des "programmeurs".

C'est tout à leur honneur tant qu'ils pensent justement à l'intérêt des utilisateurs. Le cas timeit ne parle pas en leur faveur, pour le coup.

Lire les sources lorsqu'on a des questions "avancées" est parfois incontournable.

Absolument. Et je le fais quand j'en ressens le besoin. Mais là, sur le cas de timeit, je ne voyais pas trop l'intérêt d'aller fourrer mon nez dans le code source (?)

Et comme Python est un langage à lire, çà ne pose pas vraiment de problèmes.

Tous les matins au petit déj, entre deux ou trois litres de café.

Nan, je rigole. Je rajoute un peu de sucre de temps en temps, aussi.

De plus, c'est une mine de bons exemples pour les débutants.

- W

Wiztricks et ses débutants...

Nous sommes tous d'éternels débutants. On n'a jamais fini d'apprendre, et c'est bien mieux comme ça.

Débutants... et fiers de l'être !

@+.