it-swarm.dev

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)
410
Corey Goldberg

Pada 3.3, time.clock () sudah tidak digunakan lagi , dan disarankan untuk menggunakan waktu .process_time () atau time.perf_counter () sebagai gantinya.

Sebelumnya di 2.7, sesuai dengan dokumen modul wakt:

time.clock ()

Pada Unix, kembalikan waktu prosesor saat ini sebagai angka floating point yang dinyatakan dalam detik. Presisi, dan pada kenyataannya definisi dari arti “waktu prosesor”, tergantung pada fungsi C dari nama yang sama, tetapi dalam kasus apa pun, ini adalah fungsi yang digunakan untuk pembandingan algoritme Python atau waktu.

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

147
Jason Navarrete

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 menyingkirkan waktu ini dan time.time() adalah 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 sebaiknya tidak pernah menjalankan satu tes waktu hanya, tetapi selalu jalankan serangkaian tes dan lihat mean/varians dari kali.

45
PierreBdR

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

Namun, jika Anda menentukan waktu pelaksanaan blok kode untuk keperluan pembandingan/pembuatan profil, Anda harus melihat pada timeit module .

25
dF.

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.

19
Seba

clock() -> nomor floating point

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

time() -> nomor floating point

Kembalikan waktu saat ini dalam detik sejak Zaman. Fraksi per 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)

18
Vinko Vrsalovic

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

17
user15910

Untuk practice. time() saya sendiri memiliki presisi yang lebih baik daripada clock() di Linux. clock() hanya memiliki ketelitian 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
13
bestwolf1983

Perbedaannya sangat spesifik platform.

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

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

6
Justin Sheehy

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 hanya dimaksudkan 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 ingin kode yang dijamin portabel, Anda akan ingin menggunakan time.time ().

3
auspace

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

Pada sistem * nix, clock () mengembalikan waktu prosesor sebagai angka titik mengambang, dinyatakan dalam detik. Di 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 (walaupun 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.

2
Babak

Saya menggunakan kode ini untuk membandingkan 2 metode. OS saya adalah windows 8, prosesor core 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

2

Seperti orang lain telah mencatat time.clock() tidak digunakan lagi sebagai time.perf_counter() atau time.process_time(), tetapi Python 3.7 memperkenalkan waktu resolusi nanosecond 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 modul timeitNAME_ ke fungsi waktu dan cuplikan kode kecil.

2
Chris_Rands

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

2
Jake

Jawaban yang benar: Keduanya memiliki fraksi yang sama.

Tapi mana yang lebih cepat jika subject adalah time?

Sedikit test case:

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 tetapi saya sudah menguji ..

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

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

1
dsgdfg