web-dev-qa-db-fra.com

comment mesurer le temps d'exécution des algorithmes en python

Doubles possibles:
Synchronisation précise des fonctions en python
mesure avec précision le temps que prend la fonction python

Comment mesurer et comparer les temps d'exécution de mes algorithmes écrits en python.

pythonalgorithm
25
Bunny Rabbit

Je ne suis pas sûr à 100% de ce que l'on entend par "temps d'exécution de mes algorithmes écrits en python", alors j'ai pensé que je pourrais essayer de donner un aperçu plus large de certaines des réponses possibles.

  • Les algorithmes n'ont pas de temps d'exécution; les implémentations peuvent être chronométrées, mais un algorithme est une approche abstraite de faire quelque chose. La partie la plus courante et souvent la plus précieuse de l'optimisation d'un programme est la { analyse de l'algorithme }, généralement utilisée par l'analyse asymptotique et le calcul de la complexité { gros O en temps, espace, utilisation du disque, etc. .

    Un ordinateur ne peut pas vraiment faire cette étape pour vous. Cela nécessite de faire le calcul pour comprendre comment quelque chose fonctionne. L’optimisation de cet aspect est la principale composante permettant d’obtenir des performances évolutives.

  • Vous pouvez chronométrer votre implémentation spécifique. Le meilleur moyen de faire cela en Python est d'utiliser timeit . La façon dont on semble vouloir le plus utiliser est de créer un module avec une fonction encapsulant ce que vous voulez appeler et de l'appeler à partir de la ligne de commande avec python -m timeit ....

    Utiliser timeit pour comparer plusieurs extraits lors de la microoptimisation, mais ce n'est souvent pas l'outil approprié pour comparer deux algorithmes différents. Il est courant que vous recherchiez une analyse asymptotique, mais il est possible que vous souhaitiez des types d’analyses plus complexes.

  • Vous devez savoir à quelle heure. La plupart des extraits ne valent pas la peine d'être améliorés. Vous devez apporter des modifications là où elles comptent, surtout lorsque vous effectuez une micro-optimisation et que vous n'améliorez pas la complexité asymptotique de votre algorithme. 

    Si vous quadruplez la vitesse d'une fonction dans laquelle votre code passe 1% du temps, il ne s'agit pas d'une réelle accélération. Si vous augmentez de 20% la vitesse d'une fonction dans laquelle votre programme passe 50% du temps, vous avez un réel gain.

    Pour déterminer le temps passé par un vrai programme Python, utilisez les utilitaires de profilage stdlib . Cela vous indiquera où, dans un exemple de programme, votre code passe son temps. 

20
Mike Graham

Le module timeit est utile à cet effet et est inclus dans la distribution Python standard.

Exemple:

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

Pour les petits algorithmes, 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 précis mais toujours valide, vous pouvez utiliser le temps de module comme ceci:

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)
22
joaquin

Utiliser un décorateur pour mesurer le temps d'exécution des fonctions peut être pratique. Vous trouverez 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, de sorte que l'exemple existe à SO au cas où le site serait rayé 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

13
John P

Le langage de programmation n'a pas d'importance; La mesure de la complexité d'exécution d'un algorithme fonctionne de la même manière, quelle que soit la langue. Analyse des algorithmes par Stanford le Google Code University est une très bonne ressource pour vous apprendre à analyser la complexité d'exécution des algorithmes et du code. 

Si tout ce que vous voulez faire, c'est mesurer le temps nécessaire à une fonction ou à une section de code pour s'exécuter en Python, vous pouvez utiliser les modules timeit ou time , en fonction du temps requis par le code. courir.

0
Michael Aaron Safyan