파이썬에서 코드 행 사이에 걸리는 시간을 측정하는 방법은 무엇입니까?

파이썬에서 코드 행 사이에 걸리는 시간을 측정하는 방법은 무엇입니까?

그래서 자바에서는 함수가 실행하는 데 걸리는 시간을 측정하는 방법을 사용할 수 있습니다.

하지만 파이썬에서는 어떻게 이루어집니까?코드 라인 간의 시작 시간과 종료 시간을 측정하려면?다음과 같은 이점이 있습니다.

import some_time_library

starttime = some_time_library.some_module()
code_tobe_measured() 
endtime = some_time_library.some_module()

time_taken = endtime - starttime

CPU 시간을 측정하려는 경우 Python 3.3 이상에서 를 사용할 수 있습니다.

import time
start = time.process_time()
# your code here    
print(time.process_time() - start)

첫 번째 통화에서는 타이머가 켜지고 두 번째 통화에서는 몇 초가 경과했는지 알 수 있습니다.

.time.clock()그러나 Python 3.3 이후에는 더 이상 사용되지 않으며 Python 3.8에서 제거될 예정입니다.

다음과 같은 더 나은 프로파일링 도구가 있습니다.timeit그리고.profile그러나 time.process_time()은 CPU 시간을 측정하며 이것이 당신이 묻고 있는 것입니다.

하고자 할 에는 대신벽시시측면려사다다니용합음을정하를 합니다.time.time().

사용할 수도 있습니다.time라이브러리:

import time

start = time.time()

# your code

# end

print(f'Time: {time.time() - start}')

소규모 편의 클래스를 사용하면 다음과 같이 들여쓰기된 줄에서 소요되는 시간을 측정할 수 있습니다.

with CodeTimer():
   line_to_measure()
   another_line()
   # etc...

들여쓴 줄이 실행을 마치면 다음이 표시됩니다.

Code block took: x.xxx ms

업데이트: 이제 클래스를 사용할 수 있습니다.pip install linetimer그리고 나서.from linetimer import CodeTimer이 GitHub 프로젝트를 참조하십시오.

위 클래스의 코드:

import timeit

class CodeTimer:
    def __init__(self, name=None):
        self.name = " '"  + name + "'" if name else ''

    def __enter__(self):
        self.start = timeit.default_timer()

    def __exit__(self, exc_type, exc_value, traceback):
        self.took = (timeit.default_timer() - self.start) * 1000.0
        print('Code block' + self.name + ' took: ' + str(self.took) + ' ms')

그런 다음 측정할 코드 블록의 이름을 지정할 수 있습니다.

with CodeTimer('loop 1'):
   for i in range(100000):
      pass

with CodeTimer('loop 2'):
   for i in range(100000):
      pass

Code block 'loop 1' took: 4.991 ms
Code block 'loop 2' took: 3.666 ms

둥지를 틀면,

with CodeTimer('Outer'):
   for i in range(100000):
      pass

   with CodeTimer('Inner'):
      for i in range(100000):
         pass

   for i in range(100000):
      pass

Code block 'Inner' took: 2.382 ms
Code block 'Outer' took: 10.466 ms

에 대하여timeit.default_timer()OS 및 Python 버전에 기반한 최고의 타이머를 사용합니다. 다음 답변을 참조하십시오.

코드를 함수에 넣은 다음 타이밍을 위해 장식기를 사용하는 것도 하나의 옵션입니다.(소스)이 방법의 장점은 타이머를 한 번 정의하고 모든 기능에 대해 간단한 추가 라인과 함께 사용한다는 것입니다.

정의니다합먼저를 합니다.timer장식자:

import functools
import time

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.perf_counter()
        value = func(*args, **kwargs)
        end_time = time.perf_counter()
        run_time = end_time - start_time
        print("Finished {} in {} secs".format(repr(func.__name__), round(run_time, 3)))
        return value

    return wrapper

그런 다음 다음 함수를 정의하는 동안 데코레이터를 사용합니다.

@timer
def doubled_and_add(num):
    res = sum([i*2 for i in range(num)])
    print("Result : {}".format(res))

시도해 보겠습니다.

doubled_and_add(100000)
doubled_and_add(1000000)

출력:

Result : 9999900000
Finished 'doubled_and_add' in 0.0119 secs
Result : 999999000000
Finished 'doubled_and_add' in 0.0897 secs

참고: 사용해야 하는 이유를 잘 모르겠습니다.time.perf_counter에 time.time댓글은 환영합니다.

시간은 항상 시간, 분 및 초(%H:%M:%S) 형식으로 확인하는 것이 좋습니다.

from datetime import datetime
start = datetime.now()
# your code
end = datetime.now()
time_taken = end - start
print('Time: ',time_taken) 

출력:

Time:  0:00:00.000019

최소한의 코드로 포맷된 시간을 출력하는 방법을 찾고 있었기 때문에, 이것이 제 해결책입니다.어쨌든 많은 사람들이 판다를 사용하기 때문에, 어떤 경우에는 이것이 추가적인 도서관 수입으로부터 절약할 수 있습니다.

import pandas as pd
start = pd.Timestamp.now()
# code
print(pd.Timestamp.now()-start)

출력:

0 days 00:05:32.541600

시간 정밀도가 가장 중요하지 않은 경우에는 이를 사용하는 것이 좋습니다. 그렇지 않은 경우에는time라이브러리:

%timeit pd.Timestamp.now() 3/루프 프3.29µs ±214ns

%timeit time.time()± 154ns ± 13.3ns

다음과 같이 시도할 수도 있습니다.

from time import perf_counter

t0 = perf_counter()

...

t1 = perf_counter()
time_taken = t1 - t0

모듈 사용time우리는 함수의 시작과 함수의 끝에서 unix 시간을 계산할 수 있습니다.코드는 다음과 같습니다.

from time import time as unix

이 코드가 가져옵니다.time.time유닉스 시간을 계산할 수 있게 해줍니다.

from time import sleep

이것은 필수 사항은 아니지만, 저는 또한 수입하고 있습니다.time.sleep시위 중 하나를 위해.

START_TIME = unix()

이것이 unix 시간을 계산하여 변수에 넣는 것입니다.unix 함수는 실제 함수가 아닙니다.내가time.timeunix로, 그래서 당신이 넣지 않았다면.as unix첫 번째 가져오기에서는 다음을 사용해야 합니다.time.time().

그 후, 우리는 원하는 기능이나 코드를 넣습니다.코드 스니펫의 끝에 우리가 넣었습니다.

TOTAL_TIME = unix()-START_TIME

이 코드 라인은 두 가지 작업을 수행합니다.함수의 끝에 있는 unix 시간을 계산하고 변수를 사용합니다.START_TIME이전부터 코드 스니펫을 실행하는 데 걸린 시간을 계산합니다.

그리고 나서 우리는 이 변수를 우리가 원하는 곳 어디에서나 사용할 수 있습니다.print()기능.

print("The snippet took {} seconds to execute".format(TOTAL_TIME))

여기에 두 가지 실험을 시연으로 하는 간단한 시연 코드를 작성했습니다. (완전 주석)

from time import time as unix # Import the module to measure unix time
from time import sleep

# Here are a few examples:
# 1. Counting to 100 000
START_TIME = unix()
for i in range(0, 100001):
  print("Number: {}\r".format(i), end="")
TOTAL_TIME = unix() - START_TIME
print("\nFinal time (Expirement 1): {} s\n".format(TOTAL_TIME))

# 2. Precision of sleep
for i in range(10):
  START_TIME = unix()
  sleep(0.1)
  TOTAL_TIME = unix() - START_TIME
  print("Sleep(0.1): Index: {}, Time: {} s".format(i,TOTAL_TIME))

다음은 제 출력입니다.

Number: 100000
Final time (Expirement 1): 16.666812419891357 s

Sleep(0.1): Index: 0, Time: 0.10014867782592773 s
Sleep(0.1): Index: 1, Time: 0.10016226768493652 s
Sleep(0.1): Index: 2, Time: 0.10202860832214355 s
Sleep(0.1): Index: 3, Time: 0.10015869140625 s
Sleep(0.1): Index: 4, Time: 0.10014724731445312 s
Sleep(0.1): Index: 5, Time: 0.10013675689697266 s
Sleep(0.1): Index: 6, Time: 0.10014677047729492 s
Sleep(0.1): Index: 7, Time: 0.1001439094543457 s
Sleep(0.1): Index: 8, Time: 0.10044598579406738 s
Sleep(0.1): Index: 9, Time: 0.10014700889587402 s
> 

사용하다timeit성능을 벤치마킹할 모듈:

def test():
    print("test")
    emptyFunction()
    for i in [x for x in range(10000)]:
        i**i


def emptyFunction():
    pass

if __name__ == "__main__":
    import timeit
    print(timeit.timeit("test()", number = 5, globals = globals()))
    #print(timeit.timeit("test()", setup = "from __main__ import test",
    #    number = 5))

첫 번째 매개 변수는 실행하려는 코드 조각을 정의합니다.test이 경우 &number실행을 반복할 횟수를 정의합니다.

출력:

test
test
test
test
test
36.81822113099952

사용 시간:

import timeit
timeit.timeit("code_tobe_measured()")

예.

>>> import timeit
>>> timeit.timeit("import pandas")
2.923877900000008

https://stackoverflow.com/a/63665115/7412781 솔루션에 조금 더 추가하겠습니다.

• 에 대한 종속성 제거functools.
• 소요된 프로세스 시간time.process_time()의 절대적인 카운터 대신에time.perf_counter()프로세스가 커널을 통해 컨텍스트 전환될 수 있기 때문입니다.
• 원시 함수 포인터 인쇄를 사용하여 올바른 클래스 이름도 가져옵니다.

이것은 장식가 코드입니다.

import time

def decorator_time_taken(fnc):
    def inner(*args):
        start = time.process_time()
        ret = fnc(*args)
        end = time.process_time()
        print("{} took {} seconds".format(fnc, round((end - start), 6)))
        return ret
    return inner

이것은 사용 샘플 코드입니다.193939가 프라임인지 아닌지 확인하는 것입니다.

class PrimeBrute:
    @decorator_time_taken
    def isPrime(self, a):
        for i in range(a-2):
           if a % (i+2) == 0: return False
        return True

inst = PrimeBrute()
print(inst.isPrime(193939))

이것이 출력입니다.

<function PrimeBrute.isPrime at 0x7fc0c6919ae8> took 0.015789 seconds
True

날짜 가져오기 시간

#이 코드는 계산 전에

%% time it ~code~

언급URL : https://stackoverflow.com/questions/14452145/how-to-measure-time-taken-between-lines-of-code-in-python