Bagaimana cara saya mendapatkan waktu pelaksanaan program Python?

Saya memiliki program baris perintah dengan Python yang membutuhkan waktu cukup lama untuk menyelesaikannya. Saya ingin tahu waktu yang tepat untuk menyelesaikan berlari.

Saya telah melihat timeitmodul, tetapi tampaknya itu hanya untuk potongan kode kecil. Saya ingin mengatur waktu seluruh program.

Cara paling sederhana dengan Python:

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

Ini mengasumsikan bahwa program Anda membutuhkan setidaknya sepersepuluh detik untuk dijalankan.

Cetakan:

--- 0.764891862869 seconds ---

Saya meletakkan timing.pymodul ini ke site-packagesdirektori saya sendiri , dan cukup masukkan import timingdi bagian atas modul saya:

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

Saya juga dapat menelepon timing.logdari dalam program saya jika ada tahapan signifikan dalam program yang ingin saya tampilkan. Tetapi hanya dengan memasukkan import timingakan mencetak waktu mulai dan berakhir, dan keseluruhan waktu yang berlalu. (Maafkan secondsToStrfungsi tidak jelas saya , itu hanya memformat angka floating point detik ke jj: mm: dd. Sss.)

Catatan: Versi Python 3 dari kode di atas dapat ditemukan di sini atau di sini .

Di Linux atau Unix:

$ time python yourprogram.py

Di Windows, lihat pertanyaan StackOverflow ini: Bagaimana cara mengukur waktu eksekusi suatu perintah pada baris perintah Windows?

Untuk keluaran yang lebih banyak,

$ 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

Saya sangat suka jawaban Paul McGuire , tetapi saya menggunakan Python 3. Jadi bagi mereka yang tertarik: inilah modifikasi dari jawabannya yang bekerja dengan Python 3 di * nix (saya membayangkan, di bawah Windows, yang clock()seharusnya digunakan sebagai gantinya 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")

Jika Anda menemukan ini berguna, Anda masih harus memilih suara jawabannya, bukan yang ini, karena ia melakukan sebagian besar pekerjaan;).

import time

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

time.clock()mengembalikan waktu prosesor, yang memungkinkan kita untuk menghitung hanya waktu yang digunakan oleh proses ini (toh pada Unix). Dokumentasi mengatakan "dalam hal apapun, ini adalah fungsi yang digunakan untuk pembandingan algoritma Python atau pewaktuan"

Saya suka output yang datetimedisediakan modul, di mana objek delta menunjukkan hari, jam, menit, dll sebagaimana diperlukan dengan cara yang dapat dibaca manusia.

Sebagai contoh:

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

Contoh output misalnya

Duration: 0:00:08.309267

atau

Duration: 1 day, 1:51:24.269711

Seperti yang disebutkan JF Sebastian, pendekatan ini mungkin menghadapi beberapa kasus rumit dengan waktu setempat, jadi lebih aman untuk digunakan:

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

Anda dapat menggunakan cProfile profiler Python untuk mengukur waktu CPU dan juga berapa banyak waktu yang dihabiskan di dalam setiap fungsi dan berapa kali setiap fungsi dipanggil. Ini sangat berguna jika Anda ingin meningkatkan kinerja skrip Anda tanpa tahu harus mulai dari mana. Jawaban untuk pertanyaan Stack Overflow ini cukup bagus. Itu selalu baik untuk melihat dalam dokumentasi juga.

Berikut ini contoh cara membuat profil skrip menggunakan cProfile dari baris perintah:

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

Bahkan lebih baik untuk 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 ()

Tidak digunakan lagi sejak versi 3.3: Perilaku fungsi ini tergantung pada platform: gunakan perf_counter () atau process_time () , tergantung pada kebutuhan Anda, untuk memiliki perilaku yang terdefinisi dengan baik.

time.perf_counter ()

Kembalikan nilai (dalam detik pecahan) penghitung kinerja, yaitu jam dengan resolusi tertinggi yang tersedia untuk mengukur durasi singkat. Ini tidak termasuk waktu berlalu selama tidur dan seluruh sistem.

time.process_time ()

Kembalikan nilai (dalam pecahan detik) dari jumlah sistem dan waktu CPU pengguna dari proses saat ini. Itu belum termasuk waktu yang berlalu saat tidur.

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

Cukup gunakan timeitmodul. Ia bekerja dengan Python 2 dan Python 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

Itu kembali dalam hitungan detik dan Anda dapat memiliki waktu eksekusi Anda. Ini sederhana, tetapi Anda harus menulis ini di fungsi utama yang memulai eksekusi program. Jika Anda ingin mendapatkan waktu eksekusi bahkan ketika Anda mendapatkan kesalahan maka ambil parameter "Mulai" untuk itu dan hitung di sana seperti:

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

Cuplikan berikut ini mencetak waktu yang telah berlalu dalam <HH:MM:SS>format yang dapat dibaca manusia .

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)

Di IPython , "timeit" skrip apa pun:

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

Saya telah melihat pada modul timeit, tetapi sepertinya itu hanya untuk potongan kecil kode. Saya ingin mengatur waktu seluruh program.

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

Ini menjalankan your_module.main()fungsi satu kali dan mencetak waktu yang telah berlalu menggunakan time.time()fungsi sebagai penghitung waktu.

Untuk mengemulasi /usr/bin/timePython, lihat subproses Python dengan / usr / bin / time: bagaimana cara menangkap informasi timing tetapi mengabaikan semua output lainnya? .

Untuk mengukur waktu CPU (mis., Jangan menyertakan waktu selama time.sleep()) untuk setiap fungsi, Anda dapat menggunakan profilemodul ( cProfilepada Python 2):

$ python3 -mprofile your_module.py

Anda bisa meneruskan -pke timeitperintah di atas jika Anda ingin menggunakan penghitung waktu yang sama seperti yang profiledigunakan modul.

Lihat Bagaimana Anda bisa membuat profil skrip Python?

Saya juga menyukai jawaban Paul McGuire dan menghasilkan formulir manajer konteks yang lebih sesuai dengan kebutuhan saya.

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

Untuk data orang-orang menggunakan Notebook Jupyter

Dalam sel, Anda dapat menggunakan %%timeperintah ajaib Jupyter untuk mengukur waktu eksekusi:

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

Keluaran

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

Ini hanya akan menangkap waktu eksekusi sel tertentu. Jika Anda ingin menangkap waktu eksekusi seluruh buku catatan (yaitu program), Anda dapat membuat buku catatan baru di direktori yang sama dan di buku catatan baru jalankan semua sel:

Misalkan notebook di atas disebut example_notebook.ipynb. Di buku catatan baru dalam direktori yang sama:

# 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

Keluaran

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

Ada timeitmodul yang dapat digunakan untuk mengatur waktu waktu eksekusi kode Python.

Ini memiliki dokumentasi rinci dan contoh dalam dokumentasi Python, 26.6. timeit - Mengukur waktu eksekusi dari cuplikan kode kecil .

Gunakan line_profiler .

line_profiler akan membuat profil waktu yang dibutuhkan setiap baris kode untuk dieksekusi. Profiler diimplementasikan dalam C via Cython untuk mengurangi overhead profiling.

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

Hasilnya akan:

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

Saya menggunakan fungsi yang sangat sederhana untuk mengatur waktu bagian dari eksekusi kode:

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

Dan untuk menggunakannya, panggil saja sebelum kode untuk mengukur untuk mengambil waktu fungsi, dan kemudian memanggil fungsi setelah kode dengan komentar. Waktu akan muncul di depan komentar. Sebagai contoh:

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

Maka hasilnya akan terlihat seperti ini:

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

Saya mengalami masalah yang sama di banyak tempat, jadi saya membuat paket kenyamanan horology. Anda dapat menginstalnya dengan pip install horologydan kemudian melakukannya dengan cara yang elegan:

from horology import Timing

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

akan menampilkan:

Important calculations: 12.43 ms

Atau bahkan lebih sederhana (jika Anda memiliki satu fungsi):

from horology import timed

@timed
def main():
    ...

akan menampilkan:

main: 7.12 h

Membutuhkan unit dan pembulatan. Ini bekerja dengan python 3.6 atau lebih baru.

Ini jawaban Paul McGuire yang cocok untuk saya. Untuk berjaga-jaga jika seseorang mengalami kesulitan menjalankan yang itu.

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

Panggilan timing.main()dari program Anda setelah mengimpor file.

Timeit adalah kelas dalam Python yang digunakan untuk menghitung waktu eksekusi kode blok kecil.

Default_timer adalah metode di kelas ini yang digunakan untuk mengukur waktu jam dinding, bukan waktu eksekusi CPU. Dengan demikian eksekusi proses lain dapat mengganggu ini. Jadi ini berguna untuk blok kode kecil.

Contoh kode adalah sebagai berikut:

from timeit import default_timer as timer

start= timer()

# Some logic

end = timer()

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

Jawaban nanti, tetapi saya menggunakan 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

• Bungkus semua kode Anda, termasuk impor yang mungkin Anda miliki, di dalamnya code_to_test.
• number argumen menentukan berapa kali kode harus diulang.
• Demo

Waktu tindakan eksekusi program Python bisa tidak konsisten tergantung pada:

• Program yang sama dapat dievaluasi menggunakan algoritma yang berbeda
• Waktu berjalan bervariasi antara algoritma
• Waktu berjalan bervariasi antara implementasi
• Waktu pengoperasian bervariasi antar komputer
• Waktu berjalan tidak dapat diprediksi berdasarkan input yang kecil

Ini karena cara yang paling efektif adalah menggunakan "Orde Pertumbuhan" dan mempelajari notasi "O" yang besar untuk melakukannya dengan benar.

Bagaimanapun, Anda dapat mencoba mengevaluasi kinerja program Python dalam langkah-langkah penghitungan mesin spesifik per detik menggunakan algoritma sederhana ini: sesuaikan ini dengan program yang ingin Anda evaluasi

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

Anda melakukan ini hanya dengan Python. Tidak perlu membuatnya rumit.

import time

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

Mirip dengan respons dari @rogeriopvl saya menambahkan sedikit modifikasi untuk mengkonversi ke detik menit menggunakan perpustakaan yang sama untuk pekerjaan yang berjalan lama.

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

Output Sampel

Time Taken: 00:00:08

Pertama, instal humanfriendly paket dengan membuka Command Prompt (CMD) sebagai administrator dan ketik di sana - pip install humanfriendly

Kode:

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

Keluaran:

Untuk menggunakan jawaban metakermit yang diperbarui untuk Python 2.7, Anda akan memerlukan paket monoton .

Kode tersebut akan menjadi sebagai berikut:

from datetime import timedelta
from monotonic import monotonic

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

Saya mencoba dan menemukan perbedaan waktu menggunakan skrip berikut.

import time

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

Jika Anda ingin mengukur waktu dalam mikrodetik, maka Anda dapat menggunakan versi berikut, berdasarkan sepenuhnya pada jawaban Paul McGuire dan Nicojo - ini adalah kode Python 3. Saya juga menambahkan beberapa warna ke dalamnya:

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 () => fungsi yang mencetak informasi waktu.

txt ==> argumen pertama untuk dicatat, dan string-nya untuk menandai waktu.

atexit ==> Modul Python untuk mendaftarkan fungsi yang dapat Anda panggil saat program keluar.