comment mesurer le temps de marche des algorithmes en python

Question

Doublons possibles:
Accurate timing of functions in python
accurately measure time python function takes

Comment puis-je Mesuré et comparer les temps de fonctionnement de mes algorithmes écrits en Python .Aussi pointez-moi vers un site/forum d'algorithmes sympa comme stackoverflow si vous le pouvez.

Answer 1

Je ne suis pas 100% sûr de ce que l'on entend par « temps de fonctionnement de mes algorithmes écrits en Python », donc je pensais que je pourrais essayer d'offrir un regard plus large sur certains des réponses potentielles.

• Les algorithmes ne sont pas en cours d'exécution fois; les implémentations peuvent être chronométrées, mais un algorithme est une approche abstraite pour faire quelque chose. La partie la plus commune et souvent la plus précieuse de l'optimisation d'un programme est analyzing the algorithm, en utilisant généralement l'analyse asymptotique et en calculant la complexité big O dans le temps, l'espace, l'utilisation du disque et ainsi de suite.

  Un ordinateur ne peut pas vraiment faire cette étape pour vous. Cela nécessite de faire des calculs pour comprendre comment quelque chose fonctionne. L'optimisation de ce côté des choses est l'élément principal pour avoir des performances évolutives.

• Vous pouvez planifier votre implémentation spécifique. La meilleure façon de faire cela en Python est d'utiliser timeit. La façon dont il semble le plus vouloir être utilisé est de faire un module avec une fonction encapsulant ce que vous voulez appeler et l'appeler depuis la ligne de commande avec python -m timeit .... Utilisation de timeit pour comparer plusieurs extraits lors de la micro-optimisation, mais souvent n'est pas l'outil approprié pour comparer deux algorithmes différents. Il est courant que ce que vous voulez soit une analyse asymptotique, mais il est possible que vous vouliez des types d'analyse plus compliqués.

• Vous devez savoir quoi chronométrer. La plupart des extraits ne valent pas la peine d'être améliorés. Vous devez faire des changements là où ils comptent réellement, en particulier lorsque vous faites de la micro-optimisation et n'améliorez pas la complexité asymptotique de votre algorithme.

  Si vous quadrupler la vitesse d'une fonction dans laquelle votre code passe 1% du temps, ce n'est pas une réelle accélération. Si vous faites une augmentation de vitesse de 20% sur une fonction dans laquelle votre programme passe 50% du temps, vous avez un gain réel.

  Pour déterminer le temps passé par un vrai programme Python, utilisez le stdlib profiling utilities. Cela vous dira où dans un exemple de programme votre code passe son temps.

Answer 2

Le module timeit est utile pour cela et est inclus dans la distribution Python standard.

Exemple:

import timeit 
timeit.Timer('for i in xrange(10): oct(i)').timeit() 

Answer 3

Pour les petits algorithmes que vous pouvez utiliser le module timeit de la documentation python:

def test(): 
    "Stupid test function" 
    L = [] 
    for i in range(100): 
     L.append(i) 

if __name__=='__main__': 
    from timeit import Timer 
    t = Timer("test()", "from __main__ import test") 
    print t.timeit() 

moins avec précision, mais toujours valide, vous pouvez utiliser le temps du module comme celui-ci:

from time import time 
t0 = time() 
call_mifuntion_vers_1() 
t1 = time() 
call_mifunction_vers_2() 
t2 = time() 

print 'function vers1 takes %f' %(t1-t0) 
print 'function vers2 takes %f' %(t2-t1) 

Answer 4

Le langage de programmation n'a pas d'importance; mesurer la complexité d'exécution d'un algorithme fonctionne de la même manière, quelle que soit la langue. Analysis of Algorithms par Stanford sur Google Code University est une très bonne ressource pour vous enseigner comment analyser la complexité d'exécution des algorithmes et du code. Si tout ce que vous voulez faire est de mesurer le temps écoulé qu'une fonction ou une section de code a pris pour fonctionner en Python, alors vous pouvez utiliser les modules timeit ou time, en fonction de la durée d'exécution du code.

Answer 5

L'utilisation d'un décorateur pour mesurer le temps d'exécution des fonctions peut être pratique. Il y a un exemple à http://www.zopyx.com/blog/a-python-decorator-for-measuring-the-execution-time-of-methods. Ci-dessous j'ai collé sans vergogne le code du site mentionné ci-dessus afin que l'exemple existe à SO dans le cas où le site est effacé du réseau.

import time             

def timeit(method): 

    def timed(*args, **kw): 
     ts = time.time() 
     result = method(*args, **kw) 
     te = time.time() 

     print '%r (%r, %r) %2.2f sec' % \ 
       (method.__name__, args, kw, te-ts) 
     return result 

    return timed 

class Foo(object): 

    @timeit 
    def foo(self, a=2, b=3): 
     time.sleep(0.2) 

@timeit 
def f1(): 
    time.sleep(1) 
    print 'f1' 

@timeit 
def f2(a): 
    time.sleep(2) 
    print 'f2',a 

@timeit 
def f3(a, *args, **kw): 
    time.sleep(0.3) 
    print 'f3', args, kw 

f1() 
f2(42) 
f3(42, 43, foo=2) 
Foo().foo() 

// John