Comme le dit le titre. Ce n'est pas un processus lourd au départ, donc je ne pense pas que ça va arriver à un programme lent quand je le sais, mais c'était surprenant, donc comme une petite histoire.
code
from __future__ import print_function
import timeit
print("i+=1\t", timeit.timeit("while i<1000000: i+=1", setup="i=0"))
print("i=i+1\t", timeit.timeit("while i<1000000: i=i+1", setup="i=0"))
print("a[0]+=1\t", timeit.timeit("while a[0]<1000000: a[0]+=1", setup="a=[0]"))
print("a[0]=a[0]+1\t", timeit.timeit("while a[0]<1000000: a[0]=a[0]+1", setup="a=[0]"))
text:Python2.7.8 Résultat de l'exécution
i+=1 0.0610518455505
i=i+1 0.0599188804626
a[0]+=1 0.108623981476
a[0]=a[0]+1 0.108937978745
text:Python3.4.1 résultat d'exécution
i+=1 0.08549419100017985
i=i+1 0.07950809699832462
a[0]+=1 0.14678418899711687
a[0]=a[0]+1 0.1382706459990004
Python3 est plus lent. Je ne savais pas.
En tous cas. On peut voir que ʻi = i + 1 est plus rapide que ʻi + = 1, bien que très légèrement.
Je ne l'ai pas étudié en détail, mais la cause est probablement la suivante.
Lorsque vous ajoutez des affectations sous la forme «i + = 1», l'interpréteur Python essaie d'abord de trouver «i .__ iadd__». Et s'il n'existe pas, cherchez ʻi .__ add__. Pour les ajouts de la forme ʻi = i + 1, l'interpréteur Python recherche ʻi .__ add__ depuis le début. Ainsi, ni Python2 ni Python3 n'ont ʻint .__ iadd__.
Par conséquent, il y a un gaspillage dans le traitement de ʻi + = 1 car il échoue en recherchant ʻint .__ iadd__.
Par conséquent, le format «i = i + 1» est probablement plus rapide.
Cependant, je pensais que ʻa [0] + = 1 serait plus rapide que ʻa [0] = a [0] + 1, ce qui nécessite deux références de tableau.
Si vous y réfléchissez bien, il semble qu'il soit plus rapide de se référer au 0ème du tableau que de rechercher une méthode.
Recommended Posts