파이썬 program& # 39 의 실행 시간을 어떻게 해야 합니까?

I have a 명령행을 파이썬 프로그램에 필요한 귈이예요 완료하십시오. 정확한 그런이야길 스크립트종료 데 걸리는 시간이 있습니다.

39, ve i& 티마이트 을 바라볼 수 있지만, '' 모듈에서는 it& # 39 에 대해서만 코드 스니핏 작은 것으로 보인다. I want to time 전체 프로그램.

Peter Mortensen
편집된 질문15일 7월 2017 в 11:43
프로그래밍
python time
12일 10월 2009 в 11:56
31 파운드
해결책

가장 간단한 방법으로 파이썬.

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

여기에서는 는 최소 10 분의 1 초 해당 프로그램을 실행할 수 있습니다.

인쇄:

--- 0.764891862869 seconds ---
Peter Mortensen
편집된 답변15일 7월 2017 в 11:44
해설 (6)

I put my own '이' timing.py '에' 타이밍 '척' 디렉터리입니다 모듈에서는 사이트 패키지 삽입하십시오 임포트합니다 맨 위에 내 모듈에서는:

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

또한 '에서' 나는 내 프로그램의 경우 프로그램 호출하십시오 티밍드로그 상당 부분이 스테이징합니다 보여주고 싶다. 하지만 단지 '타이밍' 는 등 임포트합니다 인쇄인쇄 시작 시간과 종료 시간을, 전체 소요 시간. (그리하면그분께서 내 무명 '세콘드스토스트' 기능을 그냥 형식식 부동 소수점 초 단위로 hh:mm:ss.sss 양식.)

참고: 한 3 위의 코드는 파이썬 버전을 korea. [here] (https://stackoverflow.com/a/12344609/6009280) 또는 [here] (http://pastebin.com/rSqrkLPE).

Community
편집된 답변23일 5월 2017 в 12:26
해설 (7)

Linux, UNIX 에서:

time python yourprogram.py

스택 오버플로 이 슬라이드에서는 Windows 에서는 토론: https://stackoverflow.com/questions/673523/how-to-measure-execution-time-of-command-in-windows-command-line, https://stackoverflow.com/questions/673523/how-to-measure-execution-time-of-command-in-windows-command-line, a href = &quot &lt &quot &gt &lt /a>;;;

해설 (4)

I really like [폴 McGuire& # 39 의 오토메이티드] (https://stackoverflow.com/a/1557906/7851470) 를 사용하고 있지만, 파이썬 3. 그래서 믿음을 보이고 있다. # 39 의 파이썬 3 에 있는 그의 답변은 here& 마시오 수행됨 * nix (I 이매진, Windows 에서 하는 'clock ()' 을 사용해야 하는 시간 () '대신').

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

찾을 수 있다면 이 유용한 합니다 아직 최대 투표 대신 이 번호요 되었고, 그는 대부분의 작업은 그의 답변은 하지 않았다.).

Georgy
편집된 답변23일 9월 2019 в 8:59
해설 (5)
 
import time

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

우리가 할 수 있는 시간을 되돌려줍니다 프로세서입니다 타임스크로크 () ',' 만 계산하십시오 이 과정에 의해 사용되는 시간 (Unix 의 어쨌든). 문서에 따르면, 이 함수를 파이썬 (bmt) 를 사용할 경우 &quot 믿지아니하며 또는 타이밍 algorithms&quot.

해설 (3)

파이썬 프로필러 크프로피레 측정하기 위해 사용할 수 있습니다 또한 얼마나 많은 시간이 소요되는 인사이드라면 CPU 시간 및 각 각 함수의 함수 및 몇 번이나 호출됨. 이것은 매우 유용한 스케쳐내 스크립트입니다 성능 향상을 위해 당신의 위치를 파악하지 못한 채 시작할 수 있습니다. 이 오토메이티드 을 (를) 가 다른 so 질문은 꽤 좋다. # 39 의 it& 이 문서 에서 항상 좋은 모습을 가질 수 없다.

39 의 사용 예는 here& 어떻게 프로필링하려면 스크립트입니다 크프로피레 명령줄에서는:

$ 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 :1()
 1000    0.051    0.000    0.051    0.000 euler048.py:2()
    1    0.005    0.005    0.061    0.061 euler048.py:2()
    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}
해설 (3)

이 모듈은 시간 표시, 여기서 'datetime' i like 출력물에는 델타 객체에는 날짜, 시간 등을 한 분 필요에 따라 사람이 읽을 수 있는 방법입니다.

예를 들면 다음과 같습니다.

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
  • Update:* J. F. 세바스티안 언급한 사례 및 현지 시간) 로, 이 때문에 일부 외곽진입 발생할 수 있는 까다로운 it& # 39 의 안전하게 사용할 수 있습니다.
import time
from datetime import timedelta
start_time = time.monotonic()
end_time = time.monotonic()
print(timedelta(seconds=end_time - start_time))
해설 (3)

더 나은 linux*용: / usr / bin / 시간 ''

$ /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

일반적으로, 그냥 '시간' 은 기본 제공 할 수 있는 '더 간단해진다는 쉘로 com/go/vid0085_kr / usr / bin / 시간'.

해설 (0)

이 [솔루션을 로제리교블] (https://stackoverflow.com/a/1557584/7851470) 는 파이썬 내장현 프로필러 좋아요, 하지만 스케쳐내 보다 구체적인 정보를 사용할 수 있습니다. 이걸 페이지:

http://docs.python.org/library/profile.html

한 많은 유용한 정보를 알려주는 프로필러 소요된 시간 등 모든 함수

Georgy
편집된 답변23일 9월 2019 в 9:10
해설 (0)
  • 타임스크로크 () *

&gt. 이후 버전에 사용되지 않는 3.3tb: 이 함수의 비헤이비어를 다릅니다 &gt. 플랫폼에서: 대신 사용하여 perf_counter () 또는 process_time () &gt. 요구 사항에 따라 비헤이비어를 잘 알 수 있다.

  • time.perf_counter () *

&gt. 성능 카운터 값을 되돌려줍니다 (분수 초 단위로) 는, &gt. 즉, 가장 높은 해상도를 사용할 수 있는 짧은 시간 측정 &gt. 기간. 은 정지 및 경과 시간 포함) 은 정보기술 (it) &gt. 시스템.

  • time.process_time () *

&gt. (분수 초 단위로) 을 더한 값을 되돌려줍니다 시스템 및 &gt. 현재 사용자 CPU 시간 과정이다. 포함시키십시오 이 시간이 없습니다. &gt. 잠자는 동안.

start = time.process_time()
... do something
elapsed = (time.process_time() - start)
해설 (0)

다음 좋은 사람이 읽을 수 있는 ',' 소요 시간을 스니핏 인쇄, HH:MM:SS&gt &lt 형식.

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
편집된 답변20일 2월 2018 в 12:19
해설 (1)

'' 모듈에서는 티마이트 됩니다. 모두 함께 작동하잖아 파이썬 2 와 파이썬 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

실행 시간 (초) 및 it 투자 할 수 있습니다. 그러나 이러한 main 함수를 쓰기 시작하는 간단한 프로그램 실행 합니다. 실행 시간 오류 후 확보하십시오 afaq 스케쳐내 경우에도 경험하십시오 매개변수입니다 &quot Start"; 같은 it 및 아니했다고 계산하십시오

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)
Jefferson Arrubla H
편집된 답변18일 9월 2017 в 8:14
해설 (0)

이피통 &quot timeit"; 모든 스크립트입니다.

def foo():
    %run bar.py
timeit foo()
해설 (0)

&gt. # 39, ve i& 티마이트 을 바라볼 수 있지만, 작은 코드 스니핏 it& # 39 에 대해서만 모듈에서는 보인다. I want to time 전체 프로그램.

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

바라보면 ' ()' 기능을 사용하여 시간을 한 시간 경과 인쇄인쇄 your_module.main 타임스타임 () '및' 역할을 타이머.

/ Usr / bin / 파이썬 지켜보리니 에뮬레이션하도록 '시간' 에서 [파이썬 하위 함께 / usr / bin/time: 그러나 다른 모든 출력입니다 캡처하려면 타이밍 정보를 어떻게 무시하시겠습니까?] (https://stackoverflow.com/a/28521323/4279).

Cpu 시간을 측정하기 위해 (예: # 39 () ',' 기간 동안 타임.슬레예프 don& t 포함) 에서 각 기능을 사용할 수 있습니다 ',' 모듈에서는 프로파일할 ('크프로피레' 의 파이썬 2):

$ python3 -mprofile your_module.py

'위' 명령 '을 전달할 수 있습니다' p 티마이트 타이머 모듈에서 사용할 경우 '같은' 프로파일할 있다.

참조 [프로파일하는데 파이썬 스크립트를 어떻게 해야 할까요?] (https://stackoverflow.com/q/582336/4279)

해설 (0)
 
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)
해설 (0)

Line_profiler 사용합니다.

시간을 프로파일할 line_profiler 는 개별 코드는 시행하십시오 노력하고 있습니다. 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: 
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))]
해설 (0)

I like 폴 McGuire& # 39 의 오토메이티드 양식 있는 더 적합한 컨텍스트로 manager 및 마련했다 너무 어렵습니다.

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))
해설 (0)

There is a '' 모듈에서는 파이썬 코드를 실행 시간을 티마이트 데 사용할 수 있는 시간입니다. 이 회사는 예제에 필요한 문서 및 파이썬 문서 (https://docs.python.org/2/library/timeit.html)

해설 (1)

아주 간단한 기능의 일부를 사용 시간 코드 실행:

import time
def timing():
    start_time = time.time()
    return lambda x: print("[{:.2f}s] {}".format(time.time() - start_time, x))

그리고 방금 전에 이를 측정하는 데 사용하며, 코드 읽어들이려면 어졌다면 security. 함수 호출 함수를 사용하여 코드 시간과 시간 후 주석, 주석 앞에 나타나는데, 예를 들면 다음과 같습니다.

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'

기분이 조금 우아한 this way.

해설 (0)

주피터 노트북에서나 사용하여 데이터에 대한 여러분

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

%%time 
[ x**2 for x in range(10000)]
  • 출력입니다 * CPU 시간: 마이크로소프트 (ms) · 4.54 사용자 sys: 0 ns, 합계: 4.54 밀리초입니다 벽 시간: 4.12 밀리초입니다

이렇게 하면 포착하십시오 실행 시간을 디렉토리에만 특정 세포. # 39 와 같은 경우, d you& 캡처하려면 실행 시간 현재 전체 노트북 새로 만들 수 있습니다 (즉, 프로그램) 같은 새로운 노트북 autoexec. 수첩에 디렉토리이며 모든 셀:

  • 예를 들어, 위의 example_notebook.ipynb 호출됨 '노트북'. 새 노트북 하나의 directory:*
# 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
  • 출력입니다 * 이피통 cpucomment 타이밍 (추정): 사용자: 0.00 때문이다. 시스템: 0.00 때문이다. 벽 시간: 0.00 때문이다.
해설 (0)