Python 프로그램 실행 시간은 어떻게 얻습니까?

질문자 :john2x

완료하는 데 시간이 걸리는 Python의 명령줄 프로그램이 있습니다. 실행을 완료하는 데 걸리는 정확한 시간을 알고 싶습니다.

timeit 모듈을 보았지만 작은 코드 조각에만 해당되는 것 같습니다. 전체 프로그램의 시간을 측정하고 싶습니다.

Python에서 가장 간단한 방법:

 import time start_time = time.time() main() print("--- %s seconds ---" % (time.time() - start_time))

이것은 프로그램이 실행되는 데 최소 10분의 1초가 걸린다고 가정합니다.

인쇄물:

 --- 0.764891862869 seconds ---

rogeriopvl

이 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 버전은 here 또는 here 에서 찾을 수 있습니다.

PaulMcG

Linux 또는 Unix:

 $ time python yourprogram.py

Windows에서는 이 StackOverflow 질문을 참조하십시오 . Windows 명령줄에서 명령의 실행 시간을 어떻게 측정합니까?

더 자세한 출력을 위해,

 $ time -v python yourprogram.py Command being timed: "python3 yourprogram.py" User time (seconds): 0.08 System time (seconds): 0.02 Percent of CPU this job got: 98% Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.10 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): 9480 Average resident set size (kbytes): 0 Major (requiring I/O) page faults: 0 Minor (reclaiming a frame) page faults: 1114 Voluntary context switches: 0 Involuntary context switches: 22 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

steveha

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

metakermit

import time start_time = time.clock() main() print(time.clock() - start_time, "seconds")

time.clock() 은 프로세서 시간을 반환하므로 이 프로세스에서 사용하는 시간만 계산할 수 있습니다(어쨌든 Unix에서). 문서에는 "어쨌든 이것은 Python 또는 타이밍 알고리즘을 벤치마킹하는 데 사용하는 기능입니다"라고 나와 있습니다.

newacct

내가 정말 좋아 폴 맥과이어의 대답은 ,하지만 난 관심이있는 사람들을위한 파이썬 3 그래서를 사용 : 여기에 * nix에서 스크립트에 파이썬 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")

이것이 유용하다고 생각되면 대부분의 작업을 수행했기 때문에 이것 대신 그의 답변에 여전히 투표를 해야 합니다 ;).

Nicojo

Python 프로파일러 cProfile을 사용하여 CPU 시간 과 추가로 각 함수 내에서 소비된 시간과 각 함수가 호출된 횟수를 측정할 수 있습니다. 이것은 어디서부터 시작해야 할지 모르는 상태에서 스크립트의 성능을 향상시키려는 경우에 매우 유용합니다. 이 답변 다른 스택 오버플로 질문에 꽤 좋다. 문서 도 항상 살펴보는 것이 좋습니다.

다음은 명령줄에서 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}

jacwah

timeit 모듈을 사용하면 됩니다. Python 2 및 Python 3에서 모두 작동합니다.

 import timeit start = timeit.default_timer() # All the program statements stop = timeit.default_timer() execution_time = stop - start print("Program Executed in "+str(execution_time)) # It returns time in seconds

몇 초 안에 반환되며 실행 시간을 가질 수 있습니다. 간단하지만 프로그램 실행을 시작하는 w메인 함수에 작성해야 합니다. 오류가 발생하더라도 실행 시간을 얻으려면 매개변수 "Start"를 가져와서 다음과 같이 계산하십시오.

 def sample_function(start,**kwargs): try: # Your statements except: # except statements run when your statements raise an exception stop = timeit.default_timer() execution_time = stop - start print("Program executed in " + str(execution_time))

Ravi Kumar

Linux에 더 적합: time

 $ 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

u0b34a0f6ae

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)

Yas

Jupyter Notebook을 사용하는 데이터 사용자를 위해

셀에서 Jupyter의 %%time 매직 명령을 사용하여 실행 시간을 측정할 수 있습니다.

 %%time [ x**2 for x in range(10000)]

산출

 CPU times: user 4.54 ms, sys: 0 ns, total: 4.54 ms Wall time: 4.12 ms

이것은 특정 셀의 실행 시간만 캡처합니다. 전체 노트북(예: 프로그램)의 실행 시간을 캡처하려면 동일한 디렉토리에 새 노트북을 만들고 새 노트북에서 모든 셀을 실행할 수 있습니다.

위의 노트북이 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 timings (estimated): User : 0.00 s. System : 0.00 s. Wall time: 0.00 s.

Matt

다음 스니펫은 사람이 읽을 수 있는 멋진 <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)

Sandeep

@rogeriopvl의 응답과 유사하게 장기 실행 작업에 대해 동일한 라이브러리를 사용하여 시간 분 초로 변환하는 약간의 수정을 추가했습니다.

 import time start_time = time.time() main() seconds = time.time() - start_time print('Time Taken:', time.strftime("%H:%M:%S",time.gmtime(seconds)))

샘플 출력

 Time Taken: 00:00:08

user 923227

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)

Qina Yan

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

Gall

IPython 에서 모든 스크립트를 "timeit"합니다.

 def foo(): %run bar.py timeit foo()

B.Kocis

timeit 모듈을 보았지만 작은 코드 조각에만 해당되는 것 같습니다. 전체 프로그램의 시간을 측정하고 싶습니다.

 $ python -mtimeit -n1 -r1 -t -s "from your_module import main" "main()"

your_module.main() time.time() 함수를 타이머로 사용하여 경과 시간을 인쇄합니다.

/usr/bin/time 을 에뮬레이트하려면 /usr/bin/time을 사용하는 Python 하위 프로세스: 타이밍 정보를 캡처하지만 다른 모든 출력은 무시하는 방법을 참조하세요. .

각 함수에 대한 time.sleep() 동안 시간을 포함하지 않음)을 측정하려면 profile 모듈(Python 2의 cProfile

 $ python3 -mprofile your_module.py

profile 모듈이 사용하는 것과 동일한 타이머를 사용하려면 위의 timeit -p 를 전달할 수 있습니다.

Python 스크립트를 프로파일링하는 방법을 참조하세요.

jfs

나중에 대답하지만 내장 timeit 사용합니다.

 import timeit code_to_test = """ a = range(100000) b = [] for i in a: b.append(i*2) """ elapsed_time = timeit.timeit(code_to_test, number=500) print(elapsed_time) # 10.159821493085474

---

• 가져오기를 포함하여 모든 코드를 code_to_test 내부에 래핑합니다.
• number 인수는 코드가 반복되어야 하는 횟수를 지정합니다.
• 데모

Pedro Lobito

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

Yu Jiaao

코드 실행의 일부 시간을 측정하기 위해 매우 간단한 함수를 사용했습니다.

 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'

Tao Wang

나는 많은 곳에서 같은 문제를 겪고 있었기 때문에 편의 패키지 horology 만들었습니다. pip install horology 한 다음 우아한 방식으로 수행할 수 있습니다.

 from horology import Timing with Timing(name='Important calculations: '): prepare() do_your_stuff() finish_sth()

출력합니다:

 Important calculations: 12.43 ms

또는 더 간단합니다(하나의 기능이 있는 경우):

 from horology import timed @timed def main(): ...

출력합니다:

 main: 7.12 h

단위와 반올림을 처리합니다. 파이썬 3.6 이상에서 작동합니다.

hans

Timeit는 작은 코드 블록의 실행 시간을 계산하는 데 사용되는 Python의 클래스입니다.

Default_timer는 CPU 실행 시간이 아니라 벽시계 타이밍을 측정하는 데 사용되는 이 클래스의 메서드입니다. 따라서 다른 프로세스 실행이 이를 방해할 수 있습니다. 따라서 작은 코드 블록에 유용합니다.

코드 샘플은 다음과 같습니다.

 from timeit import default_timer as timer start= timer() # Some logic end = timer() print("Time taken:", end-start)

Utkarsh Dhawan

먼저 명령 프롬프트(CMD)를 관리자 권한으로 열어서 인간 친화적인 pip install humanfriendly

암호:

 from humanfriendly import format_timespan import time begin_time = time.time() # Put your code here end_time = time.time() - begin_time print("Total execution time: ", format_timespan(end_time))

산출:

Amar Kumar

Python 코드의 실행 시간을 측정하는 데 사용할 수 있는 timeit

Python 문서 26.6에 자세한 문서와 예제가 있습니다. timeit — 작은 코드 조각의 실행 시간을 측정 합니다.

Alfie

이 작업은 단순히 Python에서 수행합니다. 복잡하게 만들 필요가 없습니다.

 import time start = time.localtime() end = time.localtime() """Total execution time in minutes$ """ print(end.tm_min - start.tm_min) """Total execution time in seconds$ """ print(end.tm_sec - start.tm_sec)

Mitul Panchal

함수의 경우 내가 만든 이 간단한 데코레이터를 사용하는 것이 좋습니다.

 def timeit(method): def timed(*args, **kwargs): ts = time.time() result = method(*args, **kwargs) te = time.time() if 'log_time' in kwargs: name = kwargs.get('log_name', method.__name__.upper()) kwargs['log_time'][name] = int((te - ts) * 1000) else: print('%r %2.22f ms' % (method.__name__, (te - ts) * 1000)) return result return timed @timeit def foo(): do_some_work() # foo() # 'foo' 0.000953 ms

Nikita Tonkoskur

다음 스크립트를 사용하여 시간 차이를 시도하고 찾았습니다.

 import time start_time = time.perf_counter() [main code here] print (time.perf_counter() - start_time, "seconds")

Hafez Ahmad

이것은 나를 위해 작동하는 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() 을 호출하십시오.

Saurabh Rana

이것은 프로그램의 경과 시간을 얻는 가장 간단한 방법입니다.

프로그램 끝에 다음 코드를 작성하십시오.

 import time print(time.clock())

Kushal Ghosh

이 답변에 따라 간단하지만 편리한 도구가 만들어졌습니다.

 import time from datetime import timedelta def start_time_measure(message=None): if message: print(message) return time.monotonic() def end_time_measure(start_time, print_prefix=None): end_time = time.monotonic() if print_prefix: print(print_prefix + str(timedelta(seconds=end_time - start_time))) return end_time

용법:

 total_start_time = start_time_measure() start_time = start_time_measure('Doing something...') # Do something end_time_measure(start_time, 'Done in: ') start_time = start_time_measure('Doing something else...') # Do something else end_time_measure(start_time, 'Done in: ') end_time_measure(total_start_time, 'Total time: ')

출력:

 Doing something... Done in: 0:00:01.218000 Doing something else... Done in: 0:00:01.313000 Total time: 0:00:02.672000

Nick Legend

출처 : http:www.stackoverflow.com/questions/1557571/how-do-i-get-time-of-a-python-programs-execution