Bir Python programının yürütülmesi için nasıl zaman alabilirim?

Python'da bitirmek biraz zaman alan bir komut satırı programım var. Çalışmayı bitirmek için gereken tam zamanı bilmek istiyorum.

timeitModüle baktım , ama sadece küçük kod parçacıkları için görünüyor. Tüm programı zamanlamak istiyorum.

Python'daki en basit yol:

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

Bu, programınızın çalıştırılmasının en az onda biri sürdüğünü varsayar.

Baskılar:

--- 0.764891862869 seconds ---

Bu timing.pymodülü kendi site-packagesdizinime koydum ve import timingmodülümün en üstüne yerleştirdim :

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.logGöstermek istediğim programda önemli aşamalar varsa programımdan da arayabilirim . Ancak sadece dahil olmak üzere import timingbaşlangıç ​​ve bitiş zamanlarını ve toplam geçen zamanı yazdırabilirsiniz. (Gizliliğimi affetsecondsToStr işlevimi , sadece kayan nokta sayısını ss: dd: ss.sss biçimine biçimlendirir.)

Not: Yukarıdaki kodun bir Python 3 sürümü burada veya burada bulunabilir .

Linux veya Unix'te:

$ time python yourprogram.py

Windows'ta şu StackOverflow sorusuna bakın: Windows komut satırında bir komutun yürütme süresini nasıl ölçebilirim?

Daha ayrıntılı çıktılar için,

$ 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'ın cevabını gerçekten çok seviyorum , ancak Python 3'ü kullanıyorum. Yani ilgilenenler için: İşte * nix üzerinde Python 3 ile çalışan cevabının bir modifikasyonu (Windows clock()yerine, bunun yerine kullanılması gerektiğini hayal ediyorum 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")

Bunu yararlı bulursanız, işin çoğunu yaptığı gibi, bunun yerine cevabını hala oylamalısınız;).

import time

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

time.clock()yalnızca bu işlem tarafından kullanılan süreyi hesaplamamıza izin veren işlemci zamanını döndürür (yine de Unix'te). Dokümantasyonda "her durumda, bu Python veya zamanlama algoritmalarını karşılaştırmak için kullanılacak fonksiyon" diyor

datetimeModülün sağladığı çıktıyı seviyorum, zaman delta nesnelerinin insan tarafından okunabilir bir şekilde günleri, saatleri, dakikaları vb.

Örneğin:

from datetime import datetime
start_time = datetime.now()
# do your work here
end_time = datetime.now()
print('Duration: {}'.format(end_time - start_time))

Örnek çıktı örn.

Duration: 0:00:08.309267

veya

Duration: 1 day, 1:51:24.269711

JF Sebastian'ın belirttiği gibi, bu yaklaşım yerel zamana sahip bazı zor vakalarla karşılaşabilir, bu nedenle kullanımı daha güvenlidir:

import time
from datetime import timedelta
start_time = time.monotonic()
end_time = time.monotonic()
print(timedelta(seconds=end_time - start_time))

Python profiler cProfile'ı CPU zamanını ve ayrıca her fonksiyonun içinde ne kadar zaman harcandığını ve her fonksiyonun kaç kez çağrıldığını ölçmek için kullanabilirsiniz . Nereden başlayacağınızı bilmeden betiğinizin performansını artırmak istiyorsanız bu çok kullanışlıdır. Başka bir Yığın Taşması sorusuna bu cevap oldukça iyi. Belgelere de bakmak her zaman iyidir .

Komut satırından cProfile kullanarak bir komut dosyasını nasıl profilleyeceğinize ilişkin bir örnek:

$ 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 için daha da iyi: 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

zaman saati()

Sürüm 3.3'ten bu yana kullanımdan kaldırılmıştır : Bu işlevin davranışı platforma bağlıdır: gereksinimlerinize bağlı olarak iyi tanımlanmış bir davranışa sahip olmak için perf_counter () veya process_time () kullanın.

time.perf_counter ()

Bir performans sayacının değerini (kesirli saniye cinsinden), yani kısa bir süreyi ölçmek için mevcut en yüksek çözünürlüğe sahip bir saati döndürün. Bu vermez zaman uyku sırasında geçen ve sistem genelinde olduğu sayılabilir.

time.process_time ()

Geçerli işlemin sistem toplamını ve kullanıcı CPU zamanının değerini (kesirli saniye cinsinden) döndürün. O değil uyku sırasında geçen süre sayılabilir.

start = time.process_time()
... do something
elapsed = (time.process_time() - start)

Sadece timeitmodülü kullanın . Hem Python 2 hem de Python 3 ile çalışır.

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

Saniyeler içinde geri döner ve yürütme sürenizi elde edebilirsiniz. Çok basit, ama bunları programın yürütülmesini başlatan ana fonksiyona yazmalısınız. Bir hata aldığınızda bile yürütme süresini almak istiyorsanız, o zaman "Başlat" parametrenizi alın ve orada aşağıdaki gibi hesaplayın:

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

Aşağıdaki snippet, geçen zamanı güzel bir insan tarafından okunabilir <HH:MM:SS>biçimde yazdırır .

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)

In ipython , "sürümüyle gelen timeit" herhangi bir komut dosyası:

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

Timeit modülüne baktım, ama sadece küçük kod parçacıkları için görünüyor. Tüm programı zamanlamak istiyorum.

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

your_module.main()İşlevi bir kez çalıştırır ve geçen zamanı yazdırır.time.time() işlevi zamanlayıcı olarak .

/usr/bin/timePython'da taklit etmek için bkz. / Usr / bin / time ile Python alt süreci: zamanlama bilgisi nasıl yakalanır ancak diğer tüm çıktılar yoksayılır? .

time.sleep()Her bir işlev için CPU süresini ölçmek (örneğin, süre dahil etmeyin ) için profilemodülü ( cProfilePython 2'de) kullanabilirsiniz:

$ python3 -mprofile your_module.py

Sen geçebileceği -piçin timeitsize aynı zamanlayıcı kullanmak istiyorsanız yukarıdaki komuta profilemodülü kullanımları.

Bkz. Python betiğini nasıl profilleyebilirsiniz?

Paul McGuire'ın cevabını da beğendim ve ihtiyaçlarıma daha uygun bir bağlam yöneticisi formu buldum.

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

Kullanan veri kullanıcıları için Jupyter Notebook

Bir hücrede, %%timeyürütme süresini ölçmek için Jupyter'ın sihirli komutunu kullanabilirsiniz:

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

Çıktı

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

Bu, yalnızca belirli bir hücrenin yürütme süresini yakalar. Tüm not defterinin (yani programın) yürütme süresini yakalamak istiyorsanız, aynı dizinde yeni bir not defteri oluşturabilir ve yeni not defterinde tüm hücreleri çalıştırabilirsiniz:

Yukarıdaki not defterinin çağrıldığını varsayalım example_notebook.ipynb. Aynı dizindeki yeni bir not defterinde:

# 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

Çıktı

IPython CPU timings (estimated):
  User   :       0.00 s.
  System :       0.00 s.
Wall time:       0.00 s.

timeitPython kodunun yürütme sürelerini zamanlamak için kullanılabilecek bir modül vardır.

Python belgelerinde ayrıntılı belgeler ve örnekler vardır, 26.6. timeit - Küçük kod parçacıklarının yürütme süresini ölçün .

Line_profiler kullanın .

line_profiler her bir kod satırının yürütülmesi için gereken süreyi belirler. Profil oluşturucu, profil oluşturma yükünü azaltmak için Cython aracılığıyla C olarak uygulanır .

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

Sonuçlar şöyle olacaktır:

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

Kod yürütmenin bir kısmını zamanlamak için çok basit bir işlev kullandım:

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

Bunu kullanmak için, işlev zamanlamasını almak üzere ölçmek için koddan önce çağırın ve koddan sonra işlevi yorumlarla çağırın. Saat yorumların önünde görünecektir. Örneğin:

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

Sonra çıktı şu şekilde görünecektir:

[9.35s] Loaded 1458644 rows data from 'train'

Birçok yerde aynı sorunu yaşıyordum, bu yüzden bir kolaylık paketi oluşturdum horology. İle kurabilir pip install horologyve daha sonra zarif bir şekilde yapabilirsiniz:

from horology import Timing

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

çıktı olacak:

Important calculations: 12.43 ms

Veya daha da basit (bir işleviniz varsa):

from horology import timed

@timed
def main():
    ...

çıktı olacak:

main: 7.12 h

Birimler ve yuvarlama ile ilgilenir. 3.6 veya daha yeni bir sürümle çalışır.

Bu Paul McGuire'ın benim için çalışan cevabı . Birisinin bunu çalıştırmakta sorun yaşaması ihtimaline karşı.

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()Dosyayı içe aktardıktan sonra programınızdan arayın .

Timeit, Python'da küçük kod bloklarının yürütme süresini hesaplamak için kullanılan bir sınıftır.

Default_timer, bu sınıfta CPU yürütme süresini değil duvar saati zamanlamasını ölçmek için kullanılan bir yöntemdir. Dolayısıyla, diğer işlemlerin yürütülmesi buna müdahale edebilir. Bu nedenle küçük kod blokları için yararlıdır.

Kodun bir örneği aşağıdaki gibidir:

from timeit import default_timer as timer

start= timer()

# Some logic

end = timer()

print("Time taken:", end-start)

Sonra cevap, ama kullanıyorum 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

• Sahip olabileceğiniz herhangi bir ithalat da dahil olmak üzere tüm kodunuzu içeri sarın code_to_test.
• number argüman, kodun kaç kez tekrarlanması gerektiğini belirtir.
• gösteri

Bir Python programının yürütme önleminin süresi aşağıdakilere bağlı olarak tutarsız olabilir:

• Aynı program farklı algoritmalar kullanılarak değerlendirilebilir
• Çalışma süresi algoritmalar arasında değişir
• Çalışma süresi uygulamalar arasında değişir
• Çalışma süresi bilgisayarlar arasında değişir
• Küçük girdilere bağlı olarak çalışma süresi tahmin edilemez

Çünkü en etkili yol "Büyüme Düzeni" ni kullanmak ve Büyük "O" gösterimini öğrenmek doğru şekilde yapmak .

Her neyse, bu basit algoritmayı kullanarak herhangi bir Python programının performansını belirli makine sayım adımlarındaki saniyede değerlendirmeyi deneyebilirsiniz: bunu değerlendirmek istediğiniz programa uyarlayın

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

Bunu sadece Python'da yaparsınız. Karmaşık hale getirmeye gerek yok.

import time

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

@Rogeriopvl yanıtına benzer şekilde, uzun süreli işler için aynı kütüphaneyi kullanarak saat dakika saniyesine dönüştürmek için küçük bir değişiklik ekledim.

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

Örnek Çıktı

Time Taken: 00:00:08

Öncelikle, yönetici olarak Komut İstemi'ni (CMD) açarak insan dostu paketi yükleyin ve buraya yazın - pip install humanfriendly

Kod:

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

Çıktı:

Metakermit'in Python 2.7 için güncellenmiş cevabını kullanmak için monoton pakete ihtiyacınız olacak .

Kod daha sonra aşağıdaki gibi olacaktır:

from datetime import timedelta
from monotonic import monotonic

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

Aşağıdaki komut dosyalarını kullanarak zaman farkı denedim ve buldum.

import time

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

Mikrosaniye cinsinden zamanı ölçmek istiyorsanız, tamamen Paul McGuire ve Nicojo'nun cevaplarına dayanan aşağıdaki sürümü kullanabilirsiniz - bu Python 3 kodudur. Ayrıca biraz renk ekledim:

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 () => zamanlama bilgilerini basan fonksiyon.

txt ==> günlüğe kaydedilecek ilk bağımsız değişken ve zamanlamayı işaretlemek için dizesi.

atexit ==> Program çıktığında çağırabileceğiniz işlevleri kaydetmek için Python modülü.