Dokładny czas funkcji w python

Question

Programuję w python na windows i chciałbym dokładnie zmierzyć czas potrzebny na uruchomienie funkcji. Napisałem funkcję "time_it", która przyjmuje inną funkcję, uruchamia ją i zwraca czas potrzebny na uruchomienie.

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

nazywam to 1000 razy i średnie wyniki. (Stała 1000 na końcu to udzielenie odpowiedzi w milisekundach.)

Ta funkcja wydaje się działać, ale mam dokuczliwe uczucie, że robię coś złego, i robiąc to w ten sposób, używam więcej czasu niż funkcja faktycznie używa, gdy działa.

Czy istnieje bardziej standardowy lub akceptowany sposób na zrobienie tego?

Kiedy zmieniłem funkcję testu, aby wywołać wydruk, aby trwało dłużej, funkcja time_it zwraca średnio 2,5 ms, podczas gdy cProfile.run ("f()" zwraca średnią wartość 7.0 ms. Pomyślałem, że moja funkcja przeceniłaby czas, jeśli cokolwiek, co tu się dzieje?

Jedna uwaga dodatkowa, to względny czas funkcji względem siebie, na którym mi zależy, a nie czas bezwzględny, ponieważ oczywiście będzie się on różnić w zależności od sprzętu i innych czynników.

Answer 1

Zamiast pisać własny kod profilowania, proponujemy zapoznać się z wbudowanych profilarek Python (profile lub cProfile, w zależności od potrzeb): http://docs.python.org/library/profile.html

Answer 2

Użyj przycisku ze standardowej biblioteki Pythona.

Podstawowe użycie:

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 

Answer 3

Kod ten jest bardzo niedokładna

total= 0 
for i in range(1000): 
    start= time.clock() 
    function() 
    end= time.clock() 
    total += end-start 
time= total/1000 

Kod ten jest mniej niedokładne

start= time.clock() 
for i in range(1000): 
    function() 
end= time.clock() 
time= (end-start)/1000 

Bardzo niedokładne cierpi z powodu błędu pomiaru, jeśli w czasie wykonywania Funkcja jest zbliżona do dokładności zegara. Większość mierzonych czasów to jedynie liczby losowe od 0 do kilku tyknięć zegara.

W zależności od obciążenia systemu, "czas" obserwowany z pojedynczej funkcji może być w całości artefaktem planowania systemu operacyjnego i innych niekontrolowanych kosztów ogólnych.

Druga wersja (mniej niedokładna) ma mniejszą wartość polaryzacji pomiaru. Jeśli twoja funkcja jest naprawdę szybka, być może będziesz musiał uruchomić ją 10 000 razy, aby zminimalizować planowanie systemu operacyjnego i inne narzuty.

Obie są, oczywiście, bardzo mylące. Czas działania twojego programu - jako całości - nie jest sumą czasu działania funkcji. Liczb można używać tylko do porównań względnych. Nie są to bezwzględne pomiary, które mają duże znaczenie.

Answer 4

Jeśli chcesz czasować metodę pythona, nawet jeśli blok, który mierzysz, może rzucać, dobrym sposobem jest użycie instrukcji with. Zdefiniować pewne Timer klasy jako

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 

Wtedy może chcesz czasie metodę połączenia, które mogą rzucić.Użyj metody, która zostanie wywołana, nawet jeśli żądanie połączenia zostanie odebrane. Dokładniej, trzeba użyć tryfinally aby zobaczyć wynik w przypadku rzutów, jak z

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

More details here.

Answer 5

Można stworzyć „timeme” dekorator podobnie jak

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) 

Answer 6

To jest łatwiejsze niż

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" 

Answer 7

Podobny do odpowiedzi @ AlexMartelli

import timeit 
timeit.timeit(fun, number=10000) 

może załatwić sprawę.