Dokładność time.clock () vs. time.time () w Pythonie?

Którego lepiej używać do pomiaru czasu w Pythonie? time.clock () czy time.time ()? Który zapewnia większą dokładność?

na przykład:

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

vs.

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

Od wersji 3.3 funkcja time.clock () jest przestarzała i sugeruje się użycie zamiast niej time.process_time () lub time.perf_counter () .

Wcześniej w wersji 2.7, zgodnie z dokumentacją modułu czasu :

zegar()

W systemie Unix zwróć bieżący czas procesora jako liczbę zmiennoprzecinkową wyrażoną w sekundach. Precyzja, a właściwie sama definicja znaczenia „czasu procesora”, zależy od funkcji C o tej samej nazwie, ale w każdym razie jest to funkcja używana do testowania porównawczego Pythona lub algorytmów taktowania.

W systemie Windows funkcja ta zwraca sekundy zegara, które upłynęły od pierwszego wywołania tej funkcji, jako liczbę zmiennoprzecinkową, na podstawie funkcji Win32 QueryPerformanceCounter (). Rozdzielczość jest zwykle lepsza niż jedna mikrosekunda.

Dodatkowo istnieje moduł timeit do testowania fragmentów kodu.

Krótka odpowiedź brzmi: przez większość czasu time.clock()będzie lepiej. Jeśli jednak mierzysz czas sprzętem (na przykład algorytm, który umieściłeś w GPU), time.clock()pozbędziesz się tego czasu i time.time()jest to jedyne dostępne rozwiązanie.

Uwaga: bez względu na zastosowaną metodę, czas zależy od czynników, których nie możesz kontrolować (kiedy proces będzie się zmieniał, jak często, ...), jest gorzej z, time.time()ale istnieje również z time.clock(), więc nigdy nie powinieneś uruchamiać tylko jednego testu czasu, ale zawsze przeprowadzaj serię testów i sprawdzaj średnią / wariancję czasów.

Inne odpowiedziałeś re: time.time()wersetach time.clock().

Jeśli jednak planujesz wykonanie bloku kodu na potrzeby testów porównawczych / profilowania, powinieneś spojrzeć na timeitmoduł .

Należy pamiętać o jednej rzeczy: zmiana czasu systemowego wpływa, time.time()ale nie wpływa time.clock().

Musiałem kontrolować niektóre automatyczne testy. Jeśli jeden krok przypadku testowego trwał dłużej niż określony czas, ten TC został przerwany, aby przejść do następnego.

Czasami jednak potrzebny jest krok do zmiany czasu systemowego (w celu sprawdzenia modułu harmonogramu testowanej aplikacji), więc po ustawieniu czasu systemowego na kilka godzin w przyszłości upłynął limit czasu TC i przypadek testowy został przerwany. Musiałem przełączyć się z time.time()na, time.clock()aby poradzić sobie z tym poprawnie.

clock() -> liczba zmiennoprzecinkowa

Zwróć czas procesora lub czas rzeczywisty od początku procesu lub od pierwszego połączenia z clock(). Ma to tyle samo precyzji, co zapis systemu.

time() -> liczba zmiennoprzecinkowa

Zwróć bieżący czas w sekundach od Epoki. Ułamki sekundy mogą być obecne, jeśli zapewnia je zegar systemowy.

Zwykle time()jest bardziej precyzyjny, ponieważ systemy operacyjne nie przechowują czasu działania procesu z dokładnością, jaką przechowują czas systemowy (tj. Rzeczywisty czas)

Zależy od tego, na czym ci zależy. Jeśli masz na myśli CZAS ŚCIANY (jak w, czas na zegarze na ścianie), time.clock () nie zapewnia dokładności, ponieważ może zarządzać czasem procesora.

time()ma lepszą precyzję niż clock()w systemie Linux. clock()ma precyzję mniejszą niż 10 ms. Choć time()daje prefekt precyzji. Mój test dotyczy 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

Różnica zależy od platformy.

Na przykład clock () bardzo różni się w systemie Windows niż w systemie Linux.

W przypadku przykładów, które opisujesz, prawdopodobnie zamiast tego potrzebujesz modułu „timeit”.

Jako inne zauważyli time.clock()jest zastąpiona time.perf_counter()lub time.process_time(), ale Python 3,7 wprowadza nanosekund z rozdzielczością czasową time.perf_counter_ns(), time.process_time_ns()i time.time_ns()wraz z 3 innymi funkcjami.

Te 6 nowych funkcji rozdzielczości nansecond opisano szczegółowo w 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()

Funkcje te są podobne do wersji bez sufiksu _ns, ale zwracają liczbę nanosekund jako int Python.

Jak zauważyli inni, użyj timeitmodułu do pomiaru czasu i małych fragmentów kodu.

Na Unix time.clock () mierzy czas procesora, który został wykorzystany przez bieżący proces, więc nie jest dobry do mierzenia czasu, który upłynął od pewnego momentu w przeszłości. W systemie Windows będzie mierzył sekundy zegara ściennego, które upłynęły od pierwszego wywołania funkcji. W obu systemach time.time () zwróci sekundy upływające od epoki.

Jeśli piszesz kod przeznaczony tylko dla systemu Windows, jeden z nich będzie działał (chociaż będziesz używać tych dwóch w różny sposób - funkcja time.clock () nie wymaga odejmowania). Jeśli ma to działać w systemie Unix lub chcesz mieć kod, który ma być przenośny, będziesz chciał użyć time.time ().

Krótka odpowiedź: użyj time.clock () do pomiaru czasu w Pythonie.

W systemach * nix funkcja clock () zwraca czas procesora jako liczbę zmiennoprzecinkową wyrażoną w sekundach. W systemie Windows zwraca sekundy, które upłynęły od pierwszego wywołania tej funkcji, jako liczbę zmiennoprzecinkową.

time () zwraca liczbę sekund od epoki, w UTC, jako liczbę zmiennoprzecinkową. Nie ma gwarancji, że uzyskasz lepszą precyzję niż 1 sekunda (nawet jeśli time () zwraca liczbę zmiennoprzecinkową). Należy również pamiętać, że jeśli zegar systemowy został cofnięty między dwoma wywołaniami tej funkcji, drugie wywołanie funkcji zwróci niższą wartość.

O ile mi wiadomo, time.clock () ma tyle precyzji, na ile pozwala na to twój system.

Używam tego kodu do porównania 2 metod. Mój system operacyjny to Windows 8, rdzeń procesora 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

wynik:

czas () = 0,0993799996376

clock () = 0,0993572257367

Prawidłowa odpowiedź: obie są tej samej długości ułamka.

Ale który jest szybszy, jeśli subjectjest time?

Mały przypadek testowy :

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

Nie pracuję w szwajcarskich laboratoriach, ale przetestowałem ...

Na podstawie tego pytania: time.clock()jest lepszy niżtime.time()

Edycja: time.clock()jest wewnętrznym licznikiem, więc nie można go używać na zewnątrz, ma ograniczenia max 32BIT FLOAT, nie może kontynuować liczenia, jeśli nie zapisze pierwszych / ostatnich wartości. Nie można scalić kolejnego licznika ...

time.clock()został usunięty w Pythonie 3.8, ponieważ miał zachowanie zależne od platformy :

• W systemie Unix zwróć bieżący czas procesora jako liczbę zmiennoprzecinkową wyrażoną w sekundach.

• W systemie Windows ta funkcja zwraca sekundy zegarowe, które upłynęły od pierwszego wywołania tej funkcji, jako liczbę zmiennoprzecinkową

  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

Którą funkcję wybrać zamiast tego?

• Czas procesora : tyle czasu ten konkretny proces spędza aktywnie wykonywany na procesorze. Uśpienie, oczekiwanie na żądanie sieciowe lub czas, w którym wykonywane są tylko inne procesy, nie przyczyni się do tego.

  • Posługiwać się time.process_time()

• Czas naścienny : Odnosi się do tego, ile czasu minęło „na zegarze wiszącym na ścianie”, tj. Poza czasem rzeczywistym.

  • Posługiwać się time.perf_counter()

    • time.time() mierzy również czas naścienny, ale można go zresetować, aby można było cofnąć się w czasie
    • time.monotonic() nie można go zresetować (monotoniczny = tylko idzie do przodu), ale ma mniejszą dokładność niż time.perf_counter()

Porównywanie wyników testu między Ubuntu Linux a Windows 7.

Na Ubuntu

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

W systemie Windows 7

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