[PYTHON] Ist time.time () nicht sehr genau?

Umgebung: win7 & Blender 2.77a python3.5.1

Bei der Überprüfung der Bearbeitungszeit

import time

start_time = time.time()

#
#Verschiedene Verarbeitung
#

print(time.time() - start_time)

Ich habe oft geschrieben: Ich sehe es oft so geschrieben. Es war jedoch seltsam, weil sich die Zahlen jedes Mal, wenn ich sie nachschlug, oft ziemlich änderten.

Genauigkeit von time.time ()

Wie genau ist es? Ich schrieb in der timeit Dokumentation:

http://docs.python.jp/2/library/timeit.html#timeit.default_timer

Unter Windows ist time.clock () auf Mikrosekunden genau, während time.time () nur auf 1/60 Sekunde genau ist. Andererseits ist unter Unix time.clock () ebenfalls 1/100 Sekunde genau und time.time () genauer.

Es scheint, dass Windows nur eine Genauigkeit von 1/60 Sekunde hat. Sie können die Details damit nicht messen ...

Andere Funktionen, die Zeit messen können

In time.clock () 3.3 abgeschafft time.monotonic() time.perf_counter() time.process_time() Es scheint, dass dieser Bereich bemerkenswert ist.

Verwenden Sie time.get_clock_info (), um die Informationen anzuzeigen.

import time

print("clock:\n{}".format(time.get_clock_info('clock')))
print("monotonic:\n{}".format(time.get_clock_info('monotonic')))
print("perf_counter:\n{}".format(time.get_clock_info('perf_counter')))
print("process_time:\n{}".format(time.get_clock_info('process_time')))
print("time:\n{}".format(time.get_clock_info('time')))

Ausgabeergebnis

clock:
namespace(adjustable=False, implementation='QueryPerformanceCounter()',monotonic=True, resolution=6.984127871000365e-08)

monotonic:
namespace(adjustable=False, implementation='GetTickCount64()', monotonic=True, resolution=0.015600099999999999)

perf_counter:
namespace(adjustable=False, implementation='QueryPerformanceCounter()', monotonic=True, resolution=6.984127871000365e-08)

process_time:
namespace(adjustable=False, implementation='GetProcessTimes()', monotonic=True, resolution=1e-07)

time:
namespace(adjustable=True, implementation='GetSystemTimeAsFileTime()', monotonic=False, resolution=0.015600099999999999)

Da "Auflösung" die Anzahl der Sekunden der Taktauflösung zu sein scheint, ist es besser, den kleineren Wert "time.perf_counter ()" oder "time.process_time ()" zu verwenden. Betrachtet man time.time (), so scheint es, dass es nur eine Genauigkeit von etwa 1/60 Sekunden gibt.

Tatsächliche Messung

import time

start_time = time.perf_counter()
print("perf_counter = {:.7f}".format(time.perf_counter() - start_time))

start_time = time.process_time()
print("process_time = {:.7f}".format(time.process_time() - start_time))

Ausgabeergebnis

perf_counter = 0.0000029
process_time = 0.0000000

time.perf_counter () scheint die erwartete Genauigkeit zu haben. time.process_time () ist seltsam. Lassen Sie uns die Auflösung von time.process_time () überprüfen.

import time

time_list = []

time_list.append(time.process_time())
while len(time_list) < 5:
    next_time = time.process_time()
    if time_list[len(time_list)-1] != next_time:
        time_list.append(next_time)

print(time_list[1] - time_list[0])
print(time_list[2] - time_list[1])
print(time_list[3] - time_list[2])
print(time_list[4] - time_list[3])

Ausgabeergebnis

0.015600100000000339
0.015600100000000339
0.015600100000000339
0.015600100000000339

Betrachtet man dies, so scheint es, dass "time.process_time ()" dieselbe Auflösung hat wie "time.time ()".

Fazit

In Windows ist die Genauigkeit von "time.time ()" nicht sehr hoch. Wenn Sie also Genauigkeit wünschen, verwenden Sie "time.perf_counter ()".