Untuk mengukur waktu yang berlalu selama eksekusi program, gunakan time. jam() atau waktu. waktu() fungsi. Dokumen python menyatakan bahwa fungsi ini harus digunakan untuk tujuan pembandingan.
contoh
import time t0= time.clock() print("Hello") t1 = time.clock() - t0 print("Time elapsed: ", t1) # CPU seconds elapsed (floating point)Keluaran
Ini akan memberikan output -
Time elapsed: 1.2999999999999123e-05_Anda juga dapat menggunakan modul waktu untuk mendapatkan analisis statistik waktu eksekusi cuplikan kode yang tepat. Ini menjalankan cuplikan beberapa kali dan kemudian memberi tahu Anda berapa lama jangka waktu terpendek. Anda dapat menggunakannya sebagai berikut
Sekarang mari kita bahas dua istilah - 'waktu' dan 'berlalu'. Elapse adalah kata kerja, artinya 'tergelincir atau lewat' dan waktu adalah perkembangan atau kemajuan peristiwa masa lalu ke masa kini dan masa depan. Jadi Waktu berlalu dapat dengan mudah dipahami sebagai waktu yang berlalu dari awal suatu peristiwa hingga akhir peristiwa itu
- Jumlah waktu yang dibutuhkan seorang anak laki-laki untuk menyelesaikan suatu perlombaan
- Waktu berlalu untuk menyelesaikan suatu proses
- Waktu yang dibutuhkan kereta api untuk menyelesaikan suatu perjalanan
- Waktu yang dibutuhkan oleh bumi untuk menyelesaikan revolusi mengelilingi matahari
Di Python, dengan menjalankan segmen kode atau skrip python kita dapat mengukur waktu yang telah berlalu dengan menggunakan beberapa modul python bawaan seperti waktu, DateTime, dan waktu itu
Dalam modul waktu Python, ada beberapa metode berbeda untuk menentukan waktu Berlalu dari segmen kode. Sekarang kita akan membahas metode modul waktu berikut
- waktu. perf_counter()
- waktu. time_ns()
- waktu. waktu proses
Metode modul waktu ini melacak waktu dalam hitungan detik. Jadi untuk mendapatkannya dalam format yang bisa dibaca, kita tinggal mengubahnya menjadi mikrodetik sehingga mendapatkan perbedaan waktunya
Kode
# importing time module import time # calc is the function to determine the elapsed time def calc(z): return z ** 2 # tracks the start time st = time.perf_counter() # calling the function calc(3) # tracks the end time e = time.perf_counter() # find elapsed time in seconds ms = (e-st) * 10**6 print(f"Elapsed time {ms:.03f} micro secs.")
Keluaran
Elapsed time 1.014 micro secs.
Waktu metode ini. time_ns(), digunakan untuk menghitung waktu eksekusi dalam nanodetik. Metode ini mengikuti pelacakan waktu sebelum segmen kode dan setelah segmen kode. Kemudian kurangi dan tampilkan di layar. Dengan cara ini, ini akan menghitung waktu dalam nanodetik, bukan detik
Kode
# importing the time module import time # calc function to calculate the execution time def calc(y): return (y**2) # tracking the start time st = time.time_ns() # calling the calc() function calc(3) # tracking the end time e = time.time_ns() # displaying the execution time in nanoseconds print("Taken time is", e-st, "ns") _
Keluaran
Modul ini memberikan waktu Berlalu dengan menghitung jumlah waktu pengguna dan CPU (Central Processing Unit) dan kemudian mengembalikannya. Metode ini juga mengikuti pelacakan waktu sebelum segmen kode dan setelah segmen kode. Kemudian kurangi dan tampilkan di layar
Kode
# importing the time module import time # calc function to calculate the execution time def calc(q): return q ** 76567 # tracking the start time st = time.process_time() # calling the calc() function calc(125) # tracking the end time e = time.process_time() # displaying the elapsed time in milliseconds print("python elapsed time is", (e - st) * 10**3, "ms.")
Keluaran
python elapsed time is 7.486353000000001 ms.
_ Untuk menentukan waktu eksekusi suatu segmen kode, kita juga bisa menggunakan modul Python Datetime. Prosesnya sama dengan menggunakan waktu. time(), pertama ukur waktu mulai dan waktu selesai dan setelah itu hitung selisihnya Kode # importing datetime
from datetime import datetime
# calc function to determine the elapsed time
def calc(s):
return s ** 2
# tracking the start time in datetime format
st = datetime.now()
# calling the calc func()
calc(3)
# tracking the end time in datetime format
e = datetime.now()
# displaying the elapsed time
print("Elapsed", (e - st).total_seconds() * 10**6, "µs")
Keluaran Untuk mengukur cuplikan kode kecil, modul timeit Python sering digunakan. Fungsi ini dijalankan dengan fungsi yang tidak diketahui dengan beberapa eksekusi. Sedangkan penentuan waktu eksekusi mematikan pengumpulan sampah tetapi tidak secara permanen Sekarang dalam kode di bawah ini, kita akan melihat bagaimana modul ini bekerja, dan juga kita akan mengimplementasikannya untuk menentukan waktu berlalu dari ekspresi lambda. Setelah mengimpor modul timeit, kami akan menentukan waktu yang telah berlalu dengan menggunakan fungsi timeit() dari modul
Kode
# importing timeit module import timeit # to determine the elapsed time # code statement is defined to test elap_time = timeit.timeit("print('Hello World!')") # displaying the elapsed time print(elap_time, "secs.") _
Keluaran
Hello World! Hello World! Hello World! Hello World! Hello World! ... 1.632629341998836 secs. _
- Penjelasan Sekarang potongan kode di atas akan mencetak "Hello World. " 10^6 kali sebagai parameter default adalah 1000000. Terakhir, kode ini akan mencetak waktu Berlalu dalam hitungan detik
Pada kode di bawah ini, kita akan menulis blok kode python yang berisi fungsi, dan itu disebut string dan setelah itu, kita akan meneruskan string itu ke waktu. fungsi timeit(). Untuk menghitung waktu yang berlalu, kami akan menentukan jumlah iterasi
Kode
# importing timeit import timeit # the block of code that has to be measured code_segment = '''\ import random def exe(x): return x**x execute(random.randint(20, 50)) ''' # executing the block of code and determining the elapsed time elap_time = timeit.timeit(code_segment, number=10**6) # displaying the elapsed time in seconds. # closest to the 3-decimal places print(f"{elap_time:.03f} secs.")
Keluaran
- Penjelasan Pada contoh di atas, fungsi python didefinisikan dan dipanggil, dan fungsi tersebut ditulis sebagai representasi string. Untuk 10^6 kali, kami akan menguji waktu berjalan dan kemudian kami akan menampilkan jumlah waktu yang dibutuhkan dalam detik untuk menjalankan fungsi
Metode ini membantu kita dengan menyelamatkan kita dari kesulitan menyimpan nilai dalam array dan membuat perulangan. Ini akan membantu mendapatkan nilai waktu eksekusi dari beberapa eksekusi dari blok kode yang sama. Kami menggunakan waktu. fungsi repeat() sebagai pengganti timeit. fungsi timeit(). Dibutuhkan parameter pengulangan
Kode
# importing timeit module import timeit # calc function test the elapsed time def calc(y): return y ** 2 rec = timeit.repeat(lambda: calc(3), number=10, repeat=5) # displaying the elapsed time for i, elap_time in enumerate(rec, 1): # displaying the elapsed time of code in microseconds ms = round(elap_time * 10 ** 6, 2) print(f"Case {index}: Time Taken: {m_secs}µs")
Keluaran
Elapsed time 1.014 micro secs. 0
Metode ini menggunakan waktu. perf_counter() untuk melacak stempel waktu dalam nanodetik dari sebuah instance, dan kemudian kita dapat mengurangi waktu akhir dan waktu mulai untuk mendapatkan durasi waktu Berlalu dalam nanodetik