Python'da kod satırları arasında geçen süre nasıl ölçülür?

Yani Java'da, bir işlevin yürütmek için harcadığı zamanı

Ama python'da nasıl yapılır? Kod satırları arasındaki zamanın başlangıç ​​ve bitiş zamanını ölçmek için mi? Bunu yapan bir şey:

import some_time_library

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

time_taken = endtime - starttime

CPU süresini ölçmek istiyorsanız, time.process_time()Python 3.3 ve üstü için kullanabilirsiniz :

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

İlk arama zamanlayıcıyı açar ve ikinci arama kaç saniyenin geçtiğini söyler.

Ayrıca bir işlev vardır time.clock(), ancak Python 3.3'ten beri kullanımdan kaldırılmıştır ve Python 3.8'de kaldırılacaktır.

Orada daha iyi profilleme araçları gibidir timeitve profiletime.process_time ancak () CPU zamanı ölçmek ve bu Sorduğunuz şeyi olduğu edecektir.

Bunun yerine duvar saati zamanını ölçmek istiyorsanız kullanın time.time().

timeKitaplığı da kullanabilirsiniz :

import time

start = time.time()

# your code

# end

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

Küçük bir uygunluk sınıfının yardımıyla, aşağıdaki gibi girintili satırlarda harcanan zamanı ölçebilirsiniz :

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

Girintili satır (lar) ın yürütülmesi bittikten sonra aşağıdakileri gösterecektir:

Code block took: x.xxx ms

GÜNCELLEME: Artık sınıfı pip install linetimerve ardından alabilirsiniz from linetimer import CodeTimer. Bu GitHub projesine bakın .

Yukarıdaki sınıfın kodu:

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

Daha sonra ölçmek istediğiniz kod bloklarını adlandırabilirsiniz :

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

Ve onları iç içe geçirin:

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

İlgili olarak timeit.default_timer(), işletim sistemi ve Python sürümüne göre en iyi zamanlayıcıyı kullanır, bu yanıta bakın .

Zamanı her zaman saat, dakika ve saniye (% H:% M:% S) biçiminde kontrol etmeyi tercih ederim:

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

çıktı:

Time:  0:00:00.000019

Minimum kodla biçimlendirilmiş bir zamanın nasıl çıkarılacağının bir yolunu arıyordum, işte çözümüm. Pek çok kişi Pandalar'ı zaten kullanıyor, bu nedenle bazı durumlarda bu ek kitaplık içe aktarmalarından tasarruf sağlayabilir.

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

Çıktı:

0 days 00:05:32.541600

Zaman hassasiyeti en önemli değilse bunu kullanmanızı tavsiye ederim, aksi takdirde timekitaplığı kullanın :

%timeit pd.Timestamp.now() döngü başına 3,29 µs ± 214 ns çıktı

%timeit time.time() döngü başına 154 ns ± 13,3 ns çıktı

Bunu da deneyebilirsiniz:

from time import perf_counter

t0 = perf_counter()

...

t1 = perf_counter()
time_taken = t1 - t0

Kodu bir işleve koymak, ardından zamanlama için bir dekoratör kullanmak başka bir seçenektir. ( Kaynak ) Bu yöntemin avantajı, zamanlayıcıyı bir kez tanımlamanız ve onu her işlev için basit bir ek satırla kullanmanızdır.

İlk önce timerdekoratörü tanımlayın :

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

Ardından, işlevi tanımlarken dekoratörü kullanın:

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

Hadi deneyelim:

doubled_and_add(100000)
doubled_and_add(1000000)

Çıktı:

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

Not: Bunun time.perf_counteryerine neden kullanacağımdan emin değilim time.time. Yorumlara açığız.