Bagaimana cara saya mendapatkan waktu pelaksanaan program Python?


979

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.

Jawaban:


1721

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

58
ini menghitung waktu sebenarnya (termasuk waktu yang digunakan oleh program lain) sehingga sepertinya akan memakan waktu lebih lama ketika komputer Anda sibuk melakukan hal-hal lain
newacct

35
pada Windows, lakukan hal yang sama, tetapi gunakan time.clock () alih-alih time.time (). Anda akan mendapatkan akurasi yang sedikit lebih baik.
Corey Goldberg

33
Saya sarankan melakukan round(time.time() - start_time, 2)(atau desimal apa pun yang Anda inginkan), saya mendapatkan angka ilmiah kembali seperti 1.24e-5.
ThorSummoner

16
@ Tumormoner: Anda mungkin ingin '%.2f'bukannya di round()sini.
jfs

10
Ada kelemahan besar dalam metode ini. Jika waktu sistem berubah ketika program sedang berjalan (seperti sinkronisasi dengan server waktu) maka metode ini tidak akan berfungsi atau bahkan dapat memecahkan kode (durasi negatif ...)
Gilad

210

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 .


8
Ini adalah solusi bersih nyata yang juga berfungsi jika Anda menekan Ctrl-C untuk menghentikan program.
sorin

solusi hebat Saya pasti akan menggunakannya dan membuat penghias waktu untuk mengidentifikasi fungsi bottleneck
c24b

9
Untuk Python 3 tambahkan from functools import reducedi bagian atas dan letakkan tanda kurung di setiap pernyataan cetak. Bagus sekali!
PowerApp101

2
@ PowerApp101 - Terima kasih - Jawaban Nicojo menyediakan versi ramah-Py3 dari modul ini.
PaulMcG

4
Catatan: time.clock () adalah "Tidak digunakan sejak versi 3.3: Perilaku fungsi ini tergantung pada platform: gunakan perf_counter () [dengan waktu tidur] atau process_time () [tanpa waktu tidur] sebagai gantinya, tergantung pada kebutuhan Anda, untuk memiliki perilaku yang terdefinisi dengan baik. "
mab

175

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

jadi jika saya meluncurkan widget lain, contoh dalam aplikasi QT bagaimana cara kita menghitung waktu yang dibutuhkan oleh widget itu untuk muncul?
Ciasto piekarz

1
Untuk kasus widget, jika Anda meluncurkan dari program Python, gunakan jawaban yang diterima oleh rogeriopvl.
steveha

tapi itu sepertinya tidak memberi waktu dalam min: detik itu berakhir angka mengambang !!
Ciasto piekarz

3
Ya, itu memberi sejumlah detik. Anda dapat mengonversi ke min: detik jika Anda mau. Lihatlah jawaban Paul McGuire dan secondsToStr()fungsinya.
steveha

68

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


1
Saya menemukan timedelta(seconds=t).total_seconds()bermanfaat.
nu everest

Bisakah Anda menjelaskan apa fungsi ini lakukan? apa yang ada di perintah log? apa itu atexit?
SumNeuron

@SumNeuron, singkatnya, fungsi-fungsi ini mencetak waktu eksekusi program yang Anda gunakan. s adalah argumen pertama yang dicatat, dan harus berupa string. log adalah fungsi yang mencetak info waktu. atexit adalah modul python yang memungkinkan Anda mendaftar fungsi untuk dipanggil saat keluar dari program.
Nicojo

@Nicojo Sangat membantu. Saya punya pertanyaan tentang bagaimana saya bisa menggunakan kode ini untuk menguji misalnya waktu untuk eksekusi loop. misalkan saya memiliki fungsi termasuk loop, dan saya ingin mendapatkan waktu yang dihabiskan oleh loop ini
moudi

@moudi Jawaban teratas untuk pertanyaan ini adalah taruhan terbaik Anda. Cukup atur waktu mulai tepat sebelum Anda mengulang, dan menghitung waktu yang telah berlalu pada saat keluar dari loop.
Nicojo

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


14
time.time () paling baik digunakan pada * nix. time.clock () paling baik digunakan pada Windows.
Corey Goldberg

Saya percaya ini tidak dapat digunakan untuk menghitung "hanya waktu yang digunakan oleh proses ini" karena menggunakan waktu sistem dan akan dipengaruhi oleh proses sistem lainnya? Perbaiki saya jika saya salah tentang ini :)
AnnanFay

6
Catatan: time.clock () adalah "Tidak digunakan sejak versi 3.3: Perilaku fungsi ini tergantung pada platform: gunakan perf_counter () [dengan waktu tidur] atau process_time () [tanpa waktu tidur] sebagai gantinya, tergantung pada kebutuhan Anda, untuk memiliki perilaku yang terdefinisi dengan baik. "
mab

55

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

1
@phansen: Anda bisa menggunakan di timedelta(seconds=time.monotonic()-start)sini (atau time.time()jika intervalnya besar). Jangan kurangi objek waktu naif yang mewakili waktu setempat; waktu setempat tidak monoton
jfs

OK, maksudmu seperti start_time = time.monotonic(); end_time = time.monotonic(); timedelta(seconds=end_time - start_time). Saya percaya Anda benar, tetapi kemudian Anda juga harus memformatnya, saat Anda kembali datetime.timedelta(0, 0, 76). Juga, tampaknya metode monoton hanya ditambahkan dalam Python 3.
metakermit

Ah, baiklah. Saya melihat Anda dapat melewatinya str()untuk menjadikannya "manusia". Saya akan memperbarui jawabannya, terima kasih.
metakermit

53

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}

@ jacwah Bagaimana Anda menjumlahkan total waktu?
Chuck

@ Chuck Baris pertama mengatakan X function calls in Y CPU seconds. Jika Anda ingin waktu jam dinding, gunakan salah satu jawaban lain di sini.
jacwah

28

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

18

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)

1
Mungkin mulai dengan kesimpulan, "Gunakan time.process_time ()" (atau serupa)?
Peter Mortensen

17

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

Bukankah seharusnya bagian itu di bawah finallybagian?
alper

12

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)    

1
semua jalan di sini orang menemukan jawaban yang paling waras (makna 'waras' mengandalkan sebanyak mungkin pada built-in dan karena itu mengetik paling tidak).
ijoseph

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


8

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?


7

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

7

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.


5

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

5

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'

5

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.


@ DarrenZou periksa lebih banyak dokumen dan sumber di sini
hans

Bisakah saya mendapatkan nilai itu dalam suatu variabel?
PepeElMago33

Ya, gunakan main.interval.
Memiliki

3

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.


3

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)

timeitadalah jawaban IMO yang lebih baik untuk banyak contoh.
Marc

3

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

Dan bagaimana jika Anda ingin mengatur waktu beberapa bagian dari kode yang tidak dapat dimasukkan ke string?
Daniel Stracaboško

@daniel Anda dapat membuat pertanyaan baru. Jika Anda memposting tautan di sini, saya mungkin dapat membantu Anda.
CONvid19

2

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

2

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)

2

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

2

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:

masukkan deskripsi gambar di sini


1

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

1

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

0

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.

Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.