Jak korzystać z modułu timeit

Jeśli chcesz użyć timeit w interaktywnej sesji Pythona, są dwie wygodne opcje:

1. Użyj powłoki IPython. Posiada wygodną %timeit specjalną funkcję:

   In [1]: def f(x):
      ...:     return x*x
      ...: 
   
   In [2]: %timeit for x in range(100): f(x)
   100000 loops, best of 3: 20.3 us per loop
   

2. W standardowym interpreterze Pythona można uzyskać dostęp do funkcji i innych nazw zdefiniowanych wcześniej podczas sesji interaktywnej, importując je z __main__ w instrukcji setup:

   >>> def f(x):
   ...     return x * x 
   ... 
   >>> import timeit
   >>> timeit.repeat("for x in range(100): f(x)", "from __main__ import f",
                     number=100000)
   [2.0640320777893066, 2.0876040458679199, 2.0520210266113281]
   

Powiem ci w tajemnicy: najlepszym sposobem użycia {[16] } jest linia komend.

W wierszu poleceń, timeit wykonuje właściwą analizę statystyczną: mówi, jak długo trwało najkrótsze uruchomienie. Jest to dobre, ponieważ wszystkie błąd w czasie jest pozytywny. Więc najkrótszy czas ma w sobie najmniejszy błąd. Nie ma sposobu, aby uzyskać negatywny błąd, ponieważ komputer nigdy nie może obliczyć szybciej niż może obliczyć!

Więc interfejs wiersza poleceń:

%~> python -m timeit "1 + 2"
10000000 loops, best of 3: 0.0468 usec per loop

To całkiem proste, co?

Możesz ustawić rzeczy:

%~> python -m timeit -s "x = range(10000)" "sum(x)"
1000 loops, best of 3: 543 usec per loop

Co też jest przydatne!

Jeśli chcesz mieć wiele linii, możesz użyć automatycznej kontynuacji powłoki lub użyć oddzielnych argumentów:

%~> python -m timeit -s "x = range(10000)" -s "y = range(100)" "sum(x)" "min(y)"
1000 loops, best of 3: 554 usec per loop

To daje konfigurację

x = range(1000)
y = range(100)

I razy

sum(x)
min(y)

Jeśli chcesz mieć dłuższe Skrypty, możesz pokusić się o przeniesienie do timeit wewnątrz skryptu Pythona. Sugeruję unikanie tego, ponieważ analiza i czas są po prostu lepsze na wiersz poleceń. Zamiast tego mam tendencję do tworzenia skryptów powłoki:

 SETUP="

 ... # lots of stuff

 "

 echo Minmod arr1
 python -m timeit -s "$SETUP" "Minmod(arr1)"

 echo pure_minmod arr1
 python -m timeit -s "$SETUP" "pure_minmod(arr1)"

 echo better_minmod arr1
 python -m timeit -s "$SETUP" "better_minmod(arr1)"

 ... etc

Może to potrwać nieco dłużej ze względu na wielokrotne inicjalizacje, ale zwykle nie jest to wielka sprawa.

Ale co jeślichcesz użyć timeit wewnątrz twojego modułu?

Cóż, prosty sposób jest do zrobienia:

def function(...):
    ...

timeit.Timer(function).timeit(number=NUMBER)

I to daje zbiorcze (a nie minimum!) czas uruchomić tę liczbę razy.

Aby uzyskać dobrą analizę, użyj .repeat i weź minimum:

min(timeit.Timer(function).repeat(repeat=REPEATS, number=NUMBER))

Powinieneś normalnie połączyć to z functools.partial zamiast lambda: ..., aby obniżyć koszty. Można więc mieć coś w stylu:

from functools import partial

def to_time(items):
    ...

test_items = [1, 2, 3] * 100
times = timeit.Timer(partial(to_time, test_items)).repeat(3, 1000)

# Divide by the number of repeats
time_taken = min(times) / 1000

timeit.timeit("...", setup="from __main__ import ...", number=NUMBER)

Co da ci coś bliższego interfejsowi z linii poleceń, ale w znacznie mniej fajny sposób. "from __main__ import ..." pozwala na użycie kodu z głównego modułu wewnątrz sztucznego środowiska stworzonego przez timeit.

Warto zauważyć, że jest to wygoda wrapper dla Timer(...).timeit(...) i tak nie jest szczególnie dobry w czasie. Osobiście zdecydowanie wolę używać Timer(...).repeat(...), jak pokazałem powyżej.

Ostrzeżenia

Jest kilka zastrzeżeń z timeit które trzymają się wszędzie.

• / Align = "left" / Powiedz, że chcesz czas x += 1, aby dowiedzieć się, jak długo trwa dodawanie:

  >>> python -m timeit -s "x = 0" "x += 1"
  10000000 loops, best of 3: 0.0476 usec per loop
  

  Cóż, to jest nie 0.0476 µs. Wiesz tylko, że jest mniej niż to. Wszystkie błędy są pozytywne.

  Więc spróbuj i znaleźć czysty nad głową:

  >>> python -m timeit -s "x = 0" ""      
  100000000 loops, best of 3: 0.014 usec per loop
  

  That 's a good 30% / align = "left" / Może to znacznie przekrzywiać względne czasy. Ale naprawdę zależało Ci tylko na dodaniutimingów; czasy wyszukiwania dla x również muszą być uwzględnione w napowietrznych:

  >>> python -m timeit -s "x = 0" "x"
  100000000 loops, best of 3: 0.0166 usec per loop
  

  Różnica nie jest dużo większa, ale jest.

• Metody mutacji są niebezpieczne.

  >>> python -m timeit -s "x = [0]*100000" "while x: x.pop()"
  10000000 loops, best of 3: 0.0436 usec per loop
  

  Ale to jest całkowicie błędne! x jest pusta lista po pierwszej iteracji. Musisz ponownie zainicjować:

  >>> python -m timeit "x = [0]*100000" "while x: x.pop()"
  100 loops, best of 3: 9.79 msec per loop
  

  / Align = "left" / Rozlicz to osobno.

  >>> python -m timeit "x = [0]*100000"                   
  1000 loops, best of 3: 261 usec per loop
  

  Zauważ, że odejmowanie narzutu jest rozsądne tutaj tylko dlatego, że narzut jest małym ułamkiem czasu.

  Dla Twojego przykładu warto zauważyć, że zarówno sortowanie wstawiania, jak i sortowanie Tim mają zupełnie nietypowe zachowanie czasu dla już posortowanych list. To oznacza, że ty wymaga random.shuffle pomiędzy rodzajami, jeśli chcesz uniknąć niszczenia czasu.

Jeśli chcesz szybko porównać dwa bloki kodu / funkcji, możesz to zrobić:

import timeit

start_time = timeit.default_timer()
func1()
print(timeit.default_timer() - start_time)

start_time = timeit.default_timer()
func2()
print(timeit.default_timer() - start_time)

Najłatwiej jest użyć timeit z linii poleceń:

Given test.py :

def InsertionSort(): ...
def TimSort(): ...

Uruchom czas TAK:

% python -mtimeit -s'import test' 'test.InsertionSort()'
% python -mtimeit -s'import test' 'test.TimSort()'

# Генерация целых чисел

def gen_prime(x):
    multiples = []
    results = []
    for i in range(2, x+1):
        if i not in multiples:
            results.append(i)
            for j in range(i*i, x+1, i):
                multiples.append(j)

    return results


import timeit

# Засекаем время

start_time = timeit.default_timer()
gen_prime(3000)
print(timeit.default_timer() - start_time)

# start_time = timeit.default_timer()
# gen_prime(1001)
# print(timeit.default_timer() - start_time)

Dla mnie to najszybsza droga:

import timeit
def foo():
    print("here is my code to time...")


timeit.timeit(stmt=foo, number=1234567)

To działa świetnie:

  python -m timeit -c "$(cat file_name.py)"

Pozwala ustawić ten sam słownik w każdym z poniższych i przetestować czas wykonania.

Argument setup jest w zasadzie konfiguracją słownika

Liczba ma uruchomić kod 1000000 razy. Nie konfiguracja, ale stmt

Kiedy to uruchomisz, zobaczysz, że indeks jest o wiele szybszy niż get. Możesz uruchomić go wiele razy, aby zobaczyć.

Kod zasadniczo próbuje uzyskać wartość c w słowniku.

import timeit

print('Getting value of C by index:', timeit.timeit(stmt="mydict['c']", setup="mydict={'a':5, 'b':6, 'c':7}", number=1000000))
print('Getting value of C by get:', timeit.timeit(stmt="mydict.get('c')", setup="mydict={'a':5, 'b':6, 'c':7}", number=1000000))

Oto moje wyniki, twoje będą / align = "left" /

By index: 0.20900007452246427

By get: 0.54841166886888

Po prostu podaj cały kod jako argument timeit:

import timeit

print(timeit.timeit("""

limit = 10000
prime_list = [i for i in range(2, limit+1)]

for prime in prime_list:
    for elem in range(prime*2, max(prime_list)+1, prime):
        if elem in prime_list:
            prime_list.remove(elem)"""

, number=10))

Wbudowany Moduł timeit działa najlepiej z linii poleceń IPython.

Do funkcji czasu z modułu:

from timeit import default_timer as timer
import sys

def timefunc(func, *args, **kwargs):
    """Time a function. 

    args:
        iterations=3

    Usage example:
        timeit(myfunc, 1, b=2)
    """
    try:
        iterations = kwargs.pop('iterations')
    except KeyError:
        iterations = 3
    elapsed = sys.maxsize
    for _ in range(iterations):
        start = timer()
        result = func(*args, **kwargs)
        elapsed = min(timer() - start, elapsed)
    print(('Best of {} {}(): {:.9f}'.format(iterations, func.__name__, elapsed)))
    return result

Przykład użycia interpretera Pythona REPL z funkcją akceptującą parametry.

>>> import timeit                                                                                         

>>> def naive_func(x):                                                                                    
...     a = 0                                                                                             
...     for i in range(a):                                                                                
...         a += i                                                                                        
...     return a                                                                                          

>>> def wrapper(func, *args, **kwargs):                                                                   
...     def wrapper():                                                                                    
...         return func(*args, **kwargs)                                                                  
...     return wrapper                                                                                    

>>> wrapped = wrapper(naive_func, 1_000)                                                                  

>>> timeit.timeit(wrapped, number=1_000_000)                                                              
0.4458435332577161                                                                                        

Można utworzyć dwie funkcje, a następnie uruchomić coś podobnego do tego. Zauważ, że chcesz wybrać tę samą liczbę wykonania/uruchomienia, aby porównać apple do apple.
Zostało to przetestowane pod Pythonem 3.7.

Oto kod ułatwiający jego kopiowanie

!/usr/local/bin/python3
import timeit

def fibonacci(n):
    """
    Returns the n-th Fibonacci number.
    """
    if(n == 0):
        result = 0
    elif(n == 1):
        result = 1
    else:
        result = fibonacci(n-1) + fibonacci(n-2)
    return result

if __name__ == '__main__':
    import timeit
    t1 = timeit.Timer("fibonacci(13)", "from __main__ import fibonacci")
    print("fibonacci ran:",t1.timeit(number=1000), "milliseconds")