Pythons Genauigkeit time.clock () vs. time.time ()?

Welches ist besser für das Timing in Python zu verwenden? time.clock () oder time.time ()? Welches bietet mehr Genauigkeit?

zum Beispiel:

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

vs.

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

Ab 3.3 ist time.clock () veraltet und es wird empfohlen, stattdessen time.process_time () oder time.perf_counter () zu verwenden.

Zuvor in 2.7 laut Zeitmodul docs :

Zeit Uhr()

Geben Sie unter Unix die aktuelle Prozessorzeit als Gleitkommazahl in Sekunden zurück. Die Genauigkeit und tatsächlich die Definition der Bedeutung von „Prozessorzeit“ hängt von der gleichnamigen C-Funktion ab. In jedem Fall ist dies jedoch die Funktion, die zum Benchmarking von Python- oder Timing-Algorithmen verwendet wird.

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

Zusätzlich gibt es das Timeit- Modul zum Benchmarking von Code-Snippets.

Die kurze Antwort lautet: Meistens time.clock()wird es besser. Wenn Sie jedoch Hardware planen (z. B. einen Algorithmus, den Sie in die GPU eingefügt haben), time.clock()wird diese Zeit entfallen und es time.time()ist die einzige verbleibende Lösung.

Hinweis: Unabhängig von der verwendeten Methode hängt das Timing von Faktoren ab, die Sie nicht steuern können (wann wechselt der Prozess, wie oft, ...). Dies ist schlimmer time.time(), existiert aber auch bei time.clock(), sodass Sie niemals nur einen Timing-Test durchführen sollten. Führen Sie jedoch immer eine Reihe von Tests durch und betrachten Sie den Mittelwert / die Varianz der Zeiten.

Andere : haben re beantwortet time.time()vs. time.clock().

Wenn Sie jedoch die Ausführung eines Codeblocks für Benchmarking- / Profilierungszwecke planen, sollten Sie sich das timeitModul ansehen .

Eine Sache zu beachten: Das Ändern der Systemzeit wirkt sich aus, time.time()aber nicht time.clock().

Ich musste einige automatische Testausführungen steuern. Wenn ein Schritt des Testfalls mehr als eine bestimmte Zeit in Anspruch nahm, wurde dieser TC abgebrochen, um mit dem nächsten fortzufahren.

Manchmal war jedoch ein Schritt erforderlich, um die Systemzeit zu ändern (um das Scheduler-Modul der zu testenden Anwendung zu überprüfen). Nachdem die Systemzeit einige Stunden in der Zukunft eingestellt wurde, lief das TC-Zeitlimit ab und der Testfall wurde abgebrochen. Ich hatte von wechseln , time.time()um time.clock()diese richtig zu handhaben .

clock() -> Gleitkommazahl

Gibt die CPU-Zeit oder Echtzeit seit dem Start des Prozesses oder seit dem ersten Aufruf von zurück clock(). Dies ist genauso präzise wie das System aufzeichnet.

time() -> Gleitkommazahl

Gibt die aktuelle Zeit in Sekunden seit der Epoche zurück. Sekundenbruchteile können vorhanden sein, wenn die Systemuhr sie bereitstellt.

In der Regel time()ist dies genauer, da Betriebssysteme die Prozesslaufzeit nicht mit der Genauigkeit speichern, mit der sie die Systemzeit speichern (dh die tatsächliche Zeit).

Kommt darauf an, was dich interessiert. Wenn Sie WALL TIME (wie in, die Zeit auf der Uhr an Ihrer Wand) meinen, liefert time.clock () KEINE Genauigkeit, da es möglicherweise die CPU-Zeit verwaltet.

time()hat eine bessere Präzision als clock()unter Linux. clock()hat nur eine Genauigkeit von weniger als 10 ms. Während time()gibt Präfekten Präzision. Mein Test ist auf CentOS 6.4 2. Python 2.6

using time():

1 requests, response time: 14.1749382019 ms
2 requests, response time: 8.01301002502 ms
3 requests, response time: 8.01491737366 ms
4 requests, response time: 8.41021537781 ms
5 requests, response time: 8.38804244995 ms

using clock():

1 requests, response time: 10.0 ms
2 requests, response time: 0.0 ms 
3 requests, response time: 0.0 ms
4 requests, response time: 10.0 ms
5 requests, response time: 0.0 ms 
6 requests, response time: 0.0 ms
7 requests, response time: 0.0 ms 
8 requests, response time: 0.0 ms

Der Unterschied ist sehr plattformspezifisch.

clock () unterscheidet sich beispielsweise unter Windows erheblich von Linux.

Für die Art von Beispielen, die Sie beschreiben, möchten Sie wahrscheinlich stattdessen das Modul "timeit".

Wie andere haben darauf hingewiesen , time.clock()für veraltet ist time.perf_counter()oder time.process_time()aber Python 3.7 einleitet Nanosekunde Auflösung Timing mit time.perf_counter_ns(), time.process_time_ns()und time.time_ns(), zusammen mit drei anderen Funktionen.

Diese 6 neuen Funktionen zur Auflösung von Nanosekunden sind in PEP 564 beschrieben :

time.clock_gettime_ns(clock_id)

time.clock_settime_ns(clock_id, time:int)

time.monotonic_ns()

time.perf_counter_ns()

time.process_time_ns()

time.time_ns()

Diese Funktionen ähneln der Version ohne das Suffix _ns, geben jedoch einige Nanosekunden als Python-Int zurück.

Wie auch andere angemerkt haben, verwenden Sie das timeitModul, um Funktionen und kleine Codefragmente zu messen.

Unter Unix misst time.clock () die CPU-Zeit, die vom aktuellen Prozess verwendet wurde. Daher ist es nicht gut, die seit einem bestimmten Zeitpunkt verstrichene Zeit zu messen. Unter Windows werden die seit dem ersten Aufruf der Funktion verstrichenen Sekunden der Wanduhr gemessen. Auf beiden Systemen gibt time.time () die seit der Epoche verstrichenen Sekunden zurück.

Wenn Sie Code schreiben, der nur für Windows bestimmt ist, funktioniert beides (obwohl Sie die beiden unterschiedlich verwenden - für time.clock () ist keine Subtraktion erforderlich). Wenn dies auf einem Unix-System ausgeführt werden soll oder Sie Code wünschen, der garantiert portabel ist, sollten Sie time.time () verwenden.

Kurze Antwort: Verwenden Sie time.clock () für das Timing in Python.

Auf * nix-Systemen gibt clock () die Prozessorzeit als Gleitkommazahl in Sekunden zurück. Unter Windows werden die seit dem ersten Aufruf dieser Funktion verstrichenen Sekunden als Gleitkommazahl zurückgegeben.

time () gibt die Sekunden seit der Epoche in UTC als Gleitkommazahl zurück. Es gibt keine Garantie dafür, dass Sie eine bessere Genauigkeit als 1 Sekunde erhalten (obwohl time () eine Gleitkommazahl zurückgibt). Beachten Sie auch, dass der zweite Funktionsaufruf einen niedrigeren Wert zurückgibt, wenn die Systemuhr zwischen zwei Aufrufen dieser Funktion zurückgesetzt wurde.

Nach meinem besten Verständnis ist time.clock () so präzise, ​​wie es Ihr System zulässt.

Ich benutze diesen Code, um 2 Methoden zu vergleichen. Mein Betriebssystem ist Windows 8, Prozessorkern i5, RAM 4 GB

import time

def t_time():
    start=time.time()
    time.sleep(0.1)
    return (time.time()-start)


def t_clock():
    start=time.clock()
    time.sleep(0.1)
    return (time.clock()-start)




counter_time=0
counter_clock=0

for i in range(1,100):
    counter_time += t_time()

    for i in range(1,100):
        counter_clock += t_clock()

print "time() =",counter_time/100
print "clock() =",counter_clock/100

Ausgabe:

time () = 0,0993799996376

clock () = 0,0993572257367

Richtige Antwort: Sie sind beide gleich lang wie ein Bruchteil.

Aber die schneller , wenn subjectist time?

Ein kleiner Testfall :

import timeit
import time

clock_list = []
time_list = []

test1 = """
def test(v=time.clock()):
    s = time.clock() - v
"""

test2 = """
def test(v=time.time()):
    s = time.time() - v
"""
def test_it(Range) :
    for i in range(Range) :
        clk = timeit.timeit(test1, number=10000)
        clock_list.append(clk)
        tml = timeit.timeit(test2, number=10000)
        time_list.append(tml)

test_it(100)

print "Clock Min: %f Max: %f Average: %f" %(min(clock_list), max(clock_list), sum(clock_list)/float(len(clock_list)))
print "Time  Min: %f Max: %f Average: %f" %(min(time_list), max(time_list), sum(time_list)/float(len(time_list)))

Ich arbeite nicht in einem Schweizer Labor, aber ich habe getestet.

Basierend auf dieser Frage: time.clock()ist besser alstime.time()

Bearbeiten: time.clock()ist ein interner Zähler, kann also nicht außerhalb verwendet werden, hat Einschränkungen max 32BIT FLOATund kann nicht weiter gezählt werden, wenn nicht die ersten / letzten Werte gespeichert werden. Ein weiterer Zähler kann nicht zusammengeführt werden ...

time.clock()wurde in Python 3.8 entfernt, weil es plattformabhängiges Verhalten hatte :

• Geben Sie unter Unix die aktuelle Prozessorzeit als Gleitkommazahl in Sekunden zurück.

• Unter Windows gibt diese Funktion die seit dem ersten Aufruf dieser Funktion verstrichenen Wanduhrsekunden als Gleitkommazahl zurück

  print(time.clock()); time.sleep(10); print(time.clock())
  # Linux  :  0.0382  0.0384   # see Processor Time
  # Windows: 26.1224 36.1566   # see Wall-Clock Time

Welche Funktion soll stattdessen ausgewählt werden?

• Prozessorzeit : Dies ist die Zeit, die dieser bestimmte Prozess aktiv auf der CPU ausführt. Der Ruhezustand, das Warten auf eine Webanforderung oder die Zeit, in der nur andere Prozesse ausgeführt werden, tragen nicht dazu bei.

  • Verwenden time.process_time()

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

  • Verwenden time.perf_counter()

    • time.time() Misst auch die Wanduhrzeit, kann aber zurückgesetzt werden, sodass Sie in der Zeit zurückgehen können
    • time.monotonic() kann nicht zurückgesetzt werden (monoton = geht nur vorwärts), hat aber eine geringere Genauigkeit als time.perf_counter()

Vergleich der Testergebnisse zwischen Ubuntu Linux und Windows 7.

Auf Ubuntu

>>> start = time.time(); time.sleep(0.5); (time.time() - start)
0.5005500316619873

Unter Windows 7

>>> start = time.time(); time.sleep(0.5); (time.time() - start)
0.5