Jak uzyskać czas na wykonanie programu w języku Python?

Mam program wiersza polecenia w języku Python, którego ukończenie zajmuje trochę czasu. Chcę wiedzieć, ile czasu zajmuje ukończenie biegu.

Patrzyłem na timeitmoduł, ale wygląda na to, że dotyczy tylko małych fragmentów kodu. Chcę zmierzyć czas całego programu.

Najprostszy sposób w Pythonie:

import time
start_time = time.time()
main()
print("--- %s seconds ---" % (time.time() - start_time))

Zakłada się, że uruchomienie programu zajmuje co najmniej jedną dziesiątą sekundy.

Wydruki:

--- 0.764891862869 seconds ---

Umieszczam ten timing.pymoduł w swoim własnym site-packageskatalogu i po prostu wstawiam import timingu góry mojego modułu:

import atexit
from time import clock

def secondsToStr(t):
    return "%d:%02d:%02d.%03d" % \
        reduce(lambda ll,b : divmod(ll[0],b) + ll[1:],
            [(t*1000,),1000,60,60])

line = "="*40
def log(s, elapsed=None):
    print line
    print secondsToStr(clock()), '-', s
    if elapsed:
        print "Elapsed time:", elapsed
    print line
    print

def endlog():
    end = clock()
    elapsed = end-start
    log("End Program", secondsToStr(elapsed))

def now():
    return secondsToStr(clock())

start = clock()
atexit.register(endlog)
log("Start Program")

Mogę również dzwonić timing.logz poziomu mojego programu, jeśli w programie chcę pokazać znaczące etapy. Ale samo włączenie import timingspowoduje wydrukowanie czasu rozpoczęcia i zakończenia oraz ogólnego czasu, który upłynął. (Wybacz mi moją niejasną secondsToStrfunkcję, po prostu formatuje zmiennoprzecinkową liczbę sekund do postaci hh: mm: ss.sss.)

Uwaga: Wersja powyższego kodu w języku Python 3 można znaleźć tutaj lub tutaj .

W systemie Linux lub Unix:

$ time python yourprogram.py

W systemie Windows zobacz to pytanie StackOverflow: Jak zmierzyć czas wykonania polecenia w wierszu polecenia systemu Windows?

Aby uzyskać bardziej szczegółowe dane wyjściowe,

$ time -v python yourprogram.py
    Command being timed: "python3 yourprogram.py"
    User time (seconds): 0.08
    System time (seconds): 0.02
    Percent of CPU this job got: 98%
    Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.10
    Average shared text size (kbytes): 0
    Average unshared data size (kbytes): 0
    Average stack size (kbytes): 0
    Average total size (kbytes): 0
    Maximum resident set size (kbytes): 9480
    Average resident set size (kbytes): 0
    Major (requiring I/O) page faults: 0
    Minor (reclaiming a frame) page faults: 1114
    Voluntary context switches: 0
    Involuntary context switches: 22
    Swaps: 0
    File system inputs: 0
    File system outputs: 0
    Socket messages sent: 0
    Socket messages received: 0
    Signals delivered: 0
    Page size (bytes): 4096
    Exit status: 0

Naprawdę podoba mi się odpowiedź Paula McGuire'a , ale używam Pythona 3. Dla tych, którzy są zainteresowani: oto modyfikacja jego odpowiedzi, która działa z Pythonem 3 na * nix (wyobrażam sobie, pod Windowsem, że clock()powinno się go użyć time()):

#python3
import atexit
from time import time, strftime, localtime
from datetime import timedelta

def secondsToStr(elapsed=None):
    if elapsed is None:
        return strftime("%Y-%m-%d %H:%M:%S", localtime())
    else:
        return str(timedelta(seconds=elapsed))

def log(s, elapsed=None):
    line = "="*40
    print(line)
    print(secondsToStr(), '-', s)
    if elapsed:
        print("Elapsed time:", elapsed)
    print(line)
    print()

def endlog():
    end = time()
    elapsed = end-start
    log("End Program", secondsToStr(elapsed))

start = time()
atexit.register(endlog)
log("Start Program")

Jeśli uznasz to za przydatne, powinieneś nadal głosować na jego odpowiedź zamiast tej, ponieważ wykonał większość pracy;).

import time

start_time = time.clock()
main()
print time.clock() - start_time, "seconds"

time.clock()zwraca czas procesora, co pozwala nam obliczyć tylko czas wykorzystany przez ten proces (w każdym razie na Uniksie). Dokumentacja mówi „w każdym razie jest to funkcja używana do testowania porównawczego Pythona lub algorytmów czasowych”

Podoba mi się wynik dostarczany przez datetimemoduł, w którym obiekty delta czasowej pokazują dni, godziny, minuty itp. W razie potrzeby w sposób czytelny dla człowieka.

Na przykład:

from datetime import datetime
start_time = datetime.now()
# do your work here
end_time = datetime.now()
print('Duration: {}'.format(end_time - start_time))

Przykładowy wynik np

Duration: 0:00:08.309267

lub

Duration: 1 day, 1:51:24.269711

Jak wspomniał JF Sebastian, takie podejście może napotkać pewne trudne przypadki z czasem lokalnym, więc bezpieczniej jest używać:

import time
from datetime import timedelta
start_time = time.monotonic()
end_time = time.monotonic()
print(timedelta(seconds=end_time - start_time))

Możesz użyć profilera cProfile w Pythonie, aby zmierzyć czas procesora, a także ile czasu spędza każda funkcja i ile razy wywoływana jest każda funkcja. Jest to bardzo przydatne, jeśli chcesz poprawić wydajność skryptu, nie wiedząc od czego zacząć. Ta odpowiedź na inne pytanie dotyczące przepełnienia stosu jest całkiem dobra. Zawsze dobrze jest zajrzeć również do dokumentacji .

Oto przykład, jak profilować skrypt za pomocą cProfile z wiersza poleceń:

$ python -m cProfile euler048.py

1007 function calls in 0.061 CPU seconds

Ordered by: standard name
ncalls  tottime  percall  cumtime  percall filename:lineno(function)
    1    0.000    0.000    0.061    0.061 <string>:1(<module>)
 1000    0.051    0.000    0.051    0.000 euler048.py:2(<lambda>)
    1    0.005    0.005    0.061    0.061 euler048.py:2(<module>)
    1    0.000    0.000    0.061    0.061 {execfile}
    1    0.002    0.002    0.053    0.053 {map}
    1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler objects}
    1    0.000    0.000    0.000    0.000 {range}
    1    0.003    0.003    0.003    0.003 {sum}

Jeszcze lepiej dla Linuksa: time

$ time -v python rhtest2.py

    Command being timed: "python rhtest2.py"
    User time (seconds): 4.13
    System time (seconds): 0.07
    Percent of CPU this job got: 91%
    Elapsed (wall clock) time (h:mm:ss or m:ss): 0:04.58
    Average shared text size (kbytes): 0
    Average unshared data size (kbytes): 0
    Average stack size (kbytes): 0
    Average total size (kbytes): 0
    Maximum resident set size (kbytes): 0
    Average resident set size (kbytes): 0
    Major (requiring I/O) page faults: 15
    Minor (reclaiming a frame) page faults: 5095
    Voluntary context switches: 27
    Involuntary context switches: 279
    Swaps: 0
    File system inputs: 0
    File system outputs: 0
    Socket messages sent: 0
    Socket messages received: 0
    Signals delivered: 0
    Page size (bytes): 4096
    Exit status: 0

zegar()

Przestarzałe od wersji 3.3: Zachowanie tej funkcji zależy od platformy: zamiast tego użyj perf_counter () lub process_time () , w zależności od wymagań, aby mieć dobrze zdefiniowane zachowanie.

time.perf_counter ()

Zwraca wartość (w ułamkach sekund) licznika wydajności, tj. Zegara o najwyższej dostępnej rozdzielczości do pomiaru krótkotrwałego. To jest to czas, który upłynął podczas snu i jest w całym systemie.

time.process_time ()

Zwraca wartość (w ułamkach sekund) sumy czasu systemowego i procesora użytkownika bieżącego procesu. To nie obejmuje czasu, który upłynął podczas snu.

start = time.process_time()
... do something
elapsed = (time.process_time() - start)

Po prostu użyj timeitmodułu. Działa zarówno z Python 2, jak i Python 3.

import timeit

start = timeit.default_timer()

# All the program statements
stop = timeit.default_timer()
execution_time = stop - start

print("Program Executed in "+str(execution_time)) # It returns time in seconds

Zwraca się w ciągu kilku sekund i możesz mieć swój czas wykonania. Jest to proste, ale należy je zapisać w głównej funkcji ww, która rozpoczyna wykonywanie programu. Jeśli chcesz uzyskać czas wykonania, nawet jeśli wystąpi błąd, weź do niego parametr „Start” i oblicz tam:

def sample_function(start,**kwargs):
     try:
         # Your statements
     except:
         # except statements run when your statements raise an exception
         stop = timeit.default_timer()
         execution_time = stop - start
         print("Program executed in " + str(execution_time))

Poniższy fragment drukuje upływający czas w przyjemnym dla człowieka <HH:MM:SS>formacie.

import time
from datetime import timedelta

start_time = time.time()

#
# Perform lots of computations.
#

elapsed_time_secs = time.time() - start_time

msg = "Execution took: %s secs (Wall clock time)" % timedelta(seconds=round(elapsed_time_secs))

print(msg)    

from time import time
start_time = time()
...
end_time = time()
time_taken = end_time - start_time # time_taken is in seconds
hours, rest = divmod(time_taken,3600)
minutes, seconds = divmod(rest, 60)

W IPython „timeit” dowolny skrypt:

def foo():
    %run bar.py
timeit foo()

Przyjrzałem się modułowi timeit, ale wygląda na to, że dotyczy tylko małych fragmentów kodu. Chcę zmierzyć czas całego programu.

$ python -mtimeit -n1 -r1 -t -s "from your_module import main" "main()"

Działa your_module.main()jednorazowo i drukuje upływający czas za pomocątime.time() funkcji jako timera.

Aby emulować /usr/bin/timew Pythonie, zobacz podprocesor Pythona w / usr / bin / time: jak przechwytywać informacje o taktowaniu, ale ignorować wszystkie inne dane wyjściowe? .

Aby zmierzyć czas procesora (np. Nie uwzględniaj czasu podczas time.sleep()) dla każdej funkcji, możesz użyć profilemodułu ( cProfilew Pythonie 2):

$ python3 -mprofile your_module.py

Możesz przejść -pdo timeitpowyższego polecenia, jeśli chcesz używać tego samego timera profile, którego używa moduł.

Zobacz Jak profilować skrypt w języku Python?

Podobało mi się również odpowiedź Paula McGuire'a i wymyśliłem formularz menedżera kontekstu, który bardziej odpowiada moim potrzebom.

import datetime as dt
import timeit

class TimingManager(object):
    """Context Manager used with the statement 'with' to time some execution.

    Example:

    with TimingManager() as t:
       # Code to time
    """

    clock = timeit.default_timer

    def __enter__(self):
        """
        """
        self.start = self.clock()
        self.log('\n=> Start Timing: {}')

        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        """
        """
        self.endlog()

        return False

    def log(self, s, elapsed=None):
        """Log current time and elapsed time if present.
        :param s: Text to display, use '{}' to format the text with
            the current time.
        :param elapsed: Elapsed time to display. Dafault: None, no display.
        """
        print s.format(self._secondsToStr(self.clock()))

        if(elapsed is not None):
            print 'Elapsed time: {}\n'.format(elapsed)

    def endlog(self):
        """Log time for the end of execution with elapsed time.
        """
        self.log('=> End Timing: {}', self.now())

    def now(self):
        """Return current elapsed time as hh:mm:ss string.
        :return: String.
        """
        return str(dt.timedelta(seconds = self.clock() - self.start))

    def _secondsToStr(self, sec):
        """Convert timestamp to h:mm:ss string.
        :param sec: Timestamp.
        """
        return str(dt.datetime.fromtimestamp(sec))

Dla osób korzystających z Notatnika Jupyter

W komórce możesz użyć %%timemagicznego polecenia Jupytera, aby zmierzyć czas wykonania:

%%time
[ x**2 for x in range(10000)]

Wynik

CPU times: user 4.54 ms, sys: 0 ns, total: 4.54 ms
Wall time: 4.12 ms

Spowoduje to tylko przechwycenie czasu wykonania określonej komórki. Jeśli chcesz uchwycić czas wykonania całego notesu (tj. Programu), możesz utworzyć nowy notes w tym samym katalogu i w nowym notesie wykonać wszystkie komórki:

Załóżmy, że powyższy notatnik jest nazywany example_notebook.ipynb. W nowym notatniku w tym samym katalogu:

# Convert your notebook to a .py script:
!jupyter nbconvert --to script example_notebook.ipynb

# Run the example_notebook with -t flag for time
%run -t example_notebook

Wynik

IPython CPU timings (estimated):
  User   :       0.00 s.
  System :       0.00 s.
Wall time:       0.00 s.

Istnieje timeitmoduł, którego można użyć do pomiaru czasu wykonania kodu Python.

Ma szczegółową dokumentację i przykłady w dokumentacji Pythona, 26.6. timeit - Mierzy czas wykonania małych fragmentów kodu .

Użyj line_profiler .

line_profiler będzie profilował czas wykonywania poszczególnych linii kodu. Profiler jest zaimplementowany w C przez Cython w celu zmniejszenia narzutu związanego z profilowaniem.

from line_profiler import LineProfiler
import random

def do_stuff(numbers):
    s = sum(numbers)
    l = [numbers[i]/43 for i in range(len(numbers))]
    m = ['hello'+str(numbers[i]) for i in range(len(numbers))]

numbers = [random.randint(1,100) for i in range(1000)]
lp = LineProfiler()
lp_wrapper = lp(do_stuff)
lp_wrapper(numbers)
lp.print_stats()

Wyniki będą:

Timer unit: 1e-06 s

Total time: 0.000649 s
File: <ipython-input-2-2e060b054fea>
Function: do_stuff at line 4

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
     4                                           def do_stuff(numbers):
     5         1           10     10.0      1.5      s = sum(numbers)
     6         1          186    186.0     28.7      l = [numbers[i]/43 for i in range(len(numbers))]
     7         1          453    453.0     69.8      m = ['hello'+str(numbers[i]) for i in range(len(numbers))]

Użyłem bardzo prostej funkcji do pomiaru czasu wykonania kodu:

import time
def timing():
    start_time = time.time()
    return lambda x: print("[{:.2f}s] {}".format(time.time() - start_time, x))

I aby go użyć, po prostu wywołaj go przed kodem, aby zmierzyć, aby pobrać czas funkcji, a następnie wywołaj funkcję po kodzie z komentarzami. Czas pojawi się przed komentarzami. Na przykład:

t = timing()
train = pd.read_csv('train.csv',
                        dtype={
                            'id': str,
                            'vendor_id': str,
                            'pickup_datetime': str,
                            'dropoff_datetime': str,
                            'passenger_count': int,
                            'pickup_longitude': np.float64,
                            'pickup_latitude': np.float64,
                            'dropoff_longitude': np.float64,
                            'dropoff_latitude': np.float64,
                            'store_and_fwd_flag': str,
                            'trip_duration': int,
                        },
                        parse_dates = ['pickup_datetime', 'dropoff_datetime'],
                   )
t("Loaded {} rows data from 'train'".format(len(train)))

Następnie dane wyjściowe będą wyglądać następująco:

[9.35s] Loaded 1458644 rows data from 'train'

Miałem ten sam problem w wielu miejscach, więc stworzyłem pakiet wygody horology. Możesz go zainstalować, pip install horologya następnie zrobić to w elegancki sposób:

from horology import Timing

with Timing(name='Important calculations: '):
    prepare()
    do_your_stuff()
    finish_sth()

wyświetli:

Important calculations: 12.43 ms

Lub nawet prościej (jeśli masz jedną funkcję):

from horology import timed

@timed
def main():
    ...

wyświetli:

main: 7.12 h

Dba o jednostki i zaokrąglanie. Działa z Pythonem 3.6 lub nowszym.

To jest odpowiedź Paula McGuire'a, która działa dla mnie. Na wypadek, gdyby ktoś miał problem z uruchomieniem tego.

import atexit
from time import clock

def reduce(function, iterable, initializer=None):
    it = iter(iterable)
    if initializer is None:
        value = next(it)
    else:
        value = initializer
    for element in it:
        value = function(value, element)
    return value

def secondsToStr(t):
    return "%d:%02d:%02d.%03d" % \
        reduce(lambda ll,b : divmod(ll[0],b) + ll[1:],
            [(t*1000,),1000,60,60])

line = "="*40
def log(s, elapsed=None):
    print (line)
    print (secondsToStr(clock()), '-', s)
    if elapsed:
        print ("Elapsed time:", elapsed)
    print (line)

def endlog():
    end = clock()
    elapsed = end-start
    log("End Program", secondsToStr(elapsed))

def now():
    return secondsToStr(clock())

def main():
    start = clock()
    atexit.register(endlog)
    log("Start Program")

Zadzwoń timing.main()z twojego programu po zaimportowaniu pliku.

Timeit to klasa w Pythonie używana do obliczania czasu wykonywania małych bloków kodu.

Default_timer to metoda w tej klasie, która służy do pomiaru taktowania zegara ściennego, a nie czasu wykonywania procesora. W związku z tym inne wykonywanie procesu może mieć na to wpływ. Jest więc przydatny w przypadku małych bloków kodu.

Przykładowy kod jest następujący:

from timeit import default_timer as timer

start= timer()

# Some logic

end = timer()

print("Time taken:", end-start)

Późniejsza odpowiedź, ale używam timeit:

import timeit
code_to_test = """
a = range(100000)
b = []
for i in a:
    b.append(i*2)
"""
elapsed_time = timeit.timeit(code_to_test, number=500)
print(elapsed_time)
# 10.159821493085474

• Zawiń w środku cały kod, w tym wszelkie importowane pliki code_to_test.
• number argument określa liczbę powtórzeń kodu.
• Próbny

Czas wykonania programu w języku Python może być niespójny w zależności od:

• Ten sam program można ocenić przy użyciu różnych algorytmów
• Czas działania różni się w zależności od algorytmu
• Czas działania zależy od implementacji
• Czas działania zależy od komputera
• Czas pracy nie jest przewidywalny na podstawie niewielkich nakładów

Wynika to z tego, że najskuteczniejszym sposobem jest użycie „Porządku wzrostu” i nauka dużej notacji „O” aby zrobić to poprawnie.

W każdym razie możesz spróbować ocenić wydajność dowolnego programu w języku Python w określonych krokach liczenia maszyn na sekundę za pomocą tego prostego algorytmu: dostosuj to do programu, który chcesz ocenić

import time

now = time.time()
future = now + 10
step = 4 # Why 4 steps? Because until here already four operations executed
while time.time() < future:
    step += 3 # Why 3 again? Because a while loop executes one comparison and one plus equal statement
step += 4 # Why 3 more? Because one comparison starting while when time is over plus the final assignment of step + 1 and print statement
print(str(int(step / 10)) + " steps per second")

Robisz to po prostu w Pythonie. Nie trzeba tego komplikować.

import time

start = time.localtime()
end = time.localtime()
"""Total execution time in seconds$ """
print(end.tm_sec - start.tm_sec)

Podobnie do odpowiedzi z @rogeriopvl dodałem niewielką modyfikację, aby przekonwertować na godziny i minuty, używając tej samej biblioteki dla zadań długo działających.

import time
start_time = time.time()
main()
seconds = time.time() - start_time
print('Time Taken:', time.strftime("%H:%M:%S",time.gmtime(seconds)))

Przykładowe dane wyjściowe

Time Taken: 00:00:08

Najpierw należy zainstalować humanfriendly pakiet otwierając wiersza poleceń (cmd) jako administrator i wpisz tam - pip install humanfriendly

Kod:

from humanfriendly import format_timespan
import time
begin_time = time.time()
# Put your code here
end_time = time.time() - begin_time
print("Total execution time: ", format_timespan(end_time))

Wynik:

Aby użyć zaktualizowanej odpowiedzi metakermita dla Pythona 2.7, będziesz potrzebować pakietu monotonicznego .

Kod wyglądałby następująco:

from datetime import timedelta
from monotonic import monotonic

start_time = monotonic()
end_time = monotonic()
print(timedelta(seconds=end_time - start_time))

Próbowałem i znalazłem różnicę czasu przy użyciu następujących skryptów.

import time

start_time = time.perf_counter()
[main code here]
print (time.perf_counter() - start_time, "seconds")

Jeśli chcesz mierzyć czas w mikrosekundach, możesz użyć następującej wersji, całkowicie opartej na odpowiedziach Paula McGuire'a i Nicojo - jest to kod Python 3. Dodałem też trochę koloru:

import atexit
from time import time
from datetime import timedelta, datetime


def seconds_to_str(elapsed=None):
    if elapsed is None:
        return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
    else:
        return str(timedelta(seconds=elapsed))


def log(txt, elapsed=None):
    colour_cyan = '\033[36m'
    colour_reset = '\033[0;0;39m'
    colour_red = '\033[31m'
    print('\n ' + colour_cyan + '  [TIMING]> [' + seconds_to_str() + '] ----> ' + txt + '\n' + colour_reset)
    if elapsed:
        print("\n " + colour_red + " [TIMING]> Elapsed time ==> " + elapsed + "\n" + colour_reset)


def end_log():
    end = time()
    elapsed = end-start
    log("End Program", seconds_to_str(elapsed))


start = time()
atexit.register(end_log)
log("Start Program")

log () => funkcja drukująca informacje o taktowaniu.

txt ==> pierwszy argument do zalogowania i jego ciąg do oznaczenia czasu.

atexit ==> moduł Pythona do rejestrowania funkcji, które można wywołać po wyjściu z programu.