시간 모듈로 경과 시간 측정

파이썬에서 시간 모듈을 사용하면 경과 시간을 측정 할 수 있습니까? 그렇다면 어떻게해야합니까?

커서가 특정 기간 동안 위젯에 있으면 이벤트가 발생하도록하려면이 작업을 수행해야합니다.

start_time = time.time()
# your code
elapsed_time = time.time() - start_time

간단한 데코레이터를 작성하여 다양한 기능의 실행 시간 측정을 단순화 할 수도 있습니다.

import time
from functools import wraps

PROF_DATA = {}

def profile(fn):
    @wraps(fn)
    def with_profiling(*args, **kwargs):
        start_time = time.time()

        ret = fn(*args, **kwargs)

        elapsed_time = time.time() - start_time

        if fn.__name__ not in PROF_DATA:
            PROF_DATA[fn.__name__] = [0, []]
        PROF_DATA[fn.__name__][0] += 1
        PROF_DATA[fn.__name__][1].append(elapsed_time)

        return ret

    return with_profiling

def print_prof_data():
    for fname, data in PROF_DATA.items():
        max_time = max(data[1])
        avg_time = sum(data[1]) / len(data[1])
        print "Function %s called %d times. " % (fname, data[0]),
        print 'Execution time max: %.3f, average: %.3f' % (max_time, avg_time)

def clear_prof_data():
    global PROF_DATA
    PROF_DATA = {}

용법:

@profile
def your_function(...):
    ...

하나 이상의 기능을 동시에 프로파일 링 할 수 있습니다. 그런 다음 측정 값을 인쇄하려면 print_prof_data ()를 호출하십시오.

time.time() 일을 할 것입니다.

import time

start = time.time()
# run your code
end = time.time()

elapsed = end - start

이 질문 을보고 싶을 수도 있지만 꼭 필요한 것은 아닙니다.

더 나은 형식을 원하는 사용자에게는

import time
start_time = time.time()
# your script
elapsed_time = time.time() - start_time
time.strftime("%H:%M:%S", time.gmtime(elapsed_time))

2 초 동안 인쇄됩니다.

'00:00:02'

그리고 7 분 동안 1 초 동안 :

'00:07:01'

gmtime의 최소 시간 단위는 초입니다. 마이크로 초가 필요한 경우 다음을 고려하십시오.

import datetime
start = datetime.datetime.now()
# some code
end = datetime.datetime.now()
elapsed = end - start
print(elapsed)
# or
print(elapsed.seconds,":",elapsed.microseconds) 

strftime 문서

경과 시간을 가장 잘 측정하려면 (Python 3.3부터)을 사용하십시오 time.perf_counter().

성능 카운터, 즉 짧은 지속 시간을 측정 할 수있는 가장 높은 해상도를 가진 시계의 값 (소수 초)을 반환합니다. 수면 중 경과 시간이 포함되며 시스템 전체에 적용됩니다. 반환 된 값의 기준점은 정의되어 있지 않으므로 연속 호출 결과의 차이 만 유효합니다.

시간 / 일 순서로 측정하는 경우 1 초 미만의 해상도에 신경 쓰지 않으므로 time.monotonic()대신 사용하십시오.

단조로운 시계, 즉 뒤로 이동할 수없는 시계의 값 (소수 초)을 반환합니다. 시계는 시스템 시계 업데이트의 영향을받지 않습니다. 반환 된 값의 기준점은 정의되어 있지 않으므로 연속 호출 결과의 차이 만 유효합니다.

많은 구현에서, 이들은 실제로 동일한 것일 수 있습니다.

3.3 이전에는으로 붙어 있습니다 time.clock().

유닉스에서는 현재 프로세서 시간을 부동 소수점 숫자 (초)로 반환합니다. "프로세서 시간"의 의미에 대한 정확성과 정의는 같은 이름의 C 함수의 정밀도에 따라 달라집니다.

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

Python 3.7 업데이트

Python 3.7의 새로운 기능 은 PEP 564 입니다. 나노초 분해능으로 새로운 시간 함수를 추가합니다.

이들을 사용하면 특히 매우 짧은 기간을 측정하거나 응용 프로그램 (또는 Windows 시스템)이 오래 실행되는 경우 반올림 및 부동 소수점 오류를 추가로 제거 할 수 있습니다.

perf_counter()약 100 일 후에 해결이 시작 됩니다. 예를 들어 1 년의 가동 시간 후 측정 할 수있는 가장 짧은 간격 (0보다 큼)은 시작했을 때보 다 더 커집니다.

Python 3.8 업데이트

time.clock 이제 사라졌습니다.

더 오랜 기간 동안.

import time
start_time = time.time()
...
e = int(time.time() - start_time)
print('{:02d}:{:02d}:{:02d}'.format(e // 3600, (e % 3600 // 60), e % 60))

인쇄 할 것이다

00:03:15

24 시간 이상인 경우

25:33:57

Rutger Hofste의 답변에서 영감을 얻었습니다. Rutger 감사합니다!

시간을 가져온 다음 time.time () 메서드를 사용하여 현재 시간을 알아야합니다.

import time

start_time=time.time() #taking current time as starting time

#here your code

elapsed_time=time.time()-start_time #again taking current time - starting time 

시간을 정하는 또 다른 좋은 방법은 with python 구조 를 사용하는 것입니다 .

와 구조가 자동으로 호출 __enter__ 및 __exit__ 정확하게 우리가 시간의 일에 필요한 인 방법.

Timer 클래스를 만들어 봅시다 .

from time import time

class Timer():
    def __init__(self, message):
        self.message = message
    def __enter__(self):
        self.start = time()
        return None  # could return anything, to be used like this: with Timer("Message") as value:
    def __exit__(self, type, value, traceback):
        elapsed_time = (time() - self.start) * 1000
        print(self.message.format(elapsed_time))

그런 다음 Timer 클래스를 다음과 같이 사용할 수 있습니다.

with Timer("Elapsed time to compute some prime numbers: {}ms"):
    primes = []
    for x in range(2, 500):
        if not any(x % p == 0 for p in primes):
            primes.append(x)
    print("Primes: {}".format(primes))

결과는 다음과 같습니다.

프라임 : [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89 , 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227 , 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373 , 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499]

소수를 계산하는 데 걸린 시간 : 5.01704216003418ms

Vadim Shender 응답이 훌륭합니다. 아래와 같이 더 간단한 데코레이터를 사용할 수도 있습니다.

import datetime
def calc_timing(original_function):                            
    def new_function(*args,**kwargs):                        
        start = datetime.datetime.now()                     
        x = original_function(*args,**kwargs)                
        elapsed = datetime.datetime.now()                      
        print("Elapsed Time = {0}".format(elapsed-start))     
        return x                                             
    return new_function()  

@calc_timing
def a_func(*variables):
    print("do something big!")

프로그래밍에는 시간을 측정 하는 두 가지 주요 방법 이 있으며 결과는 다릅니다.

>>> print(time.process_time()); time.sleep(10); print(time.process_time())
0.11751394000000001
0.11764988400000001  # took  0 seconds and a bit
>>> print(time.perf_counter()); time.sleep(10); print(time.perf_counter())
3972.465770326
3982.468109075       # took 10 seconds and a bit

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

  • 사용하다 time.process_time()

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

  • 사용하다 time.perf_counter()

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

다음은 테이블 출력이있는 Vadim Shender의 영리한 코드에 대한 업데이트입니다.

import collections
import time
from functools import wraps

PROF_DATA = collections.defaultdict(list)

def profile(fn):
    @wraps(fn)
    def with_profiling(*args, **kwargs):
        start_time = time.time()
        ret = fn(*args, **kwargs)
        elapsed_time = time.time() - start_time
        PROF_DATA[fn.__name__].append(elapsed_time)
        return ret
    return with_profiling

Metrics = collections.namedtuple("Metrics", "sum_time num_calls min_time max_time avg_time fname")

def print_profile_data():
    results = []
    for fname, elapsed_times in PROF_DATA.items():
        num_calls = len(elapsed_times)
        min_time = min(elapsed_times)
        max_time = max(elapsed_times)
        sum_time = sum(elapsed_times)
        avg_time = sum_time / num_calls
        metrics = Metrics(sum_time, num_calls, min_time, max_time, avg_time, fname)
        results.append(metrics)
    total_time = sum([m.sum_time for m in results])
    print("\t".join(["Percent", "Sum", "Calls", "Min", "Max", "Mean", "Function"]))
    for m in sorted(results, reverse=True):
        print("%.1f\t%.3f\t%d\t%.3f\t%.3f\t%.3f\t%s" % (100 * m.sum_time / total_time, m.sum_time, m.num_calls, m.min_time, m.max_time, m.avg_time, m.fname))
    print("%.3f Total Time" % total_time)