Technologie

Wie kann man in Python die verstrichene Zeit messen?

Melden
  1. Verwendung des time-Moduls
  2. Genauere Messung mit time.perf_counter()
  3. Messung mit dem timeit-Modul
  4. Verwendung als Kontext-Manager mit time.perf_counter()
  5. Zusammenfassung

Die Messung der verstrichenen Zeit in Python ist eine häufige Anforderung, insbesondere wenn man die Laufzeit von Programmen oder einzelnen Codeabschnitten überprüfen möchte. Dabei gibt es unterschiedliche Ansätze und Module, die je nach Genauigkeit und Anwendungsfall genutzt werden können. Im Folgenden werden die gängigsten Methoden ausführlich erläutert.

Verwendung des time-Moduls

Das eingebaute time-Modul bietet einfache Funktionen zur Zeitmessung. Die Funktion time.time() liefert die aktuelle Zeit in Sekunden seit dem sogenannten Unix-Epoche (1. Januar 1970). Um die verstrichene Zeit zu messen, speichert man den Startzeitpunkt vor einem Codeabschnitt und zieht ihn vom Endzeitpunkt danach ab.

Diese Methode eignet sich gut für einfache Anwendungen, bei denen eine Genauigkeit im Bereich von Millisekunden ausreicht. Beispiel:

import timestart = time.time()# Code dessen Laufzeit gemessen werden sollend = time.time()elapsed = end - startprint(f"Verstrichene Zeit: {elapsed} Sekunden")

Genauere Messung mit time.perf_counter()

Für präzisere Messungen empfiehlt sich die Funktion time.perf_counter(). Diese liefert eine hochaufgelöste Zeitmessung, die besonders gut für Performanceanalysen geeignet ist. Die Zeiteinheit ist ebenfalls in Sekunden, jedoch mit höherer Genauigkeit und Monotonie, das heißt, die Zeit läuft immer nur vorwärts und wird nicht durch Systemzeiteinstellungen beeinflusst.

Die Verwendung ist analog zu time.time():

import timestart = time.perf_counter()# Code dessen Laufzeit gemessen werden sollend = time.perf_counter()elapsed = end - startprint(f"Verstrichene Zeit: {elapsed:.6f} Sekunden")

Messung mit dem timeit-Modul

Das Modul timeit ist speziell für zuverlässige und wiederholte Zeitmessungen von kleinen Code-Snippets konzipiert. Es eliminiert einige Messungenauigkeiten, die durch andere Prozesse oder Garbage Collection entstehen können, indem es den Code mehrfach ausführt und einen Durchschnittswert ermittelt.

Die einfachste Anwendung ist die Nutzung der Funktion timeit.timeit():

import timeitelapsed = timeit.timeit("-".join(str(n) for n in range(100)), number=1000)print(f"Verstrichene Zeit: {elapsed} Sekunden für 1000 Durchläufe")

Hierbei wird das angegebene Statement 1000 Mal ausgeführt und die Gesamtdauer zurückgegeben.

Verwendung als Kontext-Manager mit time.perf_counter()

Für bequemes Timing einzelner Codeabschnitte kann man auch einen eigenen Kontext-Manager definieren. Dieser nutzt intern time.perf_counter() und gibt beim Verlassen der mit with markierten Blockstruktur die verstrichene Zeit aus.

Dies erleichtert die Struktur und Lesbarkeit des Codes:

import timeclass Timer: def __enter__(self): self.start = time.perf_counter() return self def __exit__(self, exc_type, exc_val, exc_tb): self.end = time.perf_counter() self.elapsed = self.end - self.start print(f"Verstrichene Zeit: {self.elapsed:.6f} Sekunden")with Timer(): # Code dessen Laufzeit gemessen werden soll sum(range(1000000))

Zusammenfassung

In Python gibt es mehrere Möglichkeiten, die verstrichene Zeit zu messen. Für einfache Fälle ist time.time() ausreichend, während für präzisere Messungen time.perf_counter() die bessere Wahl ist. Das timeit-Modul eignet sich besonders für wiederholte und genaue Benchmarks kleiner Codeabschnitte. Durch die Verwendung von Kontext-Managern kann die Messung zudem einfach und übersichtlich im Code integriert werden.

0

Kommentare