파이썬의 time.clock () 대 time.time () 정확도?

파이썬에서 타이밍에 사용하는 것이 더 낫습니까? time.clock () 또는 time.time ()? 어느 것이 더 정확한가?

예를 들면 다음과 같습니다.

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

vs.

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

3.3로, time.clock () 되지 않습니다 , 사용하도록 제안 것 time.process_time () 또는 time.perf_counter () 대신합니다.

이전의 2.7에서는 시간 모듈 문서 에 따르면 :

time.clock ()

유닉스에서는 현재 프로세서 시간을 부동 소수점 숫자 (초)로 반환합니다. “프로세서 시간”의 의미에 대한 정확성과 정의는 같은 이름의 C 함수의 정밀도에 달려 있지만, 어쨌든 이것은 파이썬 또는 타이밍 알고리즘을 벤치마킹하는 데 사용하는 함수입니다.

Windows에서이 함수는 Win32 함수 QueryPerformanceCounter ()를 기반으로이 함수에 대한 첫 번째 호출 이후 경과 된 벽시계 초를 부동 소수점 숫자로 리턴합니다. 해상도는 일반적으로 1 마이크로 초보다 낫습니다.

또한, 코드 스 니펫 벤치마킹을위한 timeit 모듈이 있습니다.

짧은 대답은 : 대부분의 시간 time.clock()이 더 나을 것입니다. 그러나 일부 하드웨어 (예 : GPU에 넣은 알고리즘)의 타이밍 time.clock()을 지정하는 경우이 시간을 없애고 time.time()유일한 해결책입니다.

참고 : 어떤 방법을 사용하든 타이밍은 제어 할 수없는 요인 (프로세스 전환시기, 빈도 등)에 따라 달라집니다.이 경우에는 나빠지지만와 함께 time.time()존재 time.clock()하므로 타이밍 테스트를 한 번만 실행해서는 안됩니다. 항상 일련의 테스트를 수행하고 시간의 평균 / 변동을 살펴보십시오.

기타 : 재 대답 한 time.time()대 time.clock().

그러나 벤치마킹 / 프로파일 링 목적으로 코드 블록의 실행을 타이밍하는 경우 timeit모듈을 살펴 봐야 합니다 .

명심해야 할 사항 : 시스템 시간 변경은에 영향을 time.time()주지만 그렇지 않습니다 time.clock().

자동 테스트 실행을 제어해야했습니다. 테스트 케이스의 한 단계가 주어진 시간보다 오래 걸리면 해당 TC는 다음 단계로 진행되지 않았습니다.

그러나 때때로 테스트 할 응용 프로그램의 스케줄러 모듈을 확인하기 위해 시스템 시간을 변경하는 단계가 필요했기 때문에 나중에 시스템 시간을 몇 시간 설정 한 후 TC 시간 초과가 만료되어 테스트 사례가 중단되었습니다. 나는 전환했다 time.time()에 time.clock()적절하게이 문제를 처리하는.

clock() -> 부동 소수점 수

프로세스 시작 이후 또는에 처음 호출 한 이후의 CPU 시간 또는 실시간을 반환합니다 clock(). 이것은 시스템 기록만큼이나 정밀합니다.

time() -> 부동 소수점 수

Epoch 이후 현재 시간을 초 단위로 반환하십시오. 시스템 시계가 제공하는 경우 1 초의 분수가 표시 될 수 있습니다.

time()운영 체제는 프로세스 실행 시간을 시스템 시간 (예 : 실제 시간)을 저장하는 정밀도로 저장하지 않기 때문에 일반적 으로 더 정확합니다.

당신이 관심있는 것에 달려 있습니다. 벽면 시계의 시간과 같이 WALL TIME을 의미하는 경우 time.clock ()은 CPU 시간을 관리 할 수 ​​있으므로 정확도를 제공하지 않습니다.

time()clock()Linux 보다 정확도가 높습니다 . clock()정밀도는 10ms 미만입니다. 하지만이 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 ()은 Linux와 Windows에서 매우 다릅니다.

설명하는 예제의 경우 "timeit"모듈이 필요할 수 있습니다.

다른 사람이 언급 한 것처럼 time.clock()찬성되지 않습니다 time.perf_counter()이나 time.process_time()와 있지만, 파이썬 3.7를 소개 나노초 해상도 타이밍 time.perf_counter_ns(), time.process_time_ns()그리고 time.time_ns()3 다른 기능과 함께.

이 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모듈 을 사용하여 함수와 작은 코드 스 니펫을 시간을 정하십시오.

Unix에서 time.clock ()은 현재 프로세스에서 사용한 CPU 시간을 측정하므로 과거 어느 시점부터 경과 시간을 측정하는 데는 좋지 않습니다. Windows에서는 함수를 처음 호출 한 후 경과 된 벽시계 초를 측정합니다. 어느 시스템에서나 time.time ()은 에포크 이후에 경과 된 초를 반환합니다.

Windows 전용 코드를 작성하는 경우 작동합니다 (두 가지를 다르게 사용하지만 time.clock ()에는 빼기가 필요하지 않습니다). 이것이 유닉스 시스템에서 실행되거나 이식성이 보장되는 코드를 원한다면 time.time ()을 사용하고 싶을 것입니다.

짧은 대답 : 파이썬에서 타이밍을 위해 time.clock () 을 사용 하십시오 .

* nix 시스템에서 clock ()은 프로세서 시간을 부동 소수점 숫자 (초)로 리턴합니다. Windows에서는이 함수를 처음 호출 한 후 경과 된 초를 부동 소수점 숫자로 리턴합니다.

time ()은 에포크 (epoch) 이후의 초를 부동 소수점 숫자로 UTC로 리턴합니다. time ()이 부동 소수점 숫자를 반환하더라도 1 초보다 더 나은 정밀도를 보장 할 수는 없습니다. 또한이 기능에 대한 두 번의 호출 사이에 시스템 시계가 다시 설정되면 두 번째 기능 호출은 더 낮은 값을 반환합니다.

내가 아는 한 time.clock ()은 시스템이 허용하는 것만 큼 정밀합니다.

이 코드를 사용하여 두 가지 방법을 비교합니다. 내 OS는 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

산출:

시간 () = 0.0993799996376

시계 () = 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이 있으며 첫 번째 / 마지막 값을 저장하지 않으면 계산을 계속할 수 없습니다. 다른 카운터를 병합 할 수 없습니다 ...

time.clock()플랫폼에 따라 동작 하기 때문에 Python 3.8에서 제거되었습니다 .

• 일 유닉스 부동 소수점 수는 초 단위로 표현되는 바와 같이, 현재의 프로세서 시간을 반환한다.

• 에 윈도우 ,이 함수는 부동 소수점 숫자로이 기능에 대한 첫 번째 호출 이후 경과 벽 시계 초를 반환

  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

어떤 기능을 대신 선택해야합니까?

• 프로세서 시간 :이 특정 프로세스가 CPU에서 능동적으로 실행되는 시간입니다. 휴면, 웹 요청 대기 또는 다른 프로세스 만 실행되는 시간은 이에 영향을 미치지 않습니다.

  • 사용하다 time.process_time()

• Wall-Clock Time (벽 시계 시간) : "벽에 걸려있는 시계", 즉 실시간 외부에 경과 된 시간을 나타냅니다.

  • 사용하다 time.perf_counter()

    • time.time() 또한 벽시계 시간을 측정하지만 재설정 할 수 있으므로 시간을 거슬러 갈 수 있습니다
    • time.monotonic() 재설정 할 수 없지만 (단조 = 앞으로 만 진행) 정밀도는 낮습니다. time.perf_counter()

Ubuntu Linux와 Windows 7 간의 테스트 결과 비교

우분투에서

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