Wie ermittle ich den Zeitpunkt der Ausführung eines Python-Programms?

Question

Ich habe ein Kommandozeilenprogramm in Python, das eine Weile braucht, bis es fertig ist. Ich möchte die genaue Zeit wissen, die es braucht, um die Ausführung zu beenden.

Ich habe mir die timeit Modul, aber es scheint nur für kleine Codeschnipsel geeignet zu sein. Ich möchte die Zeit für das gesamte Programm messen.

Answer 1

Ich mag wirklich Paul McGuire's Antwort aber ich verwende Python 3. Also für diejenigen, die interessiert sind: hier ist eine Modifikation seiner Antwort, die mit Python 3 auf *nix funktioniert (ich nehme an, unter Windows, dass clock() sollte stattdessen verwendet werden 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")

Wenn Sie dies nützlich finden, sollten Sie trotzdem seine Antwort anstelle dieser hoch bewerten, da er die meiste Arbeit geleistet hat ;).

Answer 2

Sie können den Python-Profiler cProfile verwenden, um zu messen CPU-Zeit und zusätzlich, wie viel Zeit innerhalb jeder Funktion verbracht wird und wie oft jede Funktion aufgerufen wird. Dies ist sehr nützlich, wenn Sie die Leistung Ihres Skripts verbessern wollen, ohne zu wissen, wo Sie anfangen sollen. Diese Antwort auf eine andere Stack Overflow-Frage ist ziemlich gut. Es ist immer gut, einen Blick zu werfen in die Dokumentation auch.

Hier ist ein Beispiel, wie man ein Skript mit cProfile von der Kommandozeile aus profiliert:

$ 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}

Answer 3

Verwenden Sie einfach die timeit Modul. Es funktioniert sowohl mit Python 2 als auch mit 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

Die Rückgabe erfolgt in Sekunden, und Sie können die Ausführungszeit selbst bestimmen. Es ist einfach, aber Sie sollten dies in die Hauptfunktion schreiben, die die Programmausführung startet. Wenn Sie die Ausführungszeit auch dann erhalten wollen, wenn ein Fehler auftritt, dann nehmen Sie den Parameter "Start" dazu und berechnen Sie ihn wie folgt:

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

Answer 4

time.clock wurde in Python 3.3 veraltet und wird in Python 3.8 entfernt: verwenden Sie time.perf_counter o time.process_time stattdessen

import time
start_time = time.perf_counter ()
for x in range(1, 100):
    print(x)
end_time = time.perf_counter ()
print(end_time - start_time, "seconds")

Answer 5

time.clock()

Veraltet seit Version 3.3: Das Verhalten dieser Funktion hängt von der von der Plattform ab: Verwenden Sie perf_counter() o process_time() stattdessen, je nach Ihren Anforderungen, um ein genau definiertes Verhalten zu haben.

time.perf_counter()

Gibt den Wert (in Sekundenbruchteilen) eines Leistungszählers zurück, d. h. einer Uhr mit der höchsten verfügbaren Auflösung zur Messung einer kurzen Dauer. Sie hace die während des Schlafs verstrichene Zeit enthalten und systemweit.

time.process_time()

Rückgabe des Wertes (in Bruchteilen von Sekunden) der Summe von System und Benutzer-CPU-Zeit des aktuellen Prozesses. Sie nicht die verstrichene Zeit einschließen während des Schlafs.

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