Python에서 경과시간을 측정하려면 어떻게 해야 하나요?
함수를 실행하는 데 걸린 시간을 측정하고 싶습니다. 수 timeit★★★★
import timeit
start = timeit.timeit()
print("hello")
end = timeit.timeit()
print(end - start)
두 점 사이의 경과된 벽 클럭 시간을 측정하는 데 사용합니다.
import time
start = time.time()
print("hello")
end = time.time()
print(end - start)
이것에 의해, 실행 시간이 초단위로 표시됩니다.
Python 3.3 이후의 또 다른 옵션은 요건에 따라 또는 를 사용하는 것일 수 있습니다.3.3 이전 버전에서는 (Amber님 감사합니다)를 사용하는 것이 권장되었습니다.단, 현재는 권장되지 않습니다.
Unix 에서는, 현재의 프로세서 시간을 초단위로 나타내는 부동 소수점 번호로 반환합니다."프로세서 시간"의 의미에 대한 정밀도 및 실제 정의는 같은 이름의 C 함수의 정의에 따라 달라집니다.
에서는, 이 Windows 의 「」, 「」, 「」, 「」에 해, 이에의 최초의 한 월 되돌립니다.
QueryPerformanceCounter()해상도는 보통 1마이크로초보다 우수합니다.버전 3.3 이후 권장되지 않음: 이 기능의 동작은 플랫폼에 따라 달라집니다.사용 또는 요건에 따라 적절하게 정의된 동작을 취할 수 있습니다.
timeit.default_timertimeit.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() vs. time.time() - 정확도를 참조하십시오.
다음 항목도 참조하십시오.
Python 3만:
★★time.clock() Python 3.3에서는 권장되지 않습니다.시스템 전체 타이밍 또는 프로세스 전체 타이밍에 사용할 수 있습니다.사용하던 방식 그대로입니다.time.clock():
import time
t = time.process_time()
#do some stuff
elapsed_time = time.process_time() - t
'''process_time수면 중 경과된 시간은 포함되지 않습니다.
초단위로 시간 측정:
from timeit import default_timer as timer
from datetime import timedelta
start = timer()
# ....
# (your code runs here)
# ...
end = timer()
print(timedelta(seconds=end-start))
출력:
0:00:01.946339
시간을 재고 싶은 기능이 주어지면
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초)을 반환합니다.
아, 네, 네, 아, 네. timeit혼란스러워요.doc은 너무 혼란스러워요.
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 페이지를 참조하십시오.
조작 기간을 계산하는 가장 쉬운 방법은 다음과 같습니다.
import time
start_time = time.monotonic()
<operations, programs>
print('seconds: ', time.monotonic() - start_time)
공식 문서는 여기 있습니다.
여기 많은 좋은 답변들과 몇 가지 다른 기사들을 살펴본 결과들이 있다.
째, 약, between, 만, 면, 면, 면, 면, 면, 면, 면, 면, 면, 면, 면, 면, 면, 면, 면, 면, 면면,timeit ★★★★★★★★★★★★★★★★★」time.time , . . . . . . . .timeit에는 다음 두 가지 장점이 있습니다.
timeitOS 및 Python 버전에서 사용할 수 있는 최적의 타이머를 선택합니다.timeit는 가비지 수집을 디세블로 합니다만, 이것은, 유저가 원하는 것과 원하지 않는 것이 아닙니다.
, 문제는 .timeit셋업이 필요하고 Import가 많으면 상황이 나빠지기 때문에 사용하기 쉽지 않습니다. 데코레이터를 사용하는 with이치노아쉽게도 이 기능에는 사용할 수 있는 기본 제공 기능이 없으므로 다음 두 가지 옵션이 있습니다.
옵션 1: 시간 예산 라이브러리 사용
타임버젯은 범용성이 높고 매우 심플한 라이브러리입니다.pip 설치 후 코드 한 줄만으로 사용할 수 있습니다.
@timebudget # Record how long this function takes
def my_method():
# my code
옵션 2: 소형 모듈 사용
아래에 timing.py이라는 작은 타이밍 유틸리티 모듈을 만들었습니다.이 파일을 프로젝트에 넣고 사용하기만 하면 됩니다.유일한 외부 종속성은 다시 작은 런스태트입니다.
이제 데코레이터를 앞에 놓는 것만으로 어떤 기능에도 시간을 맞출 수 있습니다.
import timing
@timing.MeasureTime
def MyBigFunc():
#do something time consuming
for i in range(10000):
print(i)
timing.print_all_timings()
으로 하고 는, .with 삭제:
import timing
#somewhere in my code
with timing.MeasureBlockTime("MyBlock"):
#do something time consuming
for i in range(10000):
print(i)
# rest of my code
timing.print_all_timings()
장점:
몇 가지 하프백 버전이 떠돌고 있기 때문에 몇 가지 포인트는 다음과 같습니다.
- 앞서 설명한 이유로 time.time 대신 timeit의 timer를 사용합니다.
- 필요에 따라 타이밍 중에 GC를 디세블로 할 수 있습니다.
- Decorator는 이름 있는 또는 이름 없는 매개 변수를 가진 함수를 허용합니다.
- 로 하는 (「사용」을 사용)
with timing.MeasureBlockTime() as t다음에 또 한 번.t.elapsed를 참조해 주세요. - 블록 타이밍에 대해 gc를 이노블로 유지하는 기능.
「」를 사용합니다.time.time실행을 측정하려면 컴퓨터의 다른 프로세스가 보낸 실행 시간을 포함하여 명령의 전체 실행 시간을 제공합니다.사용자가 알아차릴 때이지만 다른 코드 스니펫/알고리즘/함수를 비교하려면 좋지 않습니다.
은, 을 참조해 주세요.timeit:
프로파일링에 대한 자세한 정보가 필요한 경우:
- http://wiki.python.org/moin/PythonSpeed/PerformanceTips#Profiling_Code
- python 스크립트를 프로파일하려면 어떻게 해야 하나요?
업데이트: 작년에 http://pythonhosted.org/line_profiler/을 많이 사용했는데 매우 유용하다고 생각하여 Pythons 프로파일 모듈 대신 사용을 권장합니다.
타이밍 코드의 다른 콘텍스트 매니저는 다음과 같습니다.
사용방법:
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
벤치마크.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)
나는 그것이 매우 유익하다는 것을 알았다.
python cProfile 및 pstats 모듈은 기존 함수 주위에 코드를 추가할 필요 없이 특정 함수에서 경과된 시간을 측정할 수 있는 뛰어난 지원을 제공합니다.
예를 들어 python 스크립트 시간이 있는 경우기능들.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 모듈을 사용하여 모든 기능을 시간 내에 프로파일링합니다.Functions.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)
더미의 예는 별로 도움이 되지 않지만 무엇을 할 수 있는지 알 수 있습니다.이 접근법의 가장 큰 장점은 이러한 번호를 취득하고 프로파일링을 지원하기 위해 기존 코드를 편집할 필요가 없다는 것입니다.
다음은 "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
(Ipython에서만) %timeit을 사용하여 평균 처리 시간을 측정할 수 있습니다.
def foo():
print "hello"
그 후:
%timeit foo()
결과는 다음과 같습니다.
10000 loops, best of 3: 27 µs per loop
심플한 것이 좋다(피톤 3)
from timeit import timeit
timeit(lambda: print("hello"))
1회 실행의 출력은 마이크로초입니다.
2.430883963010274
설명: timeit은 기본적으로 어나니머스 함수를 100만 번 실행하고 결과는 초 단위로 표시됩니다.따라서 1회 실행의 결과는 동일하지만 평균 마이크로초 단위입니다.
동작이 느린 경우 반복 횟수를 줄이지 않으면 영원히 대기할 수 있습니다.
import time
timeit(lambda: time.sleep(1.5), number=1)
총 반복 횟수에 대한 출력은 항상 초 단위입니다.
1.5015795179999714
python3의 경우:
from time import sleep, perf_counter as pc
t0 = pc()
sleep(1)
print(pc()-t0)
우아하고 짧다.
모든 함수 호출을 재귀적으로 파악하려면 다음 절차를 수행합니다.
%load_ext snakeviz
%%snakeviz
이 두 줄의 코드를 Jupyter 노트북에 저장하면 훌륭한 인터랙티브 다이어그램을 생성할 수 있습니다.예를 들어 다음과 같습니다.
여기 암호가 있습니다. 다시 한 번, 이 두에 ''로 하는 두 줄,%사용하기 한 추가 은 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 웹사이트에서 더 많은 정보를 얻을 수 있습니다.
시간을 사용하는 또 다른 방법:
from timeit import timeit
def func():
return 1 + 1
time = timeit(func, number=1)
print(time)
두 작업 사이의 시간을 측정하는 방법.두 작업의 시간을 비교합니다.
import time
b = (123*321)*123
t1 = time.time()
c = ((9999^123)*321)^123
t2 = time.time()
print(t2-t1)
7.987022399902344e-05
여기 제가 일반적인 유틸리티로 사용하는 잘 문서화된 완전한 형태의 힌트 장식기가 있습니다.
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))
result = takes_long(10**8)
print(result)
출력:
takes_long: 4.942629056s True
Doctests는 다음 항목으로 확인할 수 있습니다.
$ python3 -m doctest --verbose -o=ELLIPSIS timer.py
그리고 이 유형은 다음을 암시합니다.
$ mypy timer.py
아주 나중에 하는 반응이지만 누군가에게 도움이 될 수도 있어이것은 매우 깨끗한 방법이라고 생각합니다.
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")
"프린트"는 Python 3의 함수이며 Python 2.7이 아닙니다.다만, 다른 기능에서는 동작합니다.건배!
편리한 기능의 타이밍을 맞추고 싶다면 간단한 데코레이터를 사용할 수 있습니다.
import time
def timing_decorator(func):
def wrapper(*args, **kwargs):
start = time.perf_counter()
original_return_val = func(*args, **kwargs)
end = time.perf_counter()
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()
든지 전화 주세요.function_to_time시간이 얼마나 걸렸는지와 시간 설정 중인 함수의 이름이 표시됩니다.
타임잇을 사용하세요.
다음은 Python REP를 사용하여 파라미터를 취득하는 nave_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
함수에 파라미터가 없는 경우에는 래퍼 기능이 필요하지 않습니다.
print_syslog_time 함수는 다음과 같습니다.
def print_elapsed_time(prefix=''):
e_time = time.time()
if not hasattr(print_elapsed_time, 's_time'):
print_elapsed_time.s_time = e_time
else:
print(f'{prefix} elapsed time: {e_time - print_elapsed_time.s_time:.2f} sec')
print_elapsed_time.s_time = e_time
이렇게 쓰다
print_elapsed_time()
.... heavy jobs ...
print_elapsed_time('after heavy jobs')
.... tons of jobs ...
print_elapsed_time('after tons of jobs')
결과는
after heavy jobs elapsed time: 0.39 sec
after tons of jobs elapsed time: 0.60 sec
이 기능의 장점과 단점은 시작 시간을 넘길 필요가 없다는 것입니다.
우리는 또한 시간을 사람이 읽을 수 있는 시간으로 바꿀 수 있다.
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')
질문에서는 엄밀하게 묻지는 않지만 코드 여러 줄 사이의 경과 시간을 점차적으로 측정할 수 있는 간단하고 균일한 방법을 원하는 경우가 많습니다.
Python 3.8 이상을 사용하는 경우 할당식(해파리 연산자라고도 함)을 사용하여 매우 우아한 방법으로 이를 달성할 수 있습니다.
import time
start, times = time.perf_counter(), {}
print("hello")
times["print"] = -start + (start := time.perf_counter())
time.sleep(1.42)
times["sleep"] = -start + (start := time.perf_counter())
a = [n**2 for n in range(10000)]
times["pow"] = -start + (start := time.perf_counter())
print(times)
=>
{'print': 2.193450927734375e-05, 'sleep': 1.4210970401763916, 'power': 0.005671024322509766}
이것을 위해 라이브러리를 만들었습니다. 함수를 측정하려면 이렇게 하면 됩니다.
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
이 독자적인 클래스 베이스의 어프로치는, 인쇄 가능한 문자열 표현, 커스터마이즈 가능한 반올림, 및 경과시간에 대한 편리한 액세스를 문자열 또는 플로트로 제공합니다.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
언급URL : https://stackoverflow.com/questions/7370801/how-do-i-measure-elapsed-time-in-python
'programing' 카테고리의 다른 글
| 저장소의 개체에 있는 동적 속성을 v-모델로 사용하는 방법은 무엇입니까? (0) | 2023.01.22 |
|---|---|
| datetime php/module에 30분 추가 (0) | 2023.01.22 |
| iframe 액션에서 상위 창 리디렉션 (0) | 2023.01.22 |
| Javascript를 사용하여 현재 도메인 이름 가져오기(경로 등이 아님) (0) | 2023.01.22 |
| 장고: 선택지 값 표시 (0) | 2023.01.22 |