Messung der verstrichenen Zeit mit dem Modul Time

Question

Ist es möglich, mit dem Time-Modul in Python die verstrichene Zeit zu messen? Wenn ja, wie kann ich das tun?

Ich muss dies tun, so dass, wenn der Cursor in einem Widget für eine bestimmte Dauer ein Ereignis geschieht.

Answer 1

start_time = time.time()
# your code
elapsed_time = time.time() - start_time

Sie können auch einen einfachen Dekorator schreiben, um die Messung der Ausführungszeit der verschiedenen Funktionen zu vereinfachen:

import time
from functools import wraps

PROF_DATA = {}

def profile(fn):
    @wraps(fn)
    def with_profiling(*args, **kwargs):
        start_time = time.time()

        ret = fn(*args, **kwargs)

        elapsed_time = time.time() - start_time

        if fn.__name__ not in PROF_DATA:
            PROF_DATA[fn.__name__] = [0, []]
        PROF_DATA[fn.__name__][0] += 1
        PROF_DATA[fn.__name__][1].append(elapsed_time)

        return ret

    return with_profiling

def print_prof_data():
    for fname, data in PROF_DATA.items():
        max_time = max(data[1])
        avg_time = sum(data[1]) / len(data[1])
        print "Function %s called %d times. " % (fname, data[0]),
        print 'Execution time max: %.3f, average: %.3f' % (max_time, avg_time)

def clear_prof_data():
    global PROF_DATA
    PROF_DATA = {}

Verwendung:

@profile
def your_function(...):
    ...

Sie können mehr als eine Funktion gleichzeitig profilieren. Zum Drucken der Messungen rufen Sie einfach print_prof_data() auf:

Answer 2

time.time() wird die Aufgabe erfüllen.

import time

start = time.time()
# run your code
end = time.time()

elapsed = end - start

Sie sollten sich Folgendes ansehen diese Frage, aber ich glaube nicht, dass das notwendig sein wird.

Answer 3

Für Benutzer, die eine bessere Formatierung wünschen,

import time
start_time = time.time()
# your script
elapsed_time = time.time() - start_time
time.strftime("%H:%M:%S", time.gmtime(elapsed_time))

wird 2 Sekunden lang ausgedruckt:

'00:00:02'

und 7 Minuten lang eine Sekunde:

'00:07:01'

Beachten Sie, dass die minimale Zeiteinheit bei gmtime Sekunden ist. Wenn Sie Mikrosekunden benötigen, sollten Sie Folgendes beachten:

import datetime
start = datetime.datetime.now()
# some code
end = datetime.datetime.now()
elapsed = end - start
print(elapsed)
# or
print(elapsed.seconds,":",elapsed.microseconds) 

strftime Dokumentation

Answer 4

Das beste Maß für die verstrichene Zeit (seit Python 3.3) ist die Verwendung von time.perf_counter() .

Liefert den Wert (in Sekundenbruchteilen) eines Leistungszählers, d. h. einer Uhr mit der höchsten verfügbaren Auflösung zur Messung einer kurzen Dauer. Er enthält die während des Ruhezustands verstrichene Zeit und ist systemweit. Der Bezugspunkt des zurückgegebenen Wertes ist nicht definiert, so dass nur die Differenz zwischen den Ergebnissen aufeinanderfolgender Aufrufe gültig ist.

Für Messungen in der Größenordnung von Stunden/Tagen ist die Auflösung im Subsekundenbereich unwichtig, daher verwenden Sie time.monotonic() stattdessen.

Gibt den Wert (in Sekundenbruchteilen) einer monotonen Uhr zurück, d.h. einer Uhr, die nicht rückwärts gehen kann. Die Uhr wird von Aktualisierungen der Systemuhr nicht beeinflusst. Der Bezugspunkt des zurückgegebenen Wertes ist undefiniert, so dass nur die Differenz zwischen den Ergebnissen aufeinanderfolgender Aufrufe gültig ist.

In vielen Implementierungen kann es sich dabei um ein und dieselbe Sache handeln.

Vor 3.3 müssen Sie sich mit time.clock() .

Unter Unix wird die aktuelle Prozessorzeit als Fließkommazahl in Sekunden zurückgegeben. Die Genauigkeit und sogar die eigentliche Definition der Bedeutung von "Prozessorzeit" hängt von der der gleichnamigen C-Funktion ab.

Unter Windows gibt diese Funktion die seit dem ersten Aufruf dieser Funktion verstrichenen Sekunden als Fließkommazahl zurück, basierend auf der Win32-Funktion QueryPerformanceCounter(). Die Auflösung ist normalerweise besser als eine Mikrosekunde.

---

Aktualisierung für Python 3.7

Neu in Python 3.7 ist PEP 564 -- Hinzufügen neuer Zeitfunktionen mit Nanosekunden-Auflösung.

Damit lassen sich Rundungs- und Fließkommafehler weiter vermeiden, insbesondere wenn Sie sehr kurze Zeiträume messen oder Ihre Anwendung (oder Ihr Windows-Rechner) lange läuft.

Die Auflösung bricht am perf_counter() nach etwa 100 Tagen. So wird z. B. nach einem Jahr Betriebszeit das kürzeste Intervall (größer als 0), das es messen kann, größer sein als zu Beginn.

---

Aktualisierung für Python 3.8

time.clock ist nun verschwunden.

Answer 5

Bei der Programmierung gibt es 2 Hauptarten der Zeitmessung mit unterschiedlichen Ergebnissen:

>>> print(time.process_time()); time.sleep(10); print(time.process_time())
0.11751394000000001
0.11764988400000001  # took  0 seconds and a bit
>>> print(time.perf_counter()); time.sleep(10); print(time.perf_counter())
3972.465770326
3982.468109075       # took 10 seconds and a bit

• Prozessor Zeit : Dies ist die Zeitspanne, die dieser Prozess aktiv auf der CPU ausgeführt wird. Der Ruhezustand, das Warten auf eine Web-Anfrage oder die Zeit, in der nur andere Prozesse ausgeführt werden, tragen nicht dazu bei.

  • Verwenden Sie time.process_time()

• Wanduhr-Zeit : Dies bezieht sich darauf, wie viel Zeit "auf einer an der Wand hängenden Uhr", d.h. außerhalb der Echtzeit, vergangen ist.

  • Verwenden Sie time.perf_counter()

    • time.time() misst auch die Wanduhrzeit, kann aber zurückgesetzt werden, so dass man in der Zeit zurückgehen kann
    • time.monotonic() kann nicht zurückgesetzt werden (monoton = geht nur vorwärts), hat aber eine geringere Genauigkeit als time.perf_counter()