Độ chính xác time.clock () so với time.time () của Python?

Cái nào tốt hơn để sử dụng cho thời gian trong Python? time.clock () hoặc time.time ()? Cái nào cung cấp độ chính xác cao hơn?

ví dụ:

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

so với

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

Kể từ 3.3, time.clock () không được dùng nữa và thay vào đó, chúng tôi khuyên bạn nên sử dụng time. Process_time () hoặc time.perf_corer () .

Trước đây trong 2.7, theo tài liệu mô-đun thời gian :

đồng hồ thời gian()

Trên Unix, trả về thời gian của bộ xử lý hiện tại dưới dạng số dấu phẩy động được biểu thị bằng giây. Độ chính xác, và trên thực tế, chính là định nghĩa về ý nghĩa của bộ xử lý thời gian, bộ xử lý, phụ thuộc vào chức năng C cùng tên, nhưng trong mọi trường hợp, đây là chức năng sử dụng để đo điểm chuẩn Python hoặc thuật toán thời gian.

Trên Windows, hàm này trả về số giây đồng hồ treo tường đã trôi qua kể từ lần gọi đầu tiên đến hàm này, dưới dạng số dấu phẩy động, dựa trên hàm Win32 QueryPerformanceCorer (). Độ phân giải thường tốt hơn một micro giây.

Ngoài ra, có timeit module cho benchmarking đoạn mã.

Câu trả lời ngắn gọn là: hầu hết thời gian time.clock()sẽ tốt hơn. Tuy nhiên, nếu bạn định thời gian cho một số phần cứng (ví dụ: một số thuật toán bạn đặt trong GPU), thì time.clock()sẽ thoát khỏi thời điểm này và time.time()là giải pháp duy nhất còn lại.

Lưu ý: dù sử dụng phương pháp nào, thời gian sẽ phụ thuộc vào các yếu tố bạn không thể kiểm soát (khi nào thì quá trình chuyển đổi, tần suất, ...), điều này còn tệ hơn time.time()nhưng cũng tồn tại với time.clock(), vì vậy bạn không bao giờ nên chỉ chạy một bài kiểm tra thời gian, nhưng luôn luôn chạy một loạt các thử nghiệm và xem xét trung bình / phương sai của thời đại.

Những người khác đã trả lời lại: time.time()vs time.clock().

Tuy nhiên, nếu bạn định thời gian thực hiện một khối mã cho mục đích đo điểm chuẩn / lược tả, bạn nên xem timeitmô-đun .

Một điều cần lưu ý: Thay đổi thời gian hệ thống có ảnh hưởng time.time()nhưng không time.clock().

Tôi cần phải kiểm soát một số thực thi kiểm tra tự động. Nếu một bước của trường hợp thử nghiệm mất hơn một khoảng thời gian nhất định, thì TC đó đã bị hủy bỏ để tiếp tục với bước tiếp theo.

Nhưng đôi khi một bước cần thiết để thay đổi thời gian hệ thống (để kiểm tra mô-đun lập lịch của ứng dụng đang thử nghiệm), vì vậy sau khi cài đặt thời gian hệ thống một vài giờ trong tương lai, thời gian chờ TC hết hạn và trường hợp thử nghiệm bị hủy bỏ. Tôi đã phải chuyển từ time.time()để time.clock()xử lý này đúng cách.

clock() -> số dấu phẩy động

Trả về thời gian CPU hoặc thời gian thực kể từ khi bắt đầu quá trình hoặc kể từ lần gọi đầu tiên clock(). Điều này có độ chính xác như hồ sơ hệ thống.

time() -> số dấu phẩy động

Trả lại thời gian hiện tại tính bằng giây kể từ Kỷ nguyên. Phân số của một giây có thể có mặt nếu đồng hồ hệ thống cung cấp cho họ.

Thông thường thì time()chính xác hơn, bởi vì các hệ điều hành không lưu trữ thời gian chạy quy trình với độ chính xác mà chúng lưu trữ thời gian hệ thống (tức là thời gian thực tế)

Phụ thuộc vào những gì bạn quan tâm. Nếu bạn có nghĩa là TƯỜNG THỜI GIAN (như trong, thời gian trên đồng hồ trên tường của bạn), time.clock () không cung cấp độ chính xác vì nó có thể quản lý thời gian của CPU.

time()có độ chính xác tốt hơn so với clock()trên Linux. clock()chỉ có độ chính xác dưới 10 ms. Trong khi time()cho độ chính xác hoàn hảo. Thử nghiệm của tôi là trên 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

Sự khác biệt là rất cụ thể nền tảng.

clock () rất khác nhau trên Windows, ví dụ như trên Linux.

Đối với loại ví dụ bạn mô tả, có thể bạn muốn mô-đun "timeit" thay thế.

Như những người khác đã ghi nhận time.clock()được phản đối ủng hộ time.perf_counter()hay time.process_time(), nhưng Python 3.7 giới thiệu nano giây thời gian giải quyết với time.perf_counter_ns(), time.process_time_ns()vàtime.time_ns() , cùng với 3 chức năng khác.

6 chức năng phân giải nansecond mới này được trình bày chi tiết trong 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()

Các hàm này tương tự như phiên bản không có hậu tố _ns, nhưng trả về một số nano giây như một int Python.

Như những người khác cũng đã lưu ý, sử dụng timeitmô-đun cho các hàm thời gian và các đoạn mã nhỏ.

Trên Unix time.clock () đo lượng thời gian CPU đã được sử dụng bởi quy trình hiện tại, do đó, sẽ không tốt khi đo thời gian đã trôi qua từ một thời điểm nào đó trong quá khứ. Trên Windows, nó sẽ đo giây đồng hồ treo tường trôi qua kể từ lần gọi đầu tiên đến chức năng. Trên một trong hai thời gian hệ thống.time () sẽ trả về giây trôi qua kể từ kỷ nguyên.

Nếu bạn đang viết mã chỉ dành cho Windows, thì nó sẽ hoạt động (mặc dù bạn sẽ sử dụng hai cách khác nhau - không cần phép trừ cho time.clock ()). Nếu điều này sẽ chạy trên một hệ thống Unix hoặc bạn muốn mã được đảm bảo là có thể mang theo được, bạn sẽ muốn sử dụng time.time ().

Câu trả lời ngắn: sử dụng time.clock () để định thời gian trong Python.

Trên các hệ thống * nix, clock () trả về thời gian của bộ xử lý dưới dạng số dấu phẩy động, được biểu thị bằng giây. Trên Windows, nó trả về số giây đã trôi qua kể từ lần gọi đầu tiên đến chức năng này, dưới dạng số dấu phẩy động.

time () trả về số giây kể từ epoch, trong UTC, dưới dạng số dấu phẩy động. Không có gì đảm bảo rằng bạn sẽ có được độ chính xác tốt hơn là 1 giây (mặc dù thời gian () trả về số dấu phẩy động). Cũng lưu ý rằng nếu đồng hồ hệ thống đã được đặt lại giữa hai cuộc gọi đến chức năng này, cuộc gọi chức năng thứ hai sẽ trả về giá trị thấp hơn.

Theo sự hiểu biết tốt nhất của tôi, time.clock () có độ chính xác như hệ thống của bạn sẽ cho phép.

Tôi sử dụng mã này để so sánh 2 phương thức. HĐH của tôi là windows 8, core xử lý 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

đầu ra:

thời gian () = 0,0993799996376

đồng hồ () = 0,0993572257367

Câu trả lời đúng: Cả hai đều có cùng độ dài của một phân số.

Nhưng cái nào nhanh hơn nếu subjectcó time?

Một trường hợp thử nghiệm nhỏ :

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

Tôi không làm việc tại một phòng thí nghiệm Thụy Sĩ nhưng tôi đã thử nghiệm ..

Dựa trên câu hỏi này: time.clock()tốt hơntime.time()

Chỉnh sửa: time.clock()là bộ đếm nội bộ nên không thể sử dụng bên ngoài, có giới hạn max 32BIT FLOAT, không thể tiếp tục đếm nếu không lưu trữ giá trị đầu tiên / cuối cùng. Không thể hợp nhất một bộ đếm khác ...

time.clock()đã bị xóa trong Python 3.8 vì nó có hành vi phụ thuộc vào nền tảng :

• Trên Unix , trả về thời gian của bộ xử lý hiện tại dưới dạng số dấu phẩy động được biểu thị bằng giây.

• Trên Windows , chức năng này trả về giây đồng hồ treo tường đã trôi qua kể từ lần gọi đầu tiên đến chức năng này, dưới dạng số dấu phẩy động

  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

Vậy nên chọn chức năng nào?

• Thời gian xử lý : Đây là khoảng thời gian quy trình cụ thể này dành tích cực được thực thi trên CPU. Ngủ, chờ yêu cầu web hoặc thời gian khi chỉ các quy trình khác được thực thi sẽ không đóng góp cho việc này.

  • Sử dụng time.process_time()

• Thời gian trên đồng hồ treo tường: Điều này đề cập đến thời gian đã trôi qua "trên đồng hồ treo trên tường", tức là ngoài thời gian thực.

  • Sử dụng time.perf_counter()

    • time.time() cũng đo thời gian đồng hồ treo tường nhưng có thể được đặt lại, vì vậy bạn có thể quay ngược thời gian
    • time.monotonic() không thể được đặt lại (đơn điệu = chỉ đi tiếp) nhưng có độ chính xác thấp hơn time.perf_counter()

So sánh kết quả thử nghiệm giữa Ubuntu Linux và Windows 7.

Trên Ubuntu

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

Trên Windows 7

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