Memo zur Messung der Python-Ausführungszeit

Plötzliche Schlussfolgerung

Immerhin ist "perf_counter ()" sicher. Es ist nichts Neues, daher ist es möglicherweise nicht lesenswert.

Angenommener Leser

Vielleicht haben Sie die Ausführungsgeschwindigkeit mit Python gemessen, aber nicht eingehend untersucht.

Der Grund für die Untersuchung

Ich habe versehentlich "time.time ()" verwendet, um die Ausführungszeit zu messen. Es war genug, weil ich mich nicht um die Genauigkeit kümmern musste, aber als ich die Ausführungsreihenfolge der Funktionen änderte, die unabhängig sein sollten, änderte sich die Ausführungszeit erheblich. Die Ursache hierfür ist unbekannt, aber ich habe mich daher entschlossen, die Zeitmessung erneut zu untersuchen. (Ich habe es aufgegeben herauszufinden, warum die Funktion selbst nicht praktisch war. Vielleicht wirkt sich die Speicherbereinigung darauf aus.)

Umgebung

Windows 10 Pro 64bit Python 3.8.3

Zeit Modul

Betrachten Sie nur das "Zeit" -Modul, das die Standardbibliothek ist

Eine Funktion zum Messen der Ausführungszeit zwischen zwei Punkten

Die Funktionen, die im Modul "Zeit" zum Messen der Ausführungszeit verwendet werden können, sind wie folgt. Es ist "monoton = wahr", wenn es mit "time.get_clock_info ()" überprüft wird. Mit anderen Worten, es wird garantiert, dass es nicht aufgrund externer Faktoren abgezogen wird.

Ich denke, was Sie unter "hoher (niedriger)" Auflösung verstehen, ist, dass die von "time.get_clock_info ()" erhaltenen Spezifikationen eine hohe Auflösung haben, aber wenn Sie sie tatsächlich verschieben, ist sie niedrig. Da es sich um eine Auflösung handelt, ist sie so geschrieben. Dies kann durch Ihre Entwicklungsumgebung beeinflusst werden.

Eine kleine Erklärung lautet wie folgt.

Mit perf_counter () wird gemessen, wie viel Echtzeit seit der Ausführung des Programms vergangen ist. Da die verstrichene Zeit während des Schlafes ebenfalls enthalten ist, besteht die Möglichkeit, dass die beabsichtigte Zeit nicht herauskommt. Es scheint jedoch das stabilste zu sein. Es scheint sicher zu sein, dies zu verwenden, z. B. auf den Standard-Timer mit Timeit usw. eingestellt zu sein.

process_time () oder thread_time () wird verwendet, um herauszufinden, wie lange ein Programm in einem Prozess (Thread) ausgeführt wurde. Ich denke, viele Menschen, auch ich, möchten diese Zeit messen. Die tatsächliche Auflösung scheint jedoch niedriger als die Spezifikationen zu sein. Ich möchte das wirklich nutzen, aber ich zögere, es zu benutzen. Auch im Fall von Windows verwende ich tatsächlich C'GetProcessTimes () `, aber in der Erklärung dazu,

text

Note that this value can exceed the amount of real time elapsed (between lpCreationTime and lpExitTime) if the process executes across multiple CPU cores.

ist was es liest. Es scheint nicht sehr zuverlässig zu sein.

monotonic () wird verwendet, um die Betriebszeit des Systems herauszufinden. Mit anderen Worten, dieser PC wird verwendet, um herauszufinden, wie viele Tage seit seiner Inbetriebnahme vergangen sind. Ich glaube nicht, dass ich es oft benutze.

time () erhält die Zeit und wird nicht zum Messen der Ausführungszeit verwendet.

Auswirkungen der Speicherbereinigung

Die Speicherbereinigung scheint die Geschwindigkeit der Programmausführung zu beeinflussen. Das unten beschriebene timeit () stoppt die Speicherbereinigung als Standardverhalten, um deren Auswirkungen zu vermeiden. Wenn Sie den Effekt der Speicherbereinigung von der Messung ausschließen möchten, müssen Sie die Speicherbereinigung stoppen. Die Methode besteht darin, wie folgt zu schreiben.

python

import gc

gc.disable() #Halt
#Messverarbeitung
gc.enable() #Fortsetzen

Wie benutzt man

Es ist einfach, das "Zeit" -Modul zu verwenden, aber Sie müssen sich nur die Zeit nehmen, bevor und nachdem Sie es messen und subtrahieren möchten, wie unten gezeigt.

python

import time
import timeit

def stopwatchPrint(func):

  @functools.wraps(func)
  def wrapper(*args, **kwargs):
    start = time.perf_counter()
    result = func(*args, **kwargs)
    end = time.perf_counter()
    print(f"{func.__name__}: {end - start:.3f} s.")
    return result

  return wrapper

@stopwatchPrint
def func1():
  #Etwas verarbeiten
  return

def func2():
  start = time.perf_counter()
  #Etwas verarbeiten
  end = time.perf_counter()
  print(f"Ausführungszeit: {end - start}"
  return

timeit Modul

Grundsätzlich gibt es kein Problem, wenn Sie "Zeit" wie oben verwenden. Die Standardbibliothek bietet jedoch auch "Zeit" zum Messen der Ausführungsgeschwindigkeit. Die meisten von ihnen rufen einfach "time.perf_counter ()" auf, aber ich werde es kurz erklären. Ich werde nicht darauf eingehen, wie man es über die Kommandozeile benutzt. Ich habe zwei Funktionen aufgelistet, aber ich denke, Sie sollten nur "timeit.repeat ()" verwenden.

python

import time
import timeit

timeit.timeit(stmt=func1, setup=func2, timer=time.time.perf_counter, number=1000000)
timeit.repeat(stmt=func1, setup=func2, timer=time.time.perf_counter, number=1000000, repeat=5)

• timeit(): --stmt: Übergibt die Funktion, deren Ausführungszeit Sie messen möchten, oder eine Zeichenfolge, die als Ausdruck ausgewertet werden kann. Wenn es sich um eine Zeichenfolge handelt, wird sie von "eval ()" ausgewertet. --setup: Übergibt eine Funktion, die eine Vorverarbeitung ausführt, oder eine Zeichenfolge, die als Ausdruck ausgewertet werden kann. Die Ausführungszeit hierfür ist nicht im Messwert enthalten. --timer: Übergeben Sie die für die Messung verwendete Timer-Funktion. Der Standardwert ist "time.time.perf_counter". Sie können time.process_time usw. übergeben. --number: Anzahl der Hinrichtungen. Der Standardwert ist "1000000". --globals: Geben Sie den Namespace an. Der Standardwert ist "Keine". Wenn Sie es ändern möchten, geben Sie "globals = globals ()" oder "globals = Locals ()" an. --repeat (): Eine sich wiederholende Version von time it. Zusätzlich zum Argument der "Zeit" hat es Folgendes. -- wiederholen: Anzahl der Wiederholungen. Wenn "number = 100" und "repeat = 3" sind, werden die 100 Ausführungen dreimal wiederholt.

Wie benutzt man

Tatsächlich wird es wie folgt verwendet. result ist eine Liste von 3 Längen, die verstrichen sind, wenn ein Element longLongLongCat () 100 Mal ausführt.

python

def longLongLongCat(): #Funktion, die Zeit messen will
   pass

result = timeit.repeat(longLongLongCat, ,number=100, repeat=3)
print(result)

Übergeben Sie Argumente an die Ausführungsfunktion "timeit"

Die Ausführungsfunktion "timeit" ist nicht dafür ausgelegt, Argumente zu übergeben. Es mag eine Voraussetzung sein, mit einer Zeichenfolge zu arbeiten, aber es gibt Widerstand, sie als Standard zu verwenden. Deshalb habe ich verschiedene Dinge ausprobiert. Es kann andere gute Wege geben.

python

import math
import timeit
import functools

def func():
  print("func")

def funcN(n):
  print(f"funcN: {n}")

class Test():
  def __init__(self, n=100, r=3):
    self.number = n
    self.repeat = r

  def glo(self):
    #print(globals())
    #print(locals())
    result = timeit.repeat("print(a, b)", number=self.number, repeat=self.repeat, globals=globals())
    print(result)

  def loc(self):
    a = 33
    b = 4
    #print(globals())
    #print(locals())
    result = timeit.repeat("print(a, b)", number=self.number, repeat=self.repeat, globals=locals())
    print(result)

  def mix(self):
    a = 33
    b = 44
    #print(globals())
    #print(locals())
    result = timeit.repeat("print(a , b)", number=self.number, repeat=self.repeat, globals={"a": 30, "b": 50})
    print(result)
    result = timeit.repeat("print(a , b)", number=self.number, repeat=self.repeat, globals={
        "a": globals()["a"],
        "b": locals()["b"]
    })
    print(result)

a = 2525
b = 2828
t = Test(1, 1)
t.glo()
t.loc()
t.mix()

timeit.repeat(func, number=1, repeat=1)
timeit.repeat(lambda: print(a, b), number=1, repeat=1)
n = 1129
timeit.repeat("funcN(n)", number=1, repeat=1, globals=globals())
timeit.repeat("funcN(n)", number=1, repeat=1, globals={"funcN": funcN, "n": 714})
g = globals()
g.update({"n": 1374})
timeit.repeat("funcN(n)", number=1, repeat=1, globals=g)
timeit.repeat(functools.partial(funcN, 184), number=1, repeat=1)

Ausgabeergebnis

shell

2525 2828
[0.001136100000000001]
33 4
[0.026095200000000013]
30 50
[0.01867479999999999]
2525 44
[0.001263299999999995]
func
2525 2828
funcN: 1129
funcN: 714
funcN: 1374
funcN: 184

Uhr Informationen

Informationen in Ihrer eigenen Umgebung.

shell

>>> time.get_clock_info("monotonic")
namespace(adjustable=False, implementation='GetTickCount64()', monotonic=True, resolution=0.015625)

>>> time.get_clock_info("perf_counter")
namespace(adjustable=False, implementation='QueryPerformanceCounter()', monotonic=True, resolution=1e-07)

>>> time.get_clock_info("process_time")
namespace(adjustable=False, implementation='GetProcessTimes()', monotonic=True, resolution=1e-07)

>>> time.get_clock_info("thread_time")
namespace(adjustable=False, implementation='GetThreadTimes()', monotonic=True, resolution=1e-07)

>>> time.get_clock_info("time")
namespace(adjustable=True, implementation='GetSystemTimeAsFileTime()', monotonic=False, resolution=0.015625)