Đo thời gian đã trôi qua với mô-đun Thời gian

Với mô-đun Time trong python, có thể đo thời gian trôi qua không? Nếu vậy, làm thế nào để tôi làm điều đó?

Tôi cần phải làm điều này để nếu con trỏ đã ở trong một widget trong một thời gian nhất định thì một sự kiện sẽ xảy ra.

start_time = time.time()
# your code
elapsed_time = time.time() - start_time

Bạn cũng có thể viết trình trang trí đơn giản để đơn giản hóa việc đo thời gian thực hiện của các chức năng khác nhau:

import time
from functools import wraps

PROF_DATA = {}

def profile(fn):
    @wraps(fn)
    def with_profiling(*args, **kwargs):
        start_time = time.time()

        ret = fn(*args, **kwargs)

        elapsed_time = time.time() - start_time

        if fn.__name__ not in PROF_DATA:
            PROF_DATA[fn.__name__] = [0, []]
        PROF_DATA[fn.__name__][0] += 1
        PROF_DATA[fn.__name__][1].append(elapsed_time)

        return ret

    return with_profiling

def print_prof_data():
    for fname, data in PROF_DATA.items():
        max_time = max(data[1])
        avg_time = sum(data[1]) / len(data[1])
        print "Function %s called %d times. " % (fname, data[0]),
        print 'Execution time max: %.3f, average: %.3f' % (max_time, avg_time)

def clear_prof_data():
    global PROF_DATA
    PROF_DATA = {}

Sử dụng:

@profile
def your_function(...):
    ...

Bạn có thể cấu hình nhiều hơn một chức năng cùng một lúc. Sau đó, để in các phép đo, chỉ cần gọi print_prof_data ():

time.time() sẽ làm việc

import time

start = time.time()
# run your code
end = time.time()

elapsed = end - start

Bạn có thể muốn xem xét câu hỏi này , nhưng tôi không nghĩ nó sẽ cần thiết.

Đối với người dùng muốn định dạng tốt hơn,

import time
start_time = time.time()
# your script
elapsed_time = time.time() - start_time
time.strftime("%H:%M:%S", time.gmtime(elapsed_time))

sẽ in ra, trong 2 giây:

'00:00:02'

và trong 7 phút một giây:

'00:07:01'

lưu ý rằng đơn vị thời gian tối thiểu với gmtime là giây. Nếu bạn cần micro giây, hãy xem xét những điều sau:

import datetime
start = datetime.datetime.now()
# some code
end = datetime.datetime.now()
elapsed = end - start
print(elapsed)
# or
print(elapsed.seconds,":",elapsed.microseconds) 

tài liệu strftime

Để đo thời gian trôi qua tốt nhất (kể từ Python 3.3), hãy sử dụng time.perf_counter().

Trả về giá trị (tính bằng giây) của bộ đếm hiệu suất, tức là đồng hồ có độ phân giải cao nhất có sẵn để đo thời lượng ngắn. Nó bao gồm thời gian trôi qua trong khi ngủ và toàn hệ thống. Điểm tham chiếu của giá trị trả về là không xác định, do đó chỉ có sự khác biệt giữa kết quả của các cuộc gọi liên tiếp là hợp lệ.

Đối với các phép đo theo thứ tự giờ / ngày, bạn không quan tâm đến độ phân giải dưới giây, vì vậy hãy sử dụng time.monotonic()thay thế.

Trả về giá trị (tính bằng giây) của đồng hồ đơn điệu, tức là đồng hồ không thể lùi lại. Đồng hồ không bị ảnh hưởng bởi cập nhật đồng hồ hệ thống. Điểm tham chiếu của giá trị trả về là không xác định, do đó chỉ có sự khác biệt giữa kết quả của các cuộc gọi liên tiếp là hợp lệ.

Trong nhiều triển khai, đây thực sự có thể là điều tương tự.

Trước 3.3, bạn bị mắc kẹt với time.clock().

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 thời gian xử lý của bộ xử lý thời gian, phụ thuộc vào chức năng C cùng tên.

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.

Cập nhật cho Python 3.7

Điểm mới trong Python 3.7 là PEP 564 - Thêm các hàm thời gian mới với độ phân giải nano giây.

Việc sử dụng chúng có thể loại bỏ thêm các lỗi làm tròn và dấu phẩy động, đặc biệt là nếu bạn đo các khoảng thời gian rất ngắn hoặc ứng dụng của bạn (hoặc máy Windows) hoạt động lâu.

Nghị quyết bắt đầu bị phá vỡ perf_counter()sau khoảng 100 ngày. Vì vậy, ví dụ sau một năm thời gian hoạt động, khoảng thời gian ngắn nhất (lớn hơn 0) nó có thể đo sẽ lớn hơn so với khi bắt đầu.

Cập nhật cho Python 3.8

time.clock bây giờ đã biến mất

Trong một thời gian dài hơn.

import time
start_time = time.time()
...
e = int(time.time() - start_time)
print('{:02d}:{:02d}:{:02d}'.format(e // 3600, (e % 3600 // 60), e % 60))

sẽ in

00:03:15

nếu hơn 24 giờ

25:33:57

Điều đó được lấy cảm hứng từ câu trả lời của Rutger Hofste. Cảm ơn bạn

Bạn cần nhập thời gian và sau đó sử dụng phương thức time.time () để biết thời gian hiện tại.

import time

start_time=time.time() #taking current time as starting time

#here your code

elapsed_time=time.time()-start_time #again taking current time - starting time 

Một cách tốt đẹp để thời gian điều là sử dụng với cấu trúc python.

với cấu trúc đang tự động gọi các phương thức __enter__ và __exit__ , đó chính xác là những gì chúng ta cần để tính thời gian.

Hãy tạo một lớp Timer .

from time import time

class Timer():
    def __init__(self, message):
        self.message = message
    def __enter__(self):
        self.start = time()
        return None  # could return anything, to be used like this: with Timer("Message") as value:
    def __exit__(self, type, value, traceback):
        elapsed_time = (time() - self.start) * 1000
        print(self.message.format(elapsed_time))

Sau đó, người ta có thể sử dụng lớp Timer như thế này:

with Timer("Elapsed time to compute some prime numbers: {}ms"):
    primes = []
    for x in range(2, 500):
        if not any(x % p == 0 for p in primes):
            primes.append(x)
    print("Primes: {}".format(primes))

Kết quả là như sau:

Số nguyên tố: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 89 , 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 227 , 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373 , 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499]

Thời gian đã trôi qua để tính một số số nguyên tố: 5,01704216003418ms

Phản ứng của Gulim Shender là tuyệt vời. Bạn cũng có thể sử dụng một trang trí đơn giản hơn như dưới đây:

import datetime
def calc_timing(original_function):                            
    def new_function(*args,**kwargs):                        
        start = datetime.datetime.now()                     
        x = original_function(*args,**kwargs)                
        elapsed = datetime.datetime.now()                      
        print("Elapsed Time = {0}".format(elapsed-start))     
        return x                                             
    return new_function()  

@calc_timing
def a_func(*variables):
    print("do something big!")

Trong lập trình, có 2 cách chính để đo thời gian , với các kết quả khác nhau:

>>> print(time.process_time()); time.sleep(10); print(time.process_time())
0.11751394000000001
0.11764988400000001  # took  0 seconds and a bit
>>> print(time.perf_counter()); time.sleep(10); print(time.perf_counter())
3972.465770326
3982.468109075       # took 10 seconds and a bit

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

Dưới đây là bản cập nhật cho mã thông minh của Vadim Shender với đầu ra dạng bảng:

import collections
import time
from functools import wraps

PROF_DATA = collections.defaultdict(list)

def profile(fn):
    @wraps(fn)
    def with_profiling(*args, **kwargs):
        start_time = time.time()
        ret = fn(*args, **kwargs)
        elapsed_time = time.time() - start_time
        PROF_DATA[fn.__name__].append(elapsed_time)
        return ret
    return with_profiling

Metrics = collections.namedtuple("Metrics", "sum_time num_calls min_time max_time avg_time fname")

def print_profile_data():
    results = []
    for fname, elapsed_times in PROF_DATA.items():
        num_calls = len(elapsed_times)
        min_time = min(elapsed_times)
        max_time = max(elapsed_times)
        sum_time = sum(elapsed_times)
        avg_time = sum_time / num_calls
        metrics = Metrics(sum_time, num_calls, min_time, max_time, avg_time, fname)
        results.append(metrics)
    total_time = sum([m.sum_time for m in results])
    print("\t".join(["Percent", "Sum", "Calls", "Min", "Max", "Mean", "Function"]))
    for m in sorted(results, reverse=True):
        print("%.1f\t%.3f\t%d\t%.3f\t%.3f\t%.3f\t%s" % (100 * m.sum_time / total_time, m.sum_time, m.num_calls, m.min_time, m.max_time, m.avg_time, m.fname))
    print("%.3f Total Time" % total_time)