Python time.clock () против точности time.time ()?

428

Что лучше использовать для синхронизации в Python? time.clock () или time.time ()? Какой из них обеспечивает большую точность?

например:

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

против

start = time.time()
... do something
elapsed = (time.time() - start)
Кори Голдберг
источник
32
Обратите внимание, что начиная с Python 3.3, использование time.clock()устарело , и рекомендуется использовать perf_counter()или process_time()вместо.
Коди Пирсолл
Смотрите этот комментарий о том , как все ядра , используемые в процессе суммируются в time.clockи time.process_time, но дочерние процессы не являются. Также посмотрите это обсуждение точности (конечно, зависит от системы).
максимум

Ответы:

161

Начиная с 3.3, time.clock () устарела , и вместо него предлагается использовать time.process_time () или time.perf_counter () .

Ранее в 2.7, в соответствии с документами модуля времени :

time.clock ()

В Unix верните текущее время процессора в виде числа с плавающей запятой, выраженного в секундах. Точность и, собственно, само определение значения «процессорного времени» зависит от точности функции C с тем же именем, но в любом случае эту функцию следует использовать для тестирования Python или алгоритмов синхронизации.

В Windows эта функция возвращает настенные часы, прошедшие с момента первого вызова этой функции, в виде числа с плавающей запятой на основе функции Win32 QueryPerformanceCounter (). Разрешение обычно лучше, чем одна микросекунда.

Кроме того, есть модуль timeit для сравнительного анализа фрагментов кода.

Джейсон Наваррете
источник
4
«это функция, используемая для тестирования Python или алгоритмов синхронизации». <br> Документы Python, похоже, не точны, основываясь на ответах, приведенных здесь. time.clock () не всегда то, что вы хотите для тестирования. особенно с существованием модуля timeit
Кори Голдберг
1
@ Корей Голдберг: так вы отправили ошибку документации ? (Они имели в виду «использовать часы (), а не время () :, но да, это небрежно)
smci
3
Как можно прочитать здесь, похоже, что поведение time.clock()было зависимым от платформы, и time.process_time()это не так. Это причина, почему time.clock()был объявлен устаревшим.
Джим Ахо
46

Короткий ответ: в большинстве случаев time.clock()будет лучше. Однако, если вы синхронизируете какое-то оборудование (например, какой-то алгоритм, который вы вставляете в GPU), то time.clock()избавитесь от этого времени и останетесь time.time()единственным решением.

Примечание: какой бы метод ни использовался, время будет зависеть от факторов, которые вы не можете контролировать (когда произойдет переключение процесса, как часто, ...), с этим хуже, time.time()но есть и с time.clock()таким, поэтому вы никогда не должны запускать только один тест синхронизации, но всегда запускайте серию тестов и смотрите на среднее / дисперсию времени.

PierreBdR
источник
также при запросе сетевого ресурса асинхронным способом (процесс будет заблокирован для ожидания), время сети будет избавлено.
декабря
25

Другие ответили: time.time()против time.clock().

Однако, если вы планируете выполнение блока кода для целей тестирования / профилирования, вы должны взглянуть на timeitмодуль .

дР.
источник
16
+1: timeit.default_timerназначается time.time()или time.clock()зависит от ОС. На Python 3.3+ default_timerесть time.perf_counter()на всех платформах.
JFS
19

Следует помнить одну вещь: изменение системного времени влияет, time.time()но не влияет time.clock().

Мне нужно было контролировать выполнение некоторых автоматических тестов. Если один шаг тестового примера занимал больше заданного времени, этот TC был прерван, чтобы перейти к следующему.

Но иногда необходимо было изменить шаг системного времени (чтобы проверить модуль планировщика тестируемого приложения), поэтому после установки системного времени через несколько часов время тайм-аута TC истекло, и контрольный пример был прерван. Я должен был перейти от time.time()к , time.clock()чтобы справиться с этим правильно.

Seba
источник
1
Я искал это. Спасибо :) Это поможет мне, даже если пользователь меняет свое время с ОС.
Аашик Хуссейн
Как я могу сравнить это время и время, сохраненное пользователем в формате час: минута?
Аашик Хуссейн
19

clock() -> число с плавающей точкой

Возврат времени ЦП или реального времени с момента начала процесса или с момента первого вызова clock(). Это имеет такую ​​же точность, как и системные записи.

time() -> число с плавающей точкой

Вернуть текущее время в секундах с начала эпохи. Могут присутствовать доли секунды, если их обеспечивают системные часы.

Обычно time()это более точно, потому что операционные системы не хранят время выполнения процесса с точностью, которую они сохраняют системное время (то есть фактическое время)

Винко Врсалович
источник
17

Зависит от того, что вы заботитесь. Если вы имеете в виду WALL TIME (как, например, время на часах на вашей стене), time.clock () НЕТ точности, поскольку она может управлять временем процессора.

user15910
источник
1
точно, я просто использовал time.clock()на серверах Linux, и числа, которые я получил, точно не были секундами
Роман Плашил
15

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
bestwolf1983
источник
так я предполагаю время () на вино ??
Tcll
6

Разница очень зависит от платформы.

Например, clock () в Windows сильно отличается от Linux.

Для примеров, которые вы описываете, вы, вероятно, захотите использовать модуль "timeit".

Джастин Шихи
источник
3
Вы могли бы расширить, в чем clockзаключается "very different"?
n611x007
5

Как уже отмечено , time.clock()является устаревшим в пользу time.perf_counter()или time.process_time(), но Python 3.7 вводит наносекундным разрешением по времени с time.perf_counter_ns(), time.process_time_ns()и time.time_ns(), вместе с 3 другими функциями.

Эти 6 новых функций с разрешением наносекунды подробно описаны в 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модуль для определения времени функций и небольших фрагментов кода.

Chris_Rands
источник
3

В Unix time.clock () измеряет количество процессорного времени, которое использовалось текущим процессом, поэтому оно не годится для измерения прошедшего времени с некоторого момента в прошлом. В Windows он будет измерять количество секунд, прошедших с момента первого вызова функции. В любой системе time.time () будет возвращать секунды, прошедшие с начала эпохи.

Если вы пишете код, предназначенный только для Windows, любой из них будет работать (хотя вы будете использовать их по-разному - для time.clock ()) вычитание не требуется. Если это будет работать в системе Unix или вы хотите, чтобы код, который гарантированно был переносимым, вы захотите использовать time.time ().


источник
2

Краткий ответ: используйте time.clock () для синхронизации в Python.

В системах * nix clock () возвращает время процессора в виде числа с плавающей запятой, выраженного в секундах. В Windows он возвращает секунды, прошедшие с момента первого вызова этой функции, в виде числа с плавающей запятой.

time () возвращает секунды с начала эпохи в формате UTC как число с плавающей запятой. Нет гарантии, что вы получите лучшую точность, чем 1 секунда (хотя time () возвращает число с плавающей запятой). Также обратите внимание, что если системные часы были установлены обратно между двумя вызовами этой функции, второй вызов функции вернет меньшее значение.

Бабак
источник
2

Насколько я понимаю, time.clock () имеет настолько высокую точность, насколько позволяет ваша система.

Джейк
источник
2

Я использую этот код для сравнения 2 методов. Моя ОС Windows 8, процессорное ядро ​​i5, RAM 4 ГБ

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

вывод:

время () = 0,0993799996376

часы () = 0.0993572257367

Нурул Актер Тоухид
источник
1

Правильный ответ: они оба имеют одинаковую длину дроби.

Но что быстрее, если 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, не может продолжать считать, если не сохранить первые / последние значения. Не могу объединить еще один счетчик ...

dsgdfg
источник
0

time.clock()был удален в Python 3.8, потому что он имел платформо-зависимое поведение :

  • В Unix верните текущее время процессора в виде числа с плавающей запятой, выраженного в секундах.
  • В Windows эта функция возвращает часы настенных часов, прошедшие с момента первого вызова этой функции, в виде числа с плавающей запятой

    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

Так какую функцию выбрать вместо?

  • Время процессора . Это время, которое этот конкретный процесс активно проводит на процессоре. Спящий режим, ожидание веб-запроса или время, когда выполняются только другие процессы, не будут этому способствовать.

    • использование time.process_time()
  • Время настенных часов : это относится к тому, сколько времени прошло «на часах, висящих на стене», то есть вне реального времени.

    • использование time.perf_counter()

      • time.time() также измеряет время настенных часов, но может быть сброшено, чтобы вы могли вернуться назад во времени
      • time.monotonic() не может быть сброшен (монотонный = только вперед), но имеет меньшую точность, чем time.perf_counter()
xjcl
источник
-1

Сравнение результатов теста между 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
возвышенность
источник
Пожалуйста, прочитайте другие ответы, чтобы понять разницу между Windows и Unix / Linux.
Кори Голдберг