Time.time () n'est-il pas très précis?

Environnement: win7 & blender 2.77a python3.5.1

Lors de la vérification du temps de traitement

import time

start_time = time.time()

#
#Traitement divers
#

print(time.time() - start_time)

J'ai souvent écrit: Je le vois souvent écrit comme ça. Cependant, c'était étrange parce que les chiffres changeaient souvent un peu à chaque fois que je cherchais.

Précision de time.time ()

Quelle est sa précision? J'ai écrit dans la documentation timeit:

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

Sous Windows, time.clock () est précis à la microseconde, tandis que time.time () n'est précis qu'à 1/60 seconde. D'un autre côté, sous Unix, time.clock () est également précis au 1/100 de seconde, et time.time () est plus précis.

Il semble que Windows n'a qu'une précision de 1/60 de seconde. Vous ne pouvez pas mesurer les détails avec ça ...

Autres fonctions qui peuvent mesurer le temps

Aboli dans time.clock () 3.3 time.monotonic() time.perf_counter() time.process_time() Il semble que ce domaine soit remarquable.

Utilisez time.get_clock_info () pour voir les informations.

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')))

Résultat de sortie

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)

Puisque resolution semble être le nombre de secondes de résolution d'horloge, il semble préférable d'utiliser la valeur la plus petite time.perf_counter () ʻou time.process_time (). En regardant time.time ()`, il semble qu'il n'y ait qu'une précision d'environ 1/60 seconde.

Mesure réelle

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))

Résultat de sortie

perf_counter = 0.0000029
process_time = 0.0000000

time.perf_counter () semble avoir la précision attendue. time.process_time () est étrange. Vérifions la résolution de time.process_time ().

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])

Résultat de sortie

0.015600100000000339
0.015600100000000339
0.015600100000000339
0.015600100000000339

En regardant cela, il semble que time.process_time () a la même résolution que time.time ().

Conclusion

Sous Windows, la précision de time.time () n'est pas très élevée, donc si vous voulez de la précision, utilisez time.perf_counter ().