내가 원하는 것은 내 코드 어딘가에서 시간을 계산 한 다음 전달 된 시간을 가져와 거의 기능을 실행하는 데 걸리는 시간을 측정하는 것입니다. timeit 모듈을 잘못 사용하고 있다고 생각하지만 문서가 혼란 스럽습니다.

import timeit

start = timeit.timeit()
print("hello")
end = timeit.timeit()
print(end - start)

두 지점 사이의 경과 된 벽시계 시간을 측정하려는 경우 다음을 사용할 수 있습니다 time.time().

import time

start = time.time()
print("hello")
end = time.time()
print(end - start)

실행 시간 (초)을 제공합니다.

3.3 이후 또 다른 옵션은 사용할 수 있습니다 perf_counter또는 process_time귀하의 요구 사항에 따라. 3.3 전에 그것을 사용을 권장했다 time.clock(감사 황색 ). 그러나 현재 더 이상 사용되지 않습니다.

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

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

버전 3.3부터 사용되지 않음 :이 기능의 동작은 플랫폼 에 따라 다릅니다. 요구 사항에 따라 또는 대신을 사용perf_counter()process_time() 하여 올바르게 정의 된 동작을 수행하십시오.

timeit.default_timer대신에 사용하십시오 timeit.timeit. 전자는 플랫폼 및 Python 버전에서 자동으로 사용할 수있는 최고의 시계를 자동으로 제공합니다.

from timeit import default_timer as timer

start = timer()
# ...
end = timer()
print(end - start) # Time in seconds, e.g. 5.38091952400282

timeit.default_timer 는 OS에 따라 time.time () 또는 time.clock ()에 할당됩니다. Python 3.3 이상에서 default_timer 는 모든 플랫폼에서 time.perf_counter () 입니다. Python-time.clock () 대 time.time ()-정확도를 참조하십시오 .

또한보십시오:

• 코드 최적화
• 속도를 최적화하는 방법

파이썬 3 만 :

time.clock ()이 때문에 파이썬 3.3으로 사용되지 않습니다 , 당신은 사용하고자하는 것입니다 time.perf_counter()시스템 전체의 타이밍, 또는 time.process_time()공정 전체의 타이밍, 당신이 사용하는 데 사용 단지 방법을 time.clock():

import time

t = time.process_time()
#do some stuff
elapsed_time = time.process_time() - t

새로운 기능 process_time은 수면 중에 경과 된 시간을 포함하지 않습니다.

시간을 내고 싶은 기능이 있다면

test.py :

def foo(): 
    # print "hello"   
    return "hello"

사용하는 가장 쉬운 방법 timeit은 명령 줄에서 호출하는 것입니다.

% python -mtimeit -s'import test' 'test.foo()'
1000000 loops, best of 3: 0.254 usec per loop

기능 속도를 비교 하기 위해 time.time또는 time.clock(순진하게) 사용하지 마십시오 . 그들은 잘못된 결과를 줄 수 있습니다 .

추신. 인쇄하고자하는 함수에 인쇄 문을 넣지 마십시오. 그렇지 않으면 측정 된 시간 은 터미널 속도에 따라 달라집니다 .

콘텍스트 관리자를 사용하여이 작업을 수행하는 것이 재미있다. with블록 블록 종료시 종료 시간을 고정 있습니다. 약간의 속임수를 사용하면 동일한 컨텍스트 관리자 기능으로 블록 내에서 경과 시간 집계를 얻을 수도 있습니다.

핵심 라이브러리에는 이것이 없지만 아마도 있어야합니다. 제 위치에 있으면 다음과 같은 작업을 수행 할 수 있습니다.

with elapsed_timer() as elapsed:
    # some lengthy code
    print( "midpoint at %.2f seconds" % elapsed() )  # time so far
    # other lengthy code

print( "all done at %.2f seconds" % elapsed() )

트릭을 수행하기에 충분한 컨텍스트 관리자 코드는 다음과 같습니다 .

from contextlib import contextmanager
from timeit import default_timer

@contextmanager
def elapsed_timer():
    start = default_timer()
    elapser = lambda: default_timer() - start
    yield lambda: elapser()
    end = default_timer()
    elapser = lambda: end-start

그리고 실행 가능한 데모 코드 :

import time

with elapsed_timer() as elapsed:
    time.sleep(1)
    print(elapsed())
    time.sleep(2)
    print(elapsed())
    time.sleep(3)

이 함수의 설계 elapsed()에 따라 블록 종료시 리턴 값 이 고정되고 추가 호출은 동일한 지속 시간 (이 장난감 예에서는 약 6 초)을 리턴합니다.

초 단위의 측정 시간 :

from timeit import default_timer as timer
from datetime import timedelta

start = timer()
end = timer()
print(timedelta(seconds=end-start))

출력 :

0:00:01.946339

나는 이것을 선호한다. timeit문서가 너무 혼란 스럽다.

from datetime import datetime 

start_time = datetime.now() 

# INSERT YOUR CODE 

time_elapsed = datetime.now() - start_time 

print('Time elapsed (hh:mm:ss.ms) {}'.format(time_elapsed))

여기서 진행중인 서식이 없으며 hh:mm:ss, 인쇄물에 썼기 때문에 해석 할 수 있습니다.time_elapsed

이 작업을 수행하는 다른 방법이 있습니다.

>> from pytictoc import TicToc
>> t = TicToc() # create TicToc instance
>> t.tic() # Start timer
>> # do something
>> t.toc() # Print elapsed time
Elapsed time is 2.612231 seconds.

전통적인 방식과 비교 :

>> from time import time
>> t1 = time()
>> # do something
>> t2 = time()
>> elapsed = t2 - t1
>> print('Elapsed time is %f seconds.' % elapsed)
Elapsed time is 2.612231 seconds.

설치:

pip install pytictoc

자세한 내용은 PyPi 페이지 를 참조하십시오.

여기에 많은 좋은 답변과 몇 가지 다른 기사를 거친 후의 결과가 있습니다.

먼저,이 사이에 논쟁하는 경우 timeit와 time.time는이 timeit두 가지 장점이 있습니다 :

1. timeit OS 및 Python 버전에서 사용 가능한 최상의 타이머를 선택합니다.
2. timeit 가비지 수집을 비활성화하지만 이것은 원하지 않거나 원하지 않는 것이 아닙니다.

이제 문제는 timeit설정이 필요하고 가져 오기가 많을 때 추악 해지기 때문에 사용하기가 쉽지 않다는 것입니다. 이상적으로는 데코레이터를 원하거나 사용하기 만하면됩니다.with 블록을 시간을 측정하십시오. 불행히도, 이것에 사용할 수있는 내장 기능이 없으므로 두 가지 옵션이 있습니다.

옵션 1 : 시간 예산 라이브러리 사용

timebudget는 설치 핍 후 한 줄의 코드에서 바로 사용할 수있는 다양하고 매우 간단한 라이브러리입니다.

@timebudget  # Record how long this function takes
def my_method():
    # my code

옵션 2 : 코드 모듈을 직접 사용

아래에 작은 유틸리티 모듈을 만들었습니다.

# utils.py
from functools import wraps
import gc
import timeit

def MeasureTime(f, no_print=False, disable_gc=False):
    @wraps(f)
    def _wrapper(*args, **kwargs):
        gcold = gc.isenabled()
        if disable_gc:
            gc.disable()
        start_time = timeit.default_timer()
        try:
            result = f(*args, **kwargs)
        finally:
            elapsed = timeit.default_timer() - start_time
            if disable_gc and gcold:
                gc.enable()
            if not no_print:
                print('"{}": {}s'.format(f.__name__, elapsed))
        return result
    return _wrapper

class MeasureBlockTime:
    def __init__(self,name="(block)", no_print=False, disable_gc=False):
        self.name = name
        self.no_print = no_print
        self.disable_gc = disable_gc
    def __enter__(self):
        self.gcold = gc.isenabled()
        if self.disable_gc:
            gc.disable()
        self.start_time = timeit.default_timer()
    def __exit__(self,ty,val,tb):
        self.elapsed = timeit.default_timer() - self.start_time
        if self.disable_gc and self.gcold:
            gc.enable()
        if not self.no_print:
            print('Function "{}": {}s'.format(self.name, self.elapsed))
        return False #re-raise any exceptions

이제 데코레이터를 앞에 놓으면 모든 기능의 시간을 지정할 수 있습니다.

import utils

@utils.MeasureTime
def MyBigFunc():
    #do something time consuming
    for i in range(10000):
        print(i)

코드 부분의 시간을 정하려면 with블록 안에 넣으십시오 .

import utils

#somewhere in my code

with utils.MeasureBlockTime("MyBlock"):
    #do something time consuming
    for i in range(10000):
        print(i)

# rest of my code

장점 :

몇 가지 반백 버전이 떠 있기 때문에 몇 가지 주요 사항을 지적하고 싶습니다.

1. 앞에서 설명한 이유로 time.time 대신 timeit에서 timer를 사용하십시오.
2. 원하는 경우 타이밍 중에 GC를 비활성화 할 수 있습니다.
3. 데코레이터는 명명 된 또는 명명되지 않은 매개 변수가있는 함수를 허용합니다.
4. 블록 타이밍에서 인쇄를 비활성화하는 기능 (사용 with utils.MeasureBlockTime() as t후 t.elapsed).
5. 블록 타이밍에 gc를 유지하는 기능.

time.time실행을 측정하는 데 사용하면 컴퓨터의 다른 프로세스에서 소비 한 실행 시간을 포함하여 명령의 전체 실행 시간이 제공됩니다. 사용자가 통지하는 시간이지만 다른 코드 스 니펫 / 알고리즘 / 함수 / ...를 비교하려는 경우 좋지 않습니다.

에 대한 추가 정보 timeit:

• timeit 모듈 사용
• timeit – 작은 비트의 Python 코드 실행 시간

프로파일 링에 대한 더 깊은 통찰력을 원한다면 :

• http://wiki.python.org/moin/PythonSpeed/PerformanceTips#Profiling_Code
• 파이썬 스크립트를 어떻게 프로파일 링 할 수 있습니까?

업데이트 : 작년에 http://pythonhosted.org/line_profiler/ 를 많이 사용 했으며 매우 유용하다는 것을 알았 으므로 Pythons 프로파일 모듈 대신 사용하는 것이 좋습니다.

다음은 "hh : mm : ss"문자열을 반환하는 작은 타이머 클래스입니다.

class Timer:
  def __init__(self):
    self.start = time.time()

  def restart(self):
    self.start = time.time()

  def get_time_hhmmss(self):
    end = time.time()
    m, s = divmod(end - self.start, 60)
    h, m = divmod(m, 60)
    time_str = "%02d:%02d:%02d" % (h, m, s)
    return time_str

용법:

# Start timer
my_timer = Timer()

# ... do something

# Get time string:
time_hhmmss = my_timer.get_time_hhmmss()
print("Time elapsed: %s" % time_hhmmss )

# ... use the timer again
my_timer.restart()

# ... do something

# Get time:
time_hhmmss = my_timer.get_time_hhmmss()

# ... etc

python cProfile 및 pstats 모듈은 기존 함수 주위에 코드를 추가하지 않고도 특정 함수에서 경과 된 시간을 측정 할 수 있도록 지원합니다.

예를 들어, 파이썬 스크립트 timeFunctions.py가있는 경우 :

import time

def hello():
    print "Hello :)"
    time.sleep(0.1)

def thankyou():
    print "Thank you!"
    time.sleep(0.05)

for idx in range(10):
    hello()

for idx in range(100):
    thankyou()

프로파일 러를 실행하고 파일에 대한 통계를 생성하려면 다음을 실행하면됩니다.

python -m cProfile -o timeStats.profile timeFunctions.py

이 작업은 cProfile 모듈을 사용하여 timeFunctions.py의 모든 함수를 프로파일 링하고 timeStats.profile 파일에서 통계를 수집합니다. 기존 모듈 (timeFunctions.py)에 코드를 추가 할 필요가 없었으며 모든 모듈에서 수행 할 수 있습니다.

stats 파일이 있으면 다음과 같이 pstats 모듈을 실행할 수 있습니다.

python -m pstats timeStats.profile

대화 형 통계 브라우저를 실행하여 많은 유용한 기능을 제공합니다. 특정 유스 케이스의 경우 함수 통계를 확인할 수 있습니다. 두 함수 모두에 대한 통계 검사 예에서는 다음을 보여줍니다.

Welcome to the profile statistics browser.
timeStats.profile% stats hello
<timestamp>    timeStats.profile

         224 function calls in 6.014 seconds

   Random listing order was used
   List reduced from 6 to 1 due to restriction <'hello'>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
       10    0.000    0.000    1.001    0.100 timeFunctions.py:3(hello)

timeStats.profile% stats thankyou
<timestamp>    timeStats.profile

         224 function calls in 6.014 seconds

   Random listing order was used
   List reduced from 6 to 1 due to restriction <'thankyou'>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
      100    0.002    0.000    5.012    0.050 timeFunctions.py:7(thankyou)

더미 예제는 그다지 많지 않지만 수행 할 수있는 작업에 대한 아이디어를 제공합니다. 이 방법의 가장 좋은 점은 기존 코드를 편집하지 않아도 숫자를 얻고 프로파일 링에 도움을 줄 수 있다는 것입니다.

타이밍 코드에 대한 또 다른 컨텍스트 관리자는 다음과 같습니다.

용법:

from benchmark import benchmark

with benchmark("Test 1+1"):
    1+1
=>
Test 1+1 : 1.41e-06 seconds

또는 시간 값이 필요한 경우

with benchmark("Test 1+1") as b:
    1+1
print(b.time)
=>
Test 1+1 : 7.05e-07 seconds
7.05233786763e-07

benchmark.py :

from timeit import default_timer as timer

class benchmark(object):

    def __init__(self, msg, fmt="%0.3g"):
        self.msg = msg
        self.fmt = fmt

    def __enter__(self):
        self.start = timer()
        return self

    def __exit__(self, *args):
        t = timer() - self.start
        print(("%s : " + self.fmt + " seconds") % (self.msg, t))
        self.time = t

http://dabeaz.blogspot.fr/2010/02/context-manager-for-timing-benchmarks.html 에서 적응

프로파일 러 모듈을 사용하십시오. 매우 상세한 프로필을 제공합니다.

import profile
profile.run('main()')

그것은 다음과 같은 것을 출력합니다 :

          5 function calls in 0.047 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    0.000    0.000 :0(exec)
        1    0.047    0.047    0.047    0.047 :0(setprofile)
        1    0.000    0.000    0.000    0.000 <string>:1(<module>)
        0    0.000             0.000          profile:0(profiler)
        1    0.000    0.000    0.047    0.047 profile:0(main())
        1    0.000    0.000    0.000    0.000 two_sum.py:2(twoSum)

나는 매우 유익한 것을 발견했습니다.

내가 좋아하는 간단한 (파이썬 3)

from timeit import timeit

timeit(lambda: print("hello"))

단일 실행에 대한 출력은 마이크로 초 입니다.

2.430883963010274

설명 : timeit은 기본적으로 익명 함수를 백만 번 실행 하고 결과는 초 단위 로 제공됩니다 . 따라서 1 회의 단일 실행 결과 는 동일한 양이지만 평균 마이크로 초 입니다.

들어 느린 동작 낮은 추가 할 수 반복 또는 당신은 영원히 기다리고있을 수 있습니다 :

import time

timeit(lambda: time.sleep(1.5), number=1)

총 반복 횟수 에 대한 출력은 항상 초 단위 입니다 .

1.5015795179999714

(Ipython 만 해당) % timeit 을 사용 하여 평균 처리 시간을 측정 할 수 있습니다 .

def foo():
    print "hello"

그리고:

%timeit foo()

결과는 다음과 같습니다.

10000 loops, best of 3: 27 µs per loop

timeit 을 사용하는 또 다른 방법 :

from timeit import timeit

def func():
    return 1 + 1

time = timeit(func, number=1)
print(time)

python3에서 :

from time import sleep, perf_counter as pc
t0 = pc()
sleep(1)
print(pc()-t0)

우아하고 짧습니다.

나중에 슈퍼 응답의 종류,하지만 그것은 누군가를위한 목적을 제공합니다. 이것은 내가 깨끗하다고 ​​생각하는 방법입니다.

import time

def timed(fun, *args):
    s = time.time()
    r = fun(*args)
    print('{} execution took {} seconds.'.format(fun.__name__, time.time()-s))
    return(r)

timed(print, "Hello")

"print"는 Python 2.7이 아니라 Python 3의 함수입니다. 그러나 다른 기능과 함께 작동합니다. 건배!

timeit을 사용할 수 있습니다.

다음은 Python REPL을 사용하여 매개 변수를 사용하는 naive_func를 테스트하는 방법에 대한 예입니다.

>>> import timeit                                                                                         

>>> def naive_func(x):                                                                                    
...     a = 0                                                                                             
...     for i in range(a):                                                                                
...         a += i                                                                                        
...     return a                                                                                          

>>> def wrapper(func, *args, **kwargs):                                                                   
...     def wrapper():                                                                                    
...         return func(*args, **kwargs)                                                                  
...     return wrapper                                                                                    

>>> wrapped = wrapper(naive_func, 1_000)                                                                  

>>> timeit.timeit(wrapped, number=1_000_000)                                                              
0.4458435332577161  

함수에 매개 변수가없는 경우 랩퍼 기능이 필요하지 않습니다.

시간을 사람이 읽을 수있는 시간으로 변환 할 수도 있습니다.

import time, datetime

start = time.clock()

def num_multi1(max):
    result = 0
    for num in range(0, 1000):
        if (num % 3 == 0 or num % 5 == 0):
            result += num

    print "Sum is %d " % result

num_multi1(1000)

end = time.clock()
value = end - start
timestamp = datetime.datetime.fromtimestamp(value)
print timestamp.strftime('%Y-%m-%d %H:%M:%S')

이것을 위해 라이브러리를 만들었습니다. 함수를 측정하려면 다음과 같이하면됩니다.

from pythonbenchmark import compare, measure
import time

a,b,c,d,e = 10,10,10,10,10
something = [a,b,c,d,e]

@measure
def myFunction(something):
    time.sleep(0.4)

@measure
def myOptimizedFunction(something):
    time.sleep(0.2)

myFunction(input)
myOptimizedFunction(input)

https://github.com/Karlheinzniebuhr/pythonbenchmark

모든 함수 호출에 대해 재귀 적으로 통찰력을 얻으려면 다음을 수행하십시오.

%load_ext snakeviz
%%snakeviz

Jupyter 노트북 에서 2 줄의 코드 만 가져 가면 멋진 대화 형 다이어그램이 생성됩니다. 예를 들면 다음과 같습니다.

코드는 다음과 같습니다. 다시 시작으로, 2 줄 %은 snakeviz를 사용하는 데 필요한 유일한 추가 코드 줄입니다.

# !pip install snakeviz
%load_ext snakeviz
import glob
import hashlib

%%snakeviz

files = glob.glob('*.txt')
def print_files_hashed(files):
    for file in files:
        with open(file) as f:
            print(hashlib.md5(f.read().encode('utf-8')).hexdigest())
print_files_hashed(files)

노트북 외부에서 snakeviz를 실행할 수도 있습니다. snakeviz 웹 사이트 에 대한 추가 정보 .

import time

def getElapsedTime(startTime, units):
    elapsedInSeconds = time.time() - startTime
    if units == 'sec':
        return elapsedInSeconds
    if units == 'min':
        return elapsedInSeconds/60
    if units == 'hour':
        return elapsedInSeconds/(60*60)

이 고유 한 클래스 기반 접근 방식은 인쇄 가능한 문자열 표현, 사용자 정의 가능한 반올림 및 경과 시간에 문자열 또는 부동으로 편리하게 액세스 할 수 있습니다. Python 3.7로 개발되었습니다.

import datetime
import timeit


class Timer:
    """Measure time used."""
    # Ref: https://stackoverflow.com/a/57931660/

    def __init__(self, round_ndigits: int = 0):
        self._round_ndigits = round_ndigits
        self._start_time = timeit.default_timer()

    def __call__(self) -> float:
        return timeit.default_timer() - self._start_time

    def __str__(self) -> str:
        return str(datetime.timedelta(seconds=round(self(), self._round_ndigits)))

용법:

# Setup timer
>>> timer = Timer()

# Access as a string
>>> print(f'Time elapsed is {timer}.')
Time elapsed is 0:00:03.
>>> print(f'Time elapsed is {timer}.')
Time elapsed is 0:00:04.

# Access as a float
>>> timer()
6.841332235
>>> timer()
7.970274425

작은 코드 스 니펫의 실행 시간을 측정하십시오.

시간 단위 : 부동 소수점으로 초 단위로 측정

import timeit
t = timeit.Timer('li = list(map(lambda x:x*2,[1,2,3,4,5]))')
t.timeit()
t.repeat()
>[1.2934070999999676, 1.3335035000000062, 1.422568500000125]

repeat () 메소드는 timeit ()를 여러 번 호출하고 결과 목록을 리턴하는 데 편리합니다.

repeat(repeat=3)¶

이 목록을 통해 우리는 항상 의미를 가질 수 있습니다.

기본적으로 timeit ()는 타이밍 동안 가비지 수집을 일시적으로 해제합니다. time.Timer ()는이 문제를 해결합니다.

장점 :

timeit.Timer ()는 독립적 인 타이밍을 더 비슷하게 만듭니다. gc는 측정되는 기능 수행의 중요한 구성 요소 일 수있다. 그렇다면 gc (garbage collector)는 설정 문자열에서 첫 번째 명령문으로 다시 활성화 할 수 있습니다. 예를 들면 다음과 같습니다.

timeit.Timer('li = list(map(lambda x:x*2,[1,2,3,4,5]))',setup='gc.enable()')

소스 파이썬 문서 !

함수를 편리하게 시간에 맞추고 싶다면 간단한 데코레이터를 사용할 수 있습니다.

def timing_decorator(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        original_return_val = func(*args, **kwargs)
        end = time.time()
        print("time elapsed in ", func.__name__, ": ", end - start, sep='')
        return original_return_val

    return wrapper

다음과 같이 시간을 정하려는 함수에서 사용할 수 있습니다.

@timing_decorator
def function_to_time():
    time.sleep(1)

그런 다음을 호출 할 때마다 시간 function_to_time과 함수 이름이 인쇄됩니다.

에 의해 주어진 contextmanager 솔루션을 기반으로 https://stackoverflow.com/a/30024601/5095636 flake8가 당 람다의 사용에 대한 경고로서, 이하 람다 무료 버전, E731 :

from contextlib import contextmanager
from timeit import default_timer

@contextmanager
def elapsed_timer():
    start_time = default_timer()

    class _Timer():
      start = start_time
      end = default_timer()
      duration = end - start

    yield _Timer

    end_time = default_timer()
    _Timer.end = end_time
    _Timer.duration = end_time - start_time

테스트:

from time import sleep

with elapsed_timer() as t:
    print("start:", t.start)
    sleep(1)
    print("end:", t.end)

t.start
t.end
t.duration

다음은 일반적인 유틸리티로 사용하는 잘 문서화되고 완전한 유형의 힌트 데코레이터입니다.

from functools import wraps
from time import perf_counter
from typing import Any, Callable, Optional, TypeVar, cast

F = TypeVar("F", bound=Callable[..., Any])


def timer(prefix: Optional[str] = None, precision: int = 6) -> Callable[[F], F]:
    """Use as a decorator to time the execution of any function.

    Args:
        prefix: String to print before the time taken.
            Default is the name of the function.
        precision: How many decimals to include in the seconds value.

    Examples:
        >>> @timer()
        ... def foo(x):
        ...     return x
        >>> foo(123)
        foo: 0.000...s
        123
        >>> @timer("Time taken: ", 2)
        ... def foo(x):
        ...     return x
        >>> foo(123)
        Time taken: 0.00s
        123

    """
    def decorator(func: F) -> F:
        @wraps(func)
        def wrapper(*args: Any, **kwargs: Any) -> Any:
            nonlocal prefix
            prefix = prefix if prefix is not None else f"{func.__name__}: "
            start = perf_counter()
            result = func(*args, **kwargs)
            end = perf_counter()
            print(f"{prefix}{end - start:.{precision}f}s")
            return result
        return cast(F, wrapper)
    return decorator

사용법 예 :

from timer import timer


@timer(precision=9)
def takes_long(x: int) -> bool:
    return x in (i for i in range(x + 1))


print(takes_long(10**8))

산출:

takes_long: 4.942629056s
True

doctest는 다음을 통해 확인할 수 있습니다.

$ python3 -m doctest --verbose -o=ELLIPSIS timer.py

그리고 유형 힌트는 다음과 같습니다.

$ mypy timer.py

내가 생각할 수있는 유일한 방법은을 사용하는 것입니다 time.time().

import time
start = time.time()
sleep(5) #just to give it some delay to show it working
finish = time.time()
elapsed = finish - start
print(elapsed)

도움이 되길 바랍니다.