Что лучше использовать для синхронизации в Python? time.clock() или time.time()? Какой из них обеспечивает большую точность?
например:
start = time.clock()
... do something
elapsed = (time.clock() - start)
против.
start = time.time()
... do something
elapsed = (time.time() - start)
Начиная с версии 3.3, time.clock() устарел, и он предложил использовать time.process_time() или time.perf_counter().
Ранее в версии 2.7 в соответствии с это функция, используемая для бенчмаркинг Python или алгоритмы синхронизации.
В Windows эта функция возвращает часы настенных часов, прошедшие с момента первый вызов этой функции в виде числа с плавающей запятой, основанный на Функция Win32 QueryPerformanceCounter(). Разрешение обычно лучше, чем одна микросекунда.
Кроме того, существует модуль timeit для сравнения фрагментов кода.
Короткий ответ: большую часть времени time.clock() будет лучше.
Однако, если вы зацикливаетесь на некотором аппаратном обеспечении (например, какой-то алгоритм вы помещаете в графический процессор), тогда time.clock() избавится от этого времени, а time.time() останется единственным решением.
Примечание: независимо от используемого метода, время будет зависеть от факторов, которые вы не можете контролировать (когда будет переключаться процесс, как часто...), это хуже с time.time(), но существует также с time.clock(), поэтому вы никогда не должны запускать только один временный тест, но всегда выполняйте серию тестов и смотрите среднее/дисперсию времени.
Другие ответили на вопрос: time.time() vs. time.clock().
Однако, если вы планируете выполнение блока кода для целей бенчмаркинга/профилирования, вы должны взглянуть на модуль timeit.
В зависимости от того, что вам нужно. Если вы имеете в виду WALL TIME (например, время на часах на стене), time.clock() не обеспечивает точность, поскольку может управлять временем процессора.
Одна вещь, о которой нужно помнить: Изменение системного времени влияет на time.time(), но не на time.clock().
Мне нужно было контролировать некоторые автоматические тесты. Если один шаг тестового примера занял больше определенного времени, то TC был прерван, чтобы продолжить следующий.
Но иногда требуется изменить системное время (чтобы проверить модуль планировщика тестируемого приложения), поэтому после установки системного времени на несколько часов в будущем тайм-аут ТС истек и тестовый случай был прерван. Мне пришлось переключиться с time.time() на time.clock(), чтобы справиться с этим правильно.
clock() → число с плавающей запятой
Возврат процессорного времени или реального времени с начала процесса или с момента
первый вызов clock(). Это имеет такую же точность, как и система
записи.
time() → число с плавающей запятой
Возвращает текущее время в секундах с момента Эпохи. Фракции секунды могут присутствовать, если системные часы предоставляют их.
Обычно time() более точен, поскольку операционные системы не сохраняют время выполнения процесса с точностью, в которой они хранят системное время (то есть фактическое время)
Для моей practice. time() более высокая точность, чем clock() для Linux. clock() имеет точность менее 10 мс. Пока time() дает префектную точность.
Мой тест находится на CentOS 6.4, 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
Разница очень специфична для платформы.
clock() очень сильно отличается от Windows, чем, например, в Linux.
В качестве примеров, которые вы описываете, вы, скорее всего, захотите использовать модуль "timeit".
В Unix time.clock() измеряет количество процессорного времени, которое было использовано текущим процессом, поэтому нецелесообразно измерять прошедшее время с некоторого момента в прошлом. В Windows он будет измерять часы настенных часов, прошедшие с момента первого вызова функции. В любой системе time.time() будет возвращать секунды, прошедшие с эпохи.
Если вы пишете код, предназначенный только для Windows, либо он будет работать (хотя вы будете использовать два по-разному - вычитание не требуется для time.clock()). Если это будет запущено в системе Unix или вы хотите, чтобы код был гарантированно переносимым, вы захотите использовать time.time().
Короткий ответ: используйте time.clock() для синхронизации в Python.
В системах * nix clock() возвращает время процессора как число с плавающей запятой, выраженное в секундах. В Windows он возвращает секунды, прошедшие со времени первого вызова этой функции, в виде числа с плавающей запятой.
time() возвращает секунды с эпохи в UTC как число с плавающей запятой. Нет никакой гарантии, что вы получите более точную точность, чем за 1 секунду (хотя время() возвращает число с плавающей запятой). Также обратите внимание, что если системные часы были установлены обратно между двумя вызовами этой функции, второй вызов функции вернет более низкое значение.
Насколько я понимаю, time.clock() имеет такую же точность, как и ваша система.
Я использую этот код для сравнения двух методов. Моя ОС - это Windows 8, ядро процессора i5, RAM 4GB
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
выход:
time() = 0.0993799996376
clock() = 0.0993572257367
Правильный ответ: Они имеют одинаковую длину доли.
Но быстрее, если subject time?
Маленький тестовый пример:
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)))
Я не работаю в швейцарских лабораториях, но я тестировал.
Исходя из этого вопроса: time.clock() лучше, чем time.time()
Изменить: time.clock() - внутренний счетчик, поэтому он не может использовать внешний вид, получил ограничения max 32BIT FLOAT, не может продолжать подсчет, если не хранить первые/последние значения. Невозможно объединить другой счетчик...
Сравнение результатов теста между Ubuntu Linux и Windows 7.
В Ubuntu
>>> start = time.time(); time.sleep(0.5); (time.time() - start)
0.5005500316619873
В Windows 7
>>> start = time.time(); time.sleep(0.5); (time.time() - start)
0.5
Как отмечали другие, time.clock() устарел в пользу time.perf_counter() или time.process_time(), но Python 3.7 вводит синхронизацию с разрешением наносекунд с time.perf_counter_ns(), time.process_time_ns() и time.time_ns() вместе с тремя другими функциями.
Эти 6 новых функций разрешения nansecond подробно описаны в PEP 564:
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()Эти функции аналогичны версии без суффикса _ns, но вернуть несколько наносекунд в виде Python int.
Как отмечали другие, используйте timeit модуль для функций времени и небольших фрагментов кода.
Чтобы продолжить на результатах @Hill, вот тест с использованием python 3.4.3 на Xubuntu 16.04 через wine:
(timeit.default_timer будет использовать time.clock(), потому что видит ОС как "win32" )
При использовании Windows часы() обычно более точны, но это не относится к вину...
вы можете видеть здесь, что time() более точен, чем clock(), что обычно происходит с Linux и Mac.
Используйте time.time().