파이썬 프로그램 실행 시간을 어떻게 얻습니까?
완료하는 데 시간이 걸리는 Python 명령 줄 프로그램이 있습니다. 달리기를 마치는 데 걸리는 정확한 시간을 알고 싶습니다.
timeit모듈을 살펴 보았지만 작은 코드 조각만을위한 것 같습니다. 전체 프로그램의 시간을 측정하고 싶습니다.
Python에서 가장 간단한 방법 :
import time
start_time = time.time()
main()
print("--- %s seconds ---" % (time.time() - start_time))
프로그램을 실행하는 데 최소 1/10 초가 걸린다고 가정합니다.
인쇄물:
--- 0.764891862869 seconds ---
이 timing.py모듈을 내 site-packages디렉토리에 넣고 import timing모듈 맨 위에 삽입 합니다.
import atexit
from time import clock
def secondsToStr(t):
return "%d:%02d:%02d.%03d" % \
reduce(lambda ll,b : divmod(ll[0],b) + ll[1:],
[(t*1000,),1000,60,60])
line = "="*40
def log(s, elapsed=None):
print line
print secondsToStr(clock()), '-', s
if elapsed:
print "Elapsed time:", elapsed
print line
print
def endlog():
end = clock()
elapsed = end-start
log("End Program", secondsToStr(elapsed))
def now():
return secondsToStr(clock())
start = clock()
atexit.register(endlog)
log("Start Program")
내가 timing.log보여주고 싶은 프로그램에 중요한 단계가 있으면 내 프로그램에서 전화 를 걸 수도 있습니다 . 그러나 포함 만하면 import timing시작 및 종료 시간과 전체 경과 시간이 인쇄됩니다. (내 모호한 secondsToStr함수를 용서하십시오 . 부동 소수점 수 초를 hh : mm : ss.sss 형식으로 포맷합니다.)
참고 : 위 코드의 Python 3 버전은 여기 또는 여기 에서 찾을 수 있습니다 .
Linux 또는 UNIX :
time python yourprogram.py
Windows에서는 다음 Stackoverflow 토론을 참조하십시오. Windows 명령 줄에서 명령 실행 시간을 측정하는 방법은 무엇입니까?
나는 Paul McGuire의 대답을 정말 좋아 하지만 Python 3을 사용합니다. 따라서 관심있는 사람들을 위해 다음은 * nix의 Python 3에서 작동하는 그의 대답의 수정입니다 (Windows에서 clock()대신 사용해야 한다고 상상 합니다 time()).
#python3
import atexit
from time import time, strftime, localtime
from datetime import timedelta
def secondsToStr(elapsed=None):
if elapsed is None:
return strftime("%Y-%m-%d %H:%M:%S", localtime())
else:
return str(timedelta(seconds=elapsed))
def log(s, elapsed=None):
line = "="*40
print(line)
print(secondsToStr(), '-', s)
if elapsed:
print("Elapsed time:", elapsed)
print(line)
print()
def endlog():
end = time()
elapsed = end-start
log("End Program", secondsToStr(elapsed))
start = time()
atexit.register(endlog)
log("Start Program")
이것이 유용하다고 생각되면 그가 대부분의 작업을 수행했듯이이 답변 대신 그의 답변에 대해 여전히 찬성 투표를해야합니다;).
import time
start_time = time.clock()
main()
print time.clock() - start_time, "seconds"
time.clock()프로세서 시간을 반환하므로이 프로세스에서 사용하는 시간 만 계산할 수 있습니다 (어쨌든 Unix에서). 문서에는 "어쨌든 이것은 Python 또는 타이밍 알고리즘을 벤치마킹하는 데 사용할 함수입니다"라고 말합니다.
파이썬 프로파일 러 cProfile을 사용하여 CPU 시간 과 추가로 각 함수 내에서 소비 된 시간과 각 함수가 호출되는 횟수 를 측정 할 수 있습니다 . 시작 위치를 모르고 스크립트의 성능을 향상시키려는 경우 매우 유용합니다. 이 답변 다른 SO 질문에 꽤 좋다. 문서를 살펴 보는 것도 항상 좋습니다 .
다음은 명령 줄에서 cProfile을 사용하여 스크립트를 프로파일 링하는 방법의 예입니다.
$ python -m cProfile euler048.py
1007 function calls in 0.061 CPU seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.000 0.000 0.061 0.061 <string>:1(<module>)
1000 0.051 0.000 0.051 0.000 euler048.py:2(<lambda>)
1 0.005 0.005 0.061 0.061 euler048.py:2(<module>)
1 0.000 0.000 0.061 0.061 {execfile}
1 0.002 0.002 0.053 0.053 {map}
1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler objects}
1 0.000 0.000 0.000 0.000 {range}
1 0.003 0.003 0.003 0.003 {sum}
나는 datetime모듈이 제공 하는 출력을 좋아하는데 , 시간 델타 객체는 사람이 읽을 수있는 방식으로 필요에 따라 일, 시간, 분 등을 표시합니다.
예를 들면 :
from datetime import datetime
start_time = datetime.now()
# do your work here
end_time = datetime.now()
print('Duration: {}'.format(end_time - start_time))
샘플 출력 예
Duration: 0:00:08.309267
또는
Duration: 1 day, 1:51:24.269711
업데이트 : JF Sebastian이 언급했듯이이 접근 방식은 현지 시간에 따라 까다로운 경우가 발생할 수 있으므로 사용하는 것이 더 안전합니다.
import time
from datetime import timedelta
start_time = time.monotonic()
end_time = time.monotonic()
print(timedelta(seconds=end_time - start_time))
Linux에 더 적합합니다. /usr/bin/time
$ /usr/bin/time -v python rhtest2.py
Command being timed: "python rhtest2.py"
User time (seconds): 4.13
System time (seconds): 0.07
Percent of CPU this job got: 91%
Elapsed (wall clock) time (h:mm:ss or m:ss): 0:04.58
Average shared text size (kbytes): 0
Average unshared data size (kbytes): 0
Average stack size (kbytes): 0
Average total size (kbytes): 0
Maximum resident set size (kbytes): 0
Average resident set size (kbytes): 0
Major (requiring I/O) page faults: 15
Minor (reclaiming a frame) page faults: 5095
Voluntary context switches: 27
Involuntary context switches: 279
Swaps: 0
File system inputs: 0
File system outputs: 0
Socket messages sent: 0
Socket messages received: 0
Signals delivered: 0
Page size (bytes): 4096
Exit status: 0
일반적으로 time더 많은 기능을 제공하는 더 간단한 쉘 내장입니다 /usr/bin/time.
rogeriopvl 의 솔루션은 잘 작동하지만 더 구체적인 정보를 원한다면 Python 내장 프로파일 러를 사용할 수 있습니다. 이 페이지를 확인하십시오 :
http://docs.python.org/library/profile.html
프로파일 러는 모든 기능에 소요 된 시간과 같은 유용한 정보를 많이 알려줍니다.
time.clock ()
버전 3.3부터 폐지 :이 함수의 동작은 플랫폼 에 따라 다릅니다. 잘 정의 된 동작을 가지려면 요구 사항에 따라 perf_counter () 또는 process_time ()을 대신 사용하십시오.
time.perf_counter ()
성능 카운터, 즉 짧은 기간을 측정하기 위해 사용 가능한 가장 높은 해상도를 가진 시계의 값 (분수 초)을 반환합니다. 여기 에는 수면 중 경과 된 시간 이 포함되며 시스템 전체에 적용됩니다.
time.process_time ()
현재 프로세스의 시스템 및 사용자 CPU 시간의 합계 값 (분수 초)을 반환합니다. 그것은 하지 않습니다 수면 중에 경과 된 시간을 포함한다.
start = time.process_time()
... do something
elapsed = (time.process_time() - start)
다음 스 니펫은 사람이 읽을 수있는 <HH:MM:SS>형식으로 경과 시간을 인쇄 합니다.
import time
from datetime import timedelta
start_time = time.time()
#
# Perform lots of computations.
#
elapsed_time_secs = time.time() - start_time
msg = "Execution took: %s secs (Wall clock time)" % timedelta(seconds=round(elapsed_time_secs))
print(msg)
timeit모듈을 사용하십시오 . Python 2 및 Python 3 모두에서 작동합니다.
import timeit
start = timeit.default_timer()
#ALL THE PROGRAM STATEMETNS
stop = timeit.default_timer()
execution_time = stop - start
print("Program Executed in "+execution_time) #It returns time in sec
초 안에 반환되며 실행 시간을 가질 수 있습니다. 간단하지만 프로그램 실행을 시작하는 Main Function에 작성해야합니다. 오류가 발생한 경우에도 실행 시간을 얻으려면 매개 변수 "시작"을 가져 와서 다음과 같이 계산하십시오.
def sample_function(start,**kwargs):
try:
#your statements
Except:
#Except Statements
stop = timeit.default_timer()
execution_time = stop - start
print("Program Executed in "+execution_time)
timeit 모듈을 살펴 보았지만 작은 코드 조각만을위한 것 같습니다. 전체 프로그램의 시간을 측정하고 싶습니다.
$ python -mtimeit -n1 -r1 -t -s "from your_module import main" "main()"
your_module.main()기능을 한 번 실행 time.time()하고 타이머 기능을 사용하여 경과 시간을 인쇄합니다 .
/usr/bin/timePython에서 에뮬레이트하려면 / usr / bin / time을 사용하는 Python 하위 프로세스 : 타이밍 정보를 캡처하지만 다른 모든 출력을 무시하는 방법은 무엇입니까? .
time.sleep()각 함수의 CPU 시간을 측정하려면 (예 : 동안 시간을 포함하지 않음 ) profilemodule ( cProfilePython 2에서)을 사용할 수 있습니다 .
$ python3 -mprofile your_module.py
당신은 전달할 수 -p에 timeit당신과 같은 타이머 사용하려는 경우 위의 명령 profile모듈을 사용합니다.
Python 스크립트를 어떻게 프로파일 링 할 수 있습니까?를 참조하십시오 .
Ipython "timeit"모든 스크립트 :
def foo():
%run bar.py
timeit foo()
from time import time
start_time = time()
...
end_time = time()
time_taken = end_time - start_time # time_taken is in seconds
hours, rest = divmod(time_taken,3600)
minutes, seconds = divmod(rest, 60)
timeit파이썬 코드의 실행 시간을 측정하는 데 사용할 수 있는 모듈이 있습니다. 파이썬 문서 ( https://docs.python.org/2/library/timeit.html ) 에 자세한 문서와 예제가 있습니다.
나는 Paul McGuire의 대답도 좋아하고 내 필요에 더 적합한 컨텍스트 관리자 양식을 생각해 냈습니다.
import datetime as dt
import timeit
class TimingManager(object):
"""Context Manager used with the statement 'with' to time some execution.
Example:
with TimingManager() as t:
# Code to time
"""
clock = timeit.default_timer
def __enter__(self):
"""
"""
self.start = self.clock()
self.log('\n=> Start Timing: {}')
return self
def __exit__(self, exc_type, exc_val, exc_tb):
"""
"""
self.endlog()
return False
def log(self, s, elapsed=None):
"""Log current time and elapsed time if present.
:param s: Text to display, use '{}' to format the text with
the current time.
:param elapsed: Elapsed time to display. Dafault: None, no display.
"""
print s.format(self._secondsToStr(self.clock()))
if(elapsed is not None):
print 'Elapsed time: {}\n'.format(elapsed)
def endlog(self):
"""Log time for the end of execution with elapsed time.
"""
self.log('=> End Timing: {}', self.now())
def now(self):
"""Return current elapsed time as hh:mm:ss string.
:return: String.
"""
return str(dt.timedelta(seconds = self.clock() - self.start))
def _secondsToStr(self, sec):
"""Convert timestamp to h:mm:ss string.
:param sec: Timestamp.
"""
return str(dt.datetime.fromtimestamp(sec))
line_profiler를 사용하십시오 .
line_profiler는 코드의 개별 라인이 실행되는 데 걸리는 시간을 프로파일 링합니다. 프로파일 러는 프로파일 링의 오버 헤드를 줄이기 위해 Cython을 통해 C로 구현됩니다.
from line_profiler import LineProfiler
import random
def do_stuff(numbers):
s = sum(numbers)
l = [numbers[i]/43 for i in range(len(numbers))]
m = ['hello'+str(numbers[i]) for i in range(len(numbers))]
numbers = [random.randint(1,100) for i in range(1000)]
lp = LineProfiler()
lp_wrapper = lp(do_stuff)
lp_wrapper(numbers)
lp.print_stats()
결과는 다음과 같습니다.
Timer unit: 1e-06 s
Total time: 0.000649 s
File: <ipython-input-2-2e060b054fea>
Function: do_stuff at line 4
Line # Hits Time Per Hit % Time Line Contents
==============================================================
4 def do_stuff(numbers):
5 1 10 10.0 1.5 s = sum(numbers)
6 1 186 186.0 28.7 l = [numbers[i]/43 for i in range(len(numbers))]
7 1 453 453.0 69.8 m = ['hello'+str(numbers[i]) for i in range(len(numbers))]
Jupyter 노트북을 사용하는 데이터 사용자를 위해
셀에서 Jupyter의 %%time매직 명령을 사용하여 실행 시간을 측정 할 수 있습니다 .
%%time
[ x**2 for x in range(10000)]
출력
CPU 시간 : 사용자 4.54ms, sys : 0ns, 총 : 4.54ms
벽 시간 : 4.12ms
이것은 특정 셀의 실행 시간 만 캡처합니다. 전체 노트북 (예 : 프로그램)의 실행 시간을 캡처하려면 동일한 디렉토리에 새 노트북을 만들고 새 노트북에서 모든 셀을 실행할 수 있습니다.
위의 노트북이라고 가정합니다 example_notebook.ipynb. 동일한 디렉토리 내의 새 노트북에서 :
# Convert your notebook to a .py script:
!jupyter nbconvert --to script example_notebook.ipynb
# Run the example_notebook with -t flag for time
%run -t example_notebook
출력
IPython CPU 타이밍 (예상) : 사용자 : 0.00 초.
시스템 : 0.00 s.
벽 시간 : 0.00 초
코드 실행의 일부를 타이밍하는 데 매우 간단한 함수를 사용했습니다.
import time
def timing():
start_time = time.time()
return lambda x: print("[{:.2f}s] {}".format(time.time() - start_time, x))
그리고 그것을 사용하려면 측정 할 코드 앞에 호출하여 타이밍 함수를 검색 한 다음 코드 뒤에 주석이있는 함수를 호출하면 시간이 주석 앞에 표시됩니다. 예를 들면 다음과 같습니다.
t = timing()
train = pd.read_csv('train.csv',
dtype={
'id': str,
'vendor_id': str,
'pickup_datetime': str,
'dropoff_datetime': str,
'passenger_count': int,
'pickup_longitude': np.float64,
'pickup_latitude': np.float64,
'dropoff_longitude': np.float64,
'dropoff_latitude': np.float64,
'store_and_fwd_flag': str,
'trip_duration': int,
},
parse_dates = ['pickup_datetime', 'dropoff_datetime'],
)
t("Loaded {} rows data from 'train'".format(len(train)))
그러면 출력은 다음과 같습니다.
[9.35s] Loaded 1458644 rows data from 'train'
이런 식으로 조금 우아하게 느껴집니다.
이것은 나를 위해 일하는 Paul McGuire의 대답입니다. 누군가가 그것을 실행하는 데 문제가있을 경우를 대비하여.
import atexit
from time import clock
def reduce(function, iterable, initializer=None):
it = iter(iterable)
if initializer is None:
value = next(it)
else:
value = initializer
for element in it:
value = function(value, element)
return value
def secondsToStr(t):
return "%d:%02d:%02d.%03d" % \
reduce(lambda ll,b : divmod(ll[0],b) + ll[1:],
[(t*1000,),1000,60,60])
line = "="*40
def log(s, elapsed=None):
print (line)
print (secondsToStr(clock()), '-', s)
if elapsed:
print ("Elapsed time:", elapsed)
print (line)
def endlog():
end = clock()
elapsed = end-start
log("End Program", secondsToStr(elapsed))
def now():
return secondsToStr(clock())
def main():
start = clock()
atexit.register(endlog)
log("Start Program")
timing.main()파일을 가져온 후 프로그램에서 호출 하십시오.
Timeit은 작은 코드 블록의 실행 시간을 계산하는 데 사용되는 Python 클래스입니다.
Default_timer는 CPU 실행 시간이 아닌 벽시계 타이밍을 측정하는 데 사용되는이 클래스의 메서드입니다. 따라서 다른 프로세스 실행이이를 방해 할 수 있습니다. 따라서 작은 코드 블록에 유용합니다.
코드 샘플은 다음과 같습니다.
from timeit import default_timer as timer
start= timer()
#some logic
end = timer()
print("Time taken:", end-start)
Python으로 간단하게 수행합니다. 복잡하게 만들 필요가 없습니다.
import time
start = time.localtime()
end = time.localtime()
"""Total execution time in second$ """
print(end.tm_sec - start.tm_sec)
python 2.7에 대한 metakermit의 업데이트 된 답변 을 사용하려면 monotonic 패키지 가 필요합니다 .
코드는 다음과 같습니다.
from datetime import timedelta
from monotonic import monotonic
start_time = monotonic()
end_time = monotonic()
print(timedelta(seconds=end_time - start_time))
Python 프로그램의 실행 측정 시간은 다음에 따라 일치하지 않을 수 있습니다.
- 다른 알고리즘을 사용하여 동일한 프로그램을 평가할 수 있습니다.
- 알고리즘에 따라 실행 시간이 다릅니다.
- 실행 시간은 구현에 따라 다릅니다.
- 실행 시간은 컴퓨터마다 다릅니다.
- 작은 입력으로 실행 시간을 예측할 수 없습니다.
가장 효과적인 방법은 "성장 순서"를 사용하고 Big "O"표기법을 배우는 것이기 때문입니다. https://en.wikipedia.org/wiki/Big_O_notation
어쨌든이 간단한 알고리즘을 사용하여 초당 특정 기계 계산 단계에서 Python 프로그램의 성능을 평가할 수 있습니다. 평가하려는 프로그램에 맞게 조정하십시오 .
import time
now = time.time()
future = now + 10
step = 4 # why 4 steps? because until here already 4 operations executed
while time.time() < future:
step += 3 # why 3 again? because while loop execute 1 comparison and 1 plus equal statement
step += 4 # why 3 more? because 1 comparison starting while when time is over plus final assignment of step + 1 and print statement
print(str(int(step / 10)) + " steps per second")
도움이 되었기를 바랍니다.
마이크로 초 단위로 시간을 측정하려면 Paul McGuire 와 Nicojo 의 답변을 완전히 기반으로 한 다음 버전을 사용할 수 있습니다 . 이것은 Python3 코드입니다. 나는 또한 그것에 몇 가지 색상을 추가했습니다.
import atexit
from time import time
from datetime import timedelta, datetime
def seconds_to_str(elapsed=None):
if elapsed is None:
return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
else:
return str(timedelta(seconds=elapsed))
def log(txt, elapsed=None):
colour_cyan = '\033[36m'
colour_reset = '\033[0;0;39m'
colour_red = '\033[31m'
print('\n ' + colour_cyan + ' [TIMING]> [' + seconds_to_str() + '] ----> ' + txt + '\n' + colour_reset)
if elapsed:
print("\n " + colour_red + " [TIMING]> Elapsed time ==> " + elapsed + "\n" + colour_reset)
def end_log():
end = time()
elapsed = end-start
log("End Program", seconds_to_str(elapsed))
start = time()
atexit.register(end_log)
log("Start Program")
log () => 타이밍 정보를 출력하는 함수.
txt ==> 로그 할 첫 번째 인수이며 타이밍을 표시하는 문자열입니다.
atexit ==> python 모듈은 프로그램 종료시 호출 할 수있는 함수를 등록합니다.
이것은 프로그램의 경과 시간을 얻는 가장 간단한 방법입니다.
프로그램 끝에 다음 코드를 작성하십시오.
import time
print(time.clock())
참고 URL : https://stackoverflow.com/questions/1557571/how-do-i-get-time-of-a-python-programs-execution
'Programing' 카테고리의 다른 글
| 문자열 내에서 문자열 (실제로 문자)의 발생 횟수를 어떻게 계산합니까? (0) | 2020.09.29 |
|---|---|
| jQuery를 사용하여 드롭 다운 목록의 선택한 값 변경 (0) | 2020.09.29 |
| 시간 초과로 Redux 작업을 전달하는 방법은 무엇입니까? (0) | 2020.09.29 |
| 키로 사전을 정렬하려면 어떻게해야합니까? (0) | 2020.09.29 |
| forEach 루프와 함께 async / await 사용 (0) | 2020.09.29 |