Le moment précis de fonctions en python

Je suis à la programmation en python sur windows et souhaitez mesurer avec précision le temps qu'il faut pour une fonction à exécuter. J'ai écrit une fonction "time_it" qui prend une autre fonction, l'exécute et renvoie le temps qu'il a fallu pour exécuter.

def time_it(f, *args):
    start = time.clock()
    f(*args)
    return (time.clock() - start)*1000

j'appelle ça 1000 fois et la moyenne du résultat. (les 1000 constante à la fin est de donner la réponse en millisecondes.)

Cette fonction semble fonctionner mais j'ai ce sentiment tenace que je suis en train de faire quelque chose de mal, et qu'en le faisant de cette façon, je suis en utilisant plus de temps que la fonction utilise lors de son exécution.

Est-il une norme plus ou accepté pour ce faire?

Quand j'ai changé mon test de la fonction à appeler un imprimer de sorte qu'il dure plus longtemps, mon time_it fonction retourne une moyenne de 2,5 ms tandis que le cProfile.run('f()') retourne et la moyenne de 7.0 ms. J'ai pensé que ma fonction serait surestimer le temps si quoi que ce soit, ce qui se passe ici?

Une remarque supplémentaire, c'est le temps relatif de fonctions par rapport à l'autre que je me soucie, pas le temps absolu comme ce sera évidemment varier selon le matériel et d'autres facteurs.

InformationsquelleAutor Atilio Jobson | 2009-05-20

37

Au lieu d'écrire votre propre code de profilage, je vous suggère de vérifier le Python intégrée profileurs (profile ou cProfile, selon vos besoins): http://docs.python.org/library/profile.html
- M'ignorer - que la chaîne n'est pas un nom de fonction, c'est un bloc eval avais le code. De sorte que vous pouvez l'utiliser pour rapide timing. C'est la bonne réponse. Et dans les autres nouvelles - "n'est pas" est significativement plus rapide que "!=" - mais peut avoir d'autres répercussions.
- Et de ce tangente - avant à l'aide de "et non pas" pour rien clever - garder ceci à l'esprit stackoverflow.com/questions/1392433/...
- Le python profil docs dire cependant: "Le profiler les modules sont conçus pour fournir un profil d'exécution pour un programme donné, et non pas à des fins d'étalonnage (pour cela, il est timeit pour raisonnable de l'exactitude des résultats)."
InformationsquelleAutor Daniel Lew
69

Utiliser le timeit module de l'Python standard library.

D'utilisation de base:
```
from timeit import Timer

# first argument is the code to be run, the second "setup" argument is only run once,
# and it not included in the execution time.
t = Timer("""x.index(123)""", setup="""x = range(1000)""")

print t.timeit() # prints float, for example 5.8254
# ..or..
print t.timeit(1000) # repeat 1000 times instead of the default 1million
```
- je veux que ma fonction qui doit être appelée avec différents arguments, pourtant quand je l'appelle t = timeit.Minuterie("f()", "de l' principal importer f") avec différents arguments et exécutez t.timeit(10000) encore une fois, j'obtiens les mêmes résultats si différents arguments devraient entraîner très différents environnements d'exécution.
InformationsquelleAutor Alex Martelli

Vous pouvez créer un "timeme" décorateur, comme si

import time                                                

def timeme(method):
    def wrapper(*args, **kw):
        startTime = int(round(time.time() * 1000))
        result = method(*args, **kw)
        endTime = int(round(time.time() * 1000))

        print(endTime - startTime,'ms')
        return result

    return wrapper

@timeme
def func1(a,b,c = 'c',sleep = 1):
    time.sleep(sleep)
    print(a,b,c)

func1('a','b','c',0)
func1('a','b','c',0.5)
func1('a','b','c',0.6)
func1('a','b','c',1)

+n pour cette réponse. Je souhaite qu'il y ait une telle option. La beauté est que je peux exporter le journal des résultats dans un fichier externe et ajouter ce partout où j'en ai besoin! Merci zillion.
Cela fonctionne très bien pour les non-fonctions récursives. Pour les fonctions récursives, il renvoie un moment pour chaque itération de la fonction.
Voici une version plus raffinée: stackoverflow.com/questions/7370801/...

InformationsquelleAutor vdrmrt

23

Ce code est très imprécis
```
total= 0
for i in range(1000):
    start= time.clock()
    function()
    end= time.clock()
    total += end-start
time= total/1000
```
Ce code est moins inexactes
```
start= time.clock()
for i in range(1000):
    function()
end= time.clock()
time= (end-start)/1000
```
La très imprécis souffre d'un biais de mesure si le moment de l'exécution de la fonction est proche de l'exactitude de l'horloge. La plupart du temps mesurés sont simplement des nombres aléatoires entre 0 et quelques tops de l'horloge.

En fonction de votre charge de travail du système, le "temps" vous observer à partir d'une seule fonction peut être tout à fait un artefact de l'OS de la planification et d'autres incontrôlable frais généraux.

La deuxième version (moins inexacte) a moins d'un biais de mesure. Si votre fonction est vraiment rapide, vous devrez peut-être exécuter à 10 000 fois à l'humidité, hors de l'OS de la planification et d'autres frais généraux.

Les deux sont, bien sûr, terriblement trompeuse. Le temps d'exécution de votre programme, dans son ensemble, n'est pas la somme de la fonction d'exécution de fois. Vous ne pouvez utiliser les numéros relative des comparaisons. Ils ne sont pas des mesures absolues qui véhiculent beaucoup de sens.
- Pourquoi l' /1000? La méthode de temps.clock() retourne les secondes comme une valeur à virgule flottante. Si vous vous attendiez le retour de millisecondes, ce serait logique, cependant en divisant par 1000 convertit à kiloseconds, d'une unité, je n'ai jamais vu avant.
- milli / 1000 = micro, pas de kilo 🙂
- Il suggère que la valeur est en secondes, l'e.g 1000 secondes. Si vous le diviser par 1000, vous obtenez 1 "kiloseconds".
- parce que la fonction a été exécutée à 1000 fois. Donc time est le temps moyen qu'il faut pour exécuter la fonction une fois.
- Je propose de ne pas remplacer le nom du module "time" avec une variable appelée "temps"
InformationsquelleAutor S.Lott

Si vous voulez le temps d'un python méthode, même si vous bloquer mesure pourrait lancer, une bonne approche est d'utiliser with déclaration. Définir quelques Timer classe comme

import time

class Timer:    
    def __enter__(self):
        self.start = time.clock()
        return self

    def __exit__(self, *args):
        self.end = time.clock()
        self.interval = self.end - self.start

Alors vous voudrez peut de temps un mode de connexion qui peut jeter. Utilisation

import httplib

with Timer() as t:
    conn = httplib.HTTPConnection('google.com')
    conn.request('GET', '/')

print('Request took %.03f sec.' % t.interval)

__exit()__ méthode sera appelée, même si la demande de connexion thows. Plus précisément, vous aurez vous utilisez try finally pour voir le résultat dans le cas où il jette, comme avec

try:
    with Timer() as t:
        conn = httplib.HTTPConnection('google.com')
        conn.request('GET', '/')
finally:
    print('Request took %.03f sec.' % t.interval)

Plus de détails ici.

InformationsquelleAutor kiriloff

7

C'est plus lisible
```
from contextlib import contextmanager

import time
@contextmanager
def timeblock(label):
    start = time.clock()
    try:
        yield
    finally:
        end = time.clock()
        print ('{} : {}'.format(label, end - start))



with timeblock("just a test"):
            print "yippee"
```
- Belle réponse, simple et jusqu'à présent, le seul que j'ai trouvé qui vous permet d'envoyer une étiquette à la fonction de minuterie.
- Solution élégante, mais un peu trop compliqué. Passé une heure à essayer de comprendre pourquoi time.sleep(10) seulement pris en 0.002 secondes pour s'exécuter en fonction de ce code. (btw, une grande différence entre time.clock() et time.time() en python)
InformationsquelleAutor JasonEdinburgh
4

Similaire à @AlexMartelli la réponse de
```
import timeit
timeit.timeit(fun, number=10000)
```
peut faire l'affaire.

InformationsquelleAutor Binu Jasim

Vous devez vous connecter pour publier un commentaire.