Keakuratan Python, time.clock () vs time.time ()?

Manakah yang lebih baik digunakan untuk menentukan waktu dengan Python? time.clock () atau time.time ()? Mana yang lebih akurat?

sebagai contoh:

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

vs.

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

Pada 3.3, time.clock () sudah usang , dan disarankan untuk menggunakan time.process_time () atau time.perf_counter () sebagai gantinya.

Sebelumnya di 2.7, sesuai dengan dokumen modul waktu :

time.clock ()

Pada Unix, kembalikan waktu prosesor saat ini sebagai angka titik mengambang yang dinyatakan dalam detik. Ketepatannya, dan pada kenyataannya definisi dari arti “waktu prosesor”, tergantung pada fungsi C dari nama yang sama, tetapi dalam hal apa pun, ini adalah fungsi yang digunakan untuk pembandingan algoritma Python atau timing.

Pada Windows, fungsi ini mengembalikan detik jam dinding yang berlalu sejak panggilan pertama ke fungsi ini, sebagai angka titik mengambang, berdasarkan pada fungsi Win32 QueryPerformanceCounter (). Resolusi biasanya lebih baik dari satu mikrodetik.

Selain itu, ada modul timeit untuk cuplikan kode pembandingan.

Jawaban singkatnya adalah: sebagian besar waktu time.clock()akan lebih baik. Namun, jika Anda menghitung waktu beberapa perangkat keras (misalnya beberapa algoritma yang Anda masukkan ke dalam GPU), maka time.clock()akan membuang waktu ini dan time.time()merupakan satu-satunya solusi yang tersisa.

Catatan: apa pun metode yang digunakan, waktunya akan tergantung pada faktor-faktor yang tidak dapat Anda kendalikan (kapan proses akan beralih, seberapa sering, ...), ini lebih buruk dengan time.time()tetapi ada juga dengan time.clock(), jadi Anda tidak boleh menjalankan satu tes waktu saja, tetapi selalu jalankan serangkaian tes dan lihat mean / varians dari kali.

Lainnya telah menjawab re: time.time()vs time.clock().

Namun, jika Anda menentukan waktu pelaksanaan blok kode untuk tujuan pembandingan / pembuatan profil, Anda harus melihat pada timeitmodul .

Satu hal yang perlu diingat: Mengubah waktu sistem memengaruhi time.time()tetapi tidak time.clock().

Saya perlu mengendalikan beberapa eksekusi tes otomatis. Jika satu langkah dari test case membutuhkan lebih dari jumlah waktu tertentu, TC itu dibatalkan untuk melanjutkan dengan yang berikutnya.

Tetapi kadang-kadang diperlukan langkah untuk mengubah waktu sistem (untuk memeriksa modul penjadwal aplikasi yang sedang diuji), jadi setelah mengatur waktu sistem beberapa jam di masa mendatang, batas waktu TC berakhir dan kasus uji dibatalkan. Saya harus beralih dari time.time()ke time.clock()untuk menangani ini dengan benar.

clock() -> nomor floating point

Kembalikan waktu CPU atau waktu nyata sejak awal proses atau sejak panggilan pertama clock(). Ini memiliki ketepatan yang sama seperti catatan sistem.

time() -> nomor floating point

Kembalikan waktu saat ini dalam detik sejak Zaman. Pecahan dari satu detik dapat hadir jika jam sistem menyediakannya.

Biasanya time()lebih tepat, karena sistem operasi tidak menyimpan waktu proses berjalan dengan presisi mereka menyimpan waktu sistem (yaitu, waktu aktual)

Tergantung pada apa yang Anda pedulikan. Jika yang Anda maksud WALL TIME (seperti dalam, waktu pada jam di dinding Anda), time.clock () memberikan akurasi TIDAK karena dapat mengatur waktu CPU.

time()memiliki presisi yang lebih baik daripada clock()di Linux. clock()hanya memiliki presisi kurang dari 10 ms. Sementara time()memberikan presisi prefek. Tes saya pada CentOS 6.4, python 2.6

using time():

1 requests, response time: 14.1749382019 ms
2 requests, response time: 8.01301002502 ms
3 requests, response time: 8.01491737366 ms
4 requests, response time: 8.41021537781 ms
5 requests, response time: 8.38804244995 ms

using clock():

1 requests, response time: 10.0 ms
2 requests, response time: 0.0 ms 
3 requests, response time: 0.0 ms
4 requests, response time: 10.0 ms
5 requests, response time: 0.0 ms 
6 requests, response time: 0.0 ms
7 requests, response time: 0.0 ms 
8 requests, response time: 0.0 ms

Perbedaannya sangat spesifik platform.

clock () sangat berbeda di Windows daripada di Linux, misalnya.

Untuk jenis contoh yang Anda jelaskan, Anda mungkin menginginkan modul "timeit".

Seperti orang lain telah mencatat time.clock()sudah ditinggalkan mendukung time.perf_counter()atau time.process_time(), tapi Python 3.7 memperkenalkan nanodetik resolusi waktu dengan time.perf_counter_ns(), time.process_time_ns(), dan time.time_ns(), bersama dengan 3 fungsi lainnya.

6 fungsi resolusi nansecond baru ini dirinci dalam PEP 564 :

time.clock_gettime_ns(clock_id)

time.clock_settime_ns(clock_id, time:int)

time.monotonic_ns()

time.perf_counter_ns()

time.process_time_ns()

time.time_ns()

Fungsi-fungsi ini mirip dengan versi tanpa akhiran _ns, tetapi mengembalikan sejumlah nanodetik sebagai int Python.

Seperti yang telah dicatat orang lain, gunakan timeitmodul untuk fungsi waktu dan cuplikan kode kecil.

Pada waktu Unix time.clock () mengukur jumlah waktu CPU yang telah digunakan oleh proses saat ini, jadi tidak ada gunanya untuk mengukur waktu yang telah berlalu dari beberapa titik di masa lalu. Pada Windows, ini akan mengukur detik jam dinding yang berlalu sejak panggilan pertama ke fungsi. Pada kedua sistem time.time () akan mengembalikan detik yang berlalu sejak zaman.

Jika Anda menulis kode yang dimaksudkan hanya untuk Windows, keduanya akan berfungsi (meskipun Anda akan menggunakan keduanya secara berbeda - tidak perlu pengurangan untuk time.clock ()). Jika ini akan berjalan pada sistem Unix atau Anda menginginkan kode yang dijamin portabel, Anda akan ingin menggunakan time.time ().

Jawaban singkat: gunakan time.clock () untuk menghitung waktu dengan Python.

Pada sistem * nix, clock () mengembalikan waktu prosesor sebagai angka floating point, dinyatakan dalam detik. Pada Windows, ia mengembalikan detik yang telah berlalu sejak panggilan pertama ke fungsi ini, sebagai nomor floating point.

time () mengembalikan detik sejak zaman, dalam UTC, sebagai angka floating point. Tidak ada jaminan bahwa Anda akan mendapatkan ketepatan yang lebih baik yaitu 1 detik (meskipun waktu () mengembalikan angka floating point). Juga perhatikan bahwa jika jam sistem telah diatur kembali antara dua panggilan ke fungsi ini, panggilan fungsi kedua akan mengembalikan nilai yang lebih rendah.

Untuk yang terbaik dari pemahaman saya, time.clock () memiliki ketepatan sebanyak sistem Anda akan memungkinkannya.

Saya menggunakan kode ini untuk membandingkan 2 metode. OS saya adalah windows 8, prosesor inti i5, RAM 4GB

import time

def t_time():
    start=time.time()
    time.sleep(0.1)
    return (time.time()-start)


def t_clock():
    start=time.clock()
    time.sleep(0.1)
    return (time.clock()-start)




counter_time=0
counter_clock=0

for i in range(1,100):
    counter_time += t_time()

    for i in range(1,100):
        counter_clock += t_clock()

print "time() =",counter_time/100
print "clock() =",counter_clock/100

keluaran:

waktu () = 0,0993799996376

jam () = 0,0993572257367

Jawaban yang benar: Keduanya memiliki fraksi yang sama.

Tapi yang lebih cepat jika subjectini time?

Sebuah test case kecil :

import timeit
import time

clock_list = []
time_list = []

test1 = """
def test(v=time.clock()):
    s = time.clock() - v
"""

test2 = """
def test(v=time.time()):
    s = time.time() - v
"""
def test_it(Range) :
    for i in range(Range) :
        clk = timeit.timeit(test1, number=10000)
        clock_list.append(clk)
        tml = timeit.timeit(test2, number=10000)
        time_list.append(tml)

test_it(100)

print "Clock Min: %f Max: %f Average: %f" %(min(clock_list), max(clock_list), sum(clock_list)/float(len(clock_list)))
print "Time  Min: %f Max: %f Average: %f" %(min(time_list), max(time_list), sum(time_list)/float(len(time_list)))

Saya tidak bekerja di laboratorium Swiss tapi saya sudah menguji ..

Berdasarkan pertanyaan ini: time.clock()lebih baik daripadatime.time()

Sunting: time.clock()adalah penghitung internal sehingga tidak dapat digunakan di luar, mendapat batasan max 32BIT FLOAT, tidak dapat melanjutkan penghitungan jika tidak menyimpan nilai pertama / terakhir. Tidak dapat menggabungkan satu konter lain ...

time.clock()dihapus di Python 3.8 karena memiliki perilaku yang bergantung pada platform :

• Pada Unix , kembalikan waktu prosesor saat ini sebagai angka titik mengambang yang dinyatakan dalam detik.

• Di Windows , fungsi ini mengembalikan detik jam dinding yang berlalu sejak panggilan pertama ke fungsi ini, sebagai nomor titik mengambang

  print(time.clock()); time.sleep(10); print(time.clock())
  # Linux  :  0.0382  0.0384   # see Processor Time
  # Windows: 26.1224 36.1566   # see Wall-Clock Time

Jadi, fungsi mana yang harus dipilih?

• Waktu Prosesor : Ini adalah berapa lama proses spesifik ini digunakan secara aktif pada CPU. Tidur, menunggu permintaan web, atau waktu ketika hanya proses lain dieksekusi tidak akan berkontribusi untuk ini.

  • Menggunakan time.process_time()

• Waktu Jam Dinding : Ini mengacu pada berapa banyak waktu yang telah berlalu "pada jam yang tergantung di dinding", yaitu di luar waktu nyata.

  • Menggunakan time.perf_counter()

    • time.time() juga mengukur waktu jam dinding tetapi dapat diatur ulang, sehingga Anda dapat kembali ke masa lalu
    • time.monotonic() tidak dapat diatur ulang (monoton = hanya berjalan maju) tetapi memiliki presisi lebih rendah dari time.perf_counter()

Membandingkan hasil pengujian antara Ubuntu Linux dan Windows 7.

Di Ubuntu

>>> start = time.time(); time.sleep(0.5); (time.time() - start)
0.5005500316619873

Di Windows 7

>>> start = time.time(); time.sleep(0.5); (time.time() - start)
0.5