파이썬 프로그램 실행 시간을 어떻게 얻습니까?

파이썬에 명령 행 프로그램이 있는데 완료하는 데 시간이 걸립니다. 달리는 데 걸리는 정확한 시간을 알고 싶습니다.

timeit모듈을 살펴 보았지만 작은 코드 조각만을위한 것 같습니다. 전체 프로그램의 시간을 정하고 싶습니다.

파이썬에서 가장 간단한 방법 :

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

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

인쇄물:

--- 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 명령 행에서 명령의 실행 시간을 어떻게 측정합니까?를 참조하십시오.

더 자세한 출력을 위해

$ 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

나는 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에서). 문서는 "어쨌든 이것은 파이썬 또는 타이밍 알고리즘 벤치마킹에 사용하는 기능"이라고 말합니다.

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

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}

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

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)

timeit모듈 만 사용하십시오 . 파이썬 2와 파이썬 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

초 단위로 반환되며 실행 시간을 가질 수 있습니다. 간단하지만 프로그램 실행을 시작하는 주요 기능으로 작성해야합니다. 오류가 발생하더라도 실행 시간을 얻으려면 매개 변수 "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))

다음 코드 조각은 사람이 읽을 수있는 <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)    

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)

에서 IPython "timeit"모든 스크립트 :

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

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()각 함수에 대한 CPU 시간을 측정하려면 (예 : 시간 동안 포함하지 않음 ) Python 2에서 profile모듈을 사용할 수 있습니다 cProfile.

$ python3 -mprofile your_module.py

당신은 전달할 수 -p에 timeit당신과 같은 타이머 사용하려는 경우 위의 명령 profile모듈을 사용합니다.

Python 스크립트를 프로파일 링하는 방법을 참조하십시오 .

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

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.

timeit파이썬 코드의 실행 시간을 시간을 정하는 데 사용할 수 있는 모듈이 있습니다.

파이썬 문서 26.6 에 자세한 문서와 예제가 있습니다. timeit — 작은 코드 스 니펫의 실행 시간을 측정 합니다.

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

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

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'

여러 곳에서 동일한 문제가 발생하여 편의 패키지를 만들었습니다 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 이상에서 작동합니다.

이것은 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)

나중에 대답하지만 다음을 사용합니다 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 인수는 코드를 반복해야하는 횟수를 지정합니다.
• 데모

파이썬 프로그램의 실행 측정 시간은 다음에 따라 일치하지 않을 수 있습니다.

• 다른 알고리즘을 사용하여 동일한 프로그램을 평가할 수 있습니다
• 실행 시간은 알고리즘마다 다릅니다.
• 실행 시간은 구현마다 다릅니다.
• 실행 시간은 컴퓨터마다 다릅니다
• 작은 입력으로 실행 시간을 예측할 수 없음

가장 효과적인 방법은 "성장의 순서"를 사용하고 큰 "O"표기법을 배우기 때문입니다 하고 제대로 수행하기 위해 을 때문입니다.

어쨌든이 간단한 알고리즘을 사용하여 초당 특정 머신 계산 단계에서 모든 Python 프로그램의 성능을 평가하려고 시도 할 수 있습니다. 평가하려는 프로그램에 적용하십시오 .

import time

now = time.time()
future = now + 10
step = 4 # Why 4 steps? Because until here already four operations executed
while time.time() < future:
    step += 3 # Why 3 again? Because a while loop executes one comparison and one plus equal statement
step += 4 # Why 3 more? Because one comparison starting while when time is over plus the final assignment of step + 1 and print statement
print(str(int(step / 10)) + " steps per second")

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

import time

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

@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

먼저 관리자 권한으로 명령 프롬프트 (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))

산출:

Python 2.7에 metakermit의 업데이트 된 답변 을 사용하려면 단조로운 패키지 가 필요합니다 .

코드는 다음과 같습니다.

from datetime import timedelta
from monotonic import monotonic

start_time = monotonic()
end_time = monotonic()
print(timedelta(seconds=end_time - start_time))

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

import time

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

마이크로 초 단위로 시간을 측정하려면 Paul McGuire 와 Nicojo 의 답변을 기반으로 다음 버전을 사용할 수 있습니다 . Python 3 코드입니다. 나는 또한 그것에 약간의 색상을 추가했습니다 :

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 ==> 파이썬 모듈은 프로그램이 종료 될 때 호출 할 수있는 함수를 등록합니다.