Wie messe ich die Zeit zwischen Codezeilen in Python?

In Java können wir also die Zeit messen, die eine Funktion zur Ausführung benötigt

Aber wie geht das in Python? Um die Start- und Endzeit zwischen Codezeilen zu messen? Etwas, das dies tut:

import some_time_library

starttime = some_time_library.some_module()
code_tobe_measured() 
endtime = some_time_library.some_module()

time_taken = endtime - starttime

Wenn Sie die CPU-Zeit messen möchten, können Sie time.process_time()Python 3.3 und höher verwenden:

import time
start = time.process_time()
# your code here    
print(time.process_time() - start)

Der erste Anruf schaltet den Timer ein und der zweite Anruf zeigt an, wie viele Sekunden vergangen sind.

Es gibt auch eine Funktion time.clock(), die jedoch seit Python 3.3 veraltet ist und in Python 3.8 entfernt wird.

Es gibt bessere Profiling-Tools wie timeitund profilejedoch misst time.process_time () die CPU-Zeit und das ist es, wonach Sie fragen.

Wenn Sie stattdessen die Wanduhrzeit messen möchten, verwenden Sie time.time().

Sie können auch die timeBibliothek verwenden:

import time

start = time.time()

# your code

# end

print(f'Time: {time.time() - start}')

Mithilfe einer kleinen Convenience-Klasse können Sie die Zeit messen , die Sie in eingerückten Zeilen wie folgt verbringen :

with CodeTimer():
   line_to_measure()
   another_line()
   # etc...

Nach Abschluss der Ausführung der eingerückten Zeile (n) wird Folgendes angezeigt:

Code block took: x.xxx ms

UPDATE: Sie können jetzt die Klasse mit pip install linetimerund dann bekommen from linetimer import CodeTimer. Siehe dieses GitHub-Projekt .

Der Code für die obige Klasse:

import timeit

class CodeTimer:
    def __init__(self, name=None):
        self.name = " '"  + name + "'" if name else ''

    def __enter__(self):
        self.start = timeit.default_timer()

    def __exit__(self, exc_type, exc_value, traceback):
        self.took = (timeit.default_timer() - self.start) * 1000.0
        print('Code block' + self.name + ' took: ' + str(self.took) + ' ms')

Sie können dann die Codeblöcke benennen, die Sie messen möchten:

with CodeTimer('loop 1'):
   for i in range(100000):
      pass

with CodeTimer('loop 2'):
   for i in range(100000):
      pass

Code block 'loop 1' took: 4.991 ms
Code block 'loop 2' took: 3.666 ms

Und niste sie:

with CodeTimer('Outer'):
   for i in range(100000):
      pass

   with CodeTimer('Inner'):
      for i in range(100000):
         pass

   for i in range(100000):
      pass

Code block 'Inner' took: 2.382 ms
Code block 'Outer' took: 10.466 ms

In dieser Antworttimeit.default_timer() wird der beste Timer verwendet, der auf dem Betriebssystem und der Python-Version basiert .

Ich bevorzuge es immer, die Zeit in Stunden, Minuten und Sekunden (% H:% M:% S) zu überprüfen:

from datetime import datetime
start = datetime.now()
# your code
end = datetime.now()
time_taken = end - start
print('Time: ',time_taken) 

Ausgabe:

Time:  0:00:00.000019

Ich suchte nach einer Möglichkeit, eine formatierte Zeit mit minimalem Code auszugeben. Hier ist meine Lösung. Viele Leute verwenden Pandas sowieso, so dass in einigen Fällen zusätzliche Bibliotheksimporte vermieden werden können.

import pandas as pd
start = pd.Timestamp.now()
# code
print(pd.Timestamp.now()-start)

Ausgabe:

0 days 00:05:32.541600

Ich würde empfehlen, dies zu verwenden, wenn die Zeitgenauigkeit nicht am wichtigsten ist, andernfalls verwenden Sie die timeBibliothek:

%timeit pd.Timestamp.now() gibt 3,29 µs ± 214 ns pro Schleife aus

%timeit time.time() gibt 154 ns ± 13,3 ns pro Schleife aus

Sie können dies auch versuchen:

from time import perf_counter

t0 = perf_counter()

...

t1 = perf_counter()
time_taken = t1 - t0

Eine weitere Option besteht darin, den Code in eine Funktion einzufügen und dann einen Dekorator für das Timing zu verwenden. ( Quelle ) Der Vorteil dieser Methode ist, dass Sie den Timer einmal definieren und ihn mit einer einfachen zusätzlichen Zeile für jede Funktion verwenden.

Definieren Sie zunächst den timerDekorateur:

import functools
import time

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.perf_counter()
        value = func(*args, **kwargs)
        end_time = time.perf_counter()
        run_time = end_time - start_time
        print("Finished {} in {} secs".format(repr(func.__name__), round(run_time, 3)))
        return value

    return wrapper

Verwenden Sie dann den Dekorator, während Sie die Funktion definieren:

@timer
def doubled_and_add(num):
    res = sum([i*2 for i in range(num)])
    print("Result : {}".format(res))

Lass es uns versuchen:

doubled_and_add(100000)
doubled_and_add(1000000)

Ausgabe:

Result : 9999900000
Finished 'doubled_and_add' in 0.0119 secs
Result : 999999000000
Finished 'doubled_and_add' in 0.0897 secs

Hinweis: Ich bin mir nicht sicher, warum ich time.perf_counterstattdessen verwenden soll time.time. Kommentare sind willkommen.