Làm cách nào để tôi có thời gian thực hiện chương trình Python?

Tôi có một chương trình dòng lệnh trong Python mất một lúc để hoàn thành. Tôi muốn biết chính xác thời gian cần thiết để hoàn thành việc chạy.

Tôi đã xem timeitmô-đun, nhưng có vẻ như nó chỉ dành cho các đoạn mã nhỏ. Tôi muốn thời gian toàn bộ chương trình.

Cách đơn giản nhất trong Python:

import time
start_time = time.time()
main()
print("--- %s seconds ---" % (time.time() - start_time))

Điều này giả định rằng chương trình của bạn mất ít nhất một phần mười giây để chạy.

Bản in:

--- 0.764891862869 seconds ---

Tôi đặt timing.pymô-đun này vào site-packagesthư mục của riêng tôi và chỉ cần chèn import timingở đầu mô-đun của tôi:

import atexit
from time import clock

def secondsToStr(t):
    return "%d:%02d:%02d.%03d" % \
        reduce(lambda ll,b : divmod(ll[0],b) + ll[1:],
            [(t*1000,),1000,60,60])

line = "="*40
def log(s, elapsed=None):
    print line
    print secondsToStr(clock()), '-', s
    if elapsed:
        print "Elapsed time:", elapsed
    print line
    print

def endlog():
    end = clock()
    elapsed = end-start
    log("End Program", secondsToStr(elapsed))

def now():
    return secondsToStr(clock())

start = clock()
atexit.register(endlog)
log("Start Program")

Tôi cũng có thể gọi timing.logtừ trong chương trình của mình nếu có các giai đoạn quan trọng trong chương trình tôi muốn hiển thị. Nhưng chỉ bao gồm import timingsẽ in thời gian bắt đầu và kết thúc, và thời gian trôi qua tổng thể. (Tha thứ cho secondsToStrchức năng tối nghĩa của tôi , nó chỉ định dạng số dấu phẩy động của giây thành dạng hh: mm: ss.sss.)

Lưu ý: Có thể tìm thấy phiên bản Python 3 của đoạn mã trên tại đây hoặc tại đây .

Trong Linux hoặc Unix:

$ time python yourprogram.py

Trong Windows, hãy xem câu hỏi StackOverflow này: Làm cách nào để đo thời gian thực hiện lệnh trên dòng lệnh Windows?

Để có đầu ra dài dòng hơn,

$ time -v python yourprogram.py
    Command being timed: "python3 yourprogram.py"
    User time (seconds): 0.08
    System time (seconds): 0.02
    Percent of CPU this job got: 98%
    Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.10
    Average shared text size (kbytes): 0
    Average unshared data size (kbytes): 0
    Average stack size (kbytes): 0
    Average total size (kbytes): 0
    Maximum resident set size (kbytes): 9480
    Average resident set size (kbytes): 0
    Major (requiring I/O) page faults: 0
    Minor (reclaiming a frame) page faults: 1114
    Voluntary context switches: 0
    Involuntary context switches: 22
    Swaps: 0
    File system inputs: 0
    File system outputs: 0
    Socket messages sent: 0
    Socket messages received: 0
    Signals delivered: 0
    Page size (bytes): 4096
    Exit status: 0

Tôi thực sự thích câu trả lời của Paul McGuire , nhưng tôi sử dụng Python 3. Vì vậy, đối với những người quan tâm: đây là bản sửa đổi câu trả lời của anh ấy hoạt động với Python 3 trên * nix (tôi tưởng tượng, trong Windows, clock()nên được sử dụng thay vì time()):

#python3
import atexit
from time import time, strftime, localtime
from datetime import timedelta

def secondsToStr(elapsed=None):
    if elapsed is None:
        return strftime("%Y-%m-%d %H:%M:%S", localtime())
    else:
        return str(timedelta(seconds=elapsed))

def log(s, elapsed=None):
    line = "="*40
    print(line)
    print(secondsToStr(), '-', s)
    if elapsed:
        print("Elapsed time:", elapsed)
    print(line)
    print()

def endlog():
    end = time()
    elapsed = end-start
    log("End Program", secondsToStr(elapsed))

start = time()
atexit.register(endlog)
log("Start Program")

Nếu bạn thấy điều này hữu ích, bạn vẫn nên bình chọn câu trả lời của anh ấy thay vì câu trả lời này, vì anh ấy đã làm hầu hết công việc;).

import time

start_time = time.clock()
main()
print time.clock() - start_time, "seconds"

time.clock()trả về thời gian của bộ xử lý, cho phép chúng ta chỉ tính thời gian được sử dụng bởi quy trình này (dù sao trên Unix). Tài liệu nói "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"

Tôi thích đầu ra mà datetimemô-đun cung cấp, trong đó các đối tượng delta thời gian hiển thị ngày, giờ, phút, v.v. khi cần thiết theo cách có thể đọc được của con người.

Ví dụ:

from datetime import datetime
start_time = datetime.now()
# do your work here
end_time = datetime.now()
print('Duration: {}'.format(end_time - start_time))

Sản lượng mẫu, vd

Duration: 0:00:08.309267

hoặc là

Duration: 1 day, 1:51:24.269711

Như JF Sebastian đã đề cập, phương pháp này có thể gặp phải một số trường hợp khó khăn với giờ địa phương, vì vậy sẽ an toàn hơn khi sử dụng:

import time
from datetime import timedelta
start_time = time.monotonic()
end_time = time.monotonic()
print(timedelta(seconds=end_time - start_time))

Bạn có thể sử dụng cProfile Python profiler để đo thời gian CPU và thêm vào đó là bao nhiêu thời gian được sử dụng bên trong mỗi chức năng và số lần mỗi chức năng được gọi. Điều này rất hữu ích nếu bạn muốn cải thiện hiệu suất của tập lệnh mà không biết bắt đầu từ đâu. Câu trả lời này cho một câu hỏi Stack Overflow khác là khá tốt. Luôn luôn tốt để có một cái nhìn trong tài liệu .

Dưới đây là một ví dụ về cách cấu hình tập lệnh bằng cProfile từ một dòng lệnh:

$ python -m cProfile euler048.py

1007 function calls in 0.061 CPU seconds

Ordered by: standard name
ncalls  tottime  percall  cumtime  percall filename:lineno(function)
    1    0.000    0.000    0.061    0.061 <string>:1(<module>)
 1000    0.051    0.000    0.051    0.000 euler048.py:2(<lambda>)
    1    0.005    0.005    0.061    0.061 euler048.py:2(<module>)
    1    0.000    0.000    0.061    0.061 {execfile}
    1    0.002    0.002    0.053    0.053 {map}
    1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler objects}
    1    0.000    0.000    0.000    0.000 {range}
    1    0.003    0.003    0.003    0.003 {sum}

Thậm chí tốt hơn cho Linux: time

$ time -v python rhtest2.py

    Command being timed: "python rhtest2.py"
    User time (seconds): 4.13
    System time (seconds): 0.07
    Percent of CPU this job got: 91%
    Elapsed (wall clock) time (h:mm:ss or m:ss): 0:04.58
    Average shared text size (kbytes): 0
    Average unshared data size (kbytes): 0
    Average stack size (kbytes): 0
    Average total size (kbytes): 0
    Maximum resident set size (kbytes): 0
    Average resident set size (kbytes): 0
    Major (requiring I/O) page faults: 15
    Minor (reclaiming a frame) page faults: 5095
    Voluntary context switches: 27
    Involuntary context switches: 279
    Swaps: 0
    File system inputs: 0
    File system outputs: 0
    Socket messages sent: 0
    Socket messages received: 0
    Signals delivered: 0
    Page size (bytes): 4096
    Exit status: 0

đồng hồ thời gian()

Không dùng nữa kể từ phiên bản 3.3: Hành vi của chức năng này phụ thuộc vào nền tảng: sử dụng perf_corer () hoặc process_time () thay vào đó, tùy thuộc vào yêu cầu của bạn, để có hành vi được xác định rõ.

time.perf_count ()

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ó không bao gồm thời gian trôi qua trong lúc ngủ và toàn hệ thống.

time. process_time ()

Trả về giá trị (tính bằng giây) của tổng thời gian CPU của hệ thống và người dùng của quy trình hiện tại. Nó không bao gồm thời gian trôi qua trong khi ngủ.

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

Chỉ cần sử dụng timeitmô-đun. Nó hoạt động với cả Python 2 và Python 3.

import timeit

start = timeit.default_timer()

# All the program statements
stop = timeit.default_timer()
execution_time = stop - start

print("Program Executed in "+str(execution_time)) # It returns time in seconds

Nó trở lại trong vài giây và bạn có thể có thời gian thực hiện của bạn. Nó đơn giản, nhưng bạn nên viết chúng trong hàm mainw để bắt đầu thực thi chương trình. Nếu bạn muốn có được thời gian thực hiện ngay cả khi bạn gặp lỗi, hãy lấy tham số "Bắt đầu" của bạn cho nó và tính toán như sau:

def sample_function(start,**kwargs):
     try:
         # Your statements
     except:
         # except statements run when your statements raise an exception
         stop = timeit.default_timer()
         execution_time = stop - start
         print("Program executed in " + str(execution_time))

Đoạn mã sau đây in thời gian trôi qua trong một <HH:MM:SS>định dạng dễ đọc của con người .

import time
from datetime import timedelta

start_time = time.time()

#
# Perform lots of computations.
#

elapsed_time_secs = time.time() - start_time

msg = "Execution took: %s secs (Wall clock time)" % timedelta(seconds=round(elapsed_time_secs))

print(msg)    

from time import time
start_time = time()
...
end_time = time()
time_taken = end_time - start_time # time_taken is in seconds
hours, rest = divmod(time_taken,3600)
minutes, seconds = divmod(rest, 60)

Trong IPython , "timeit" bất kỳ tập lệnh nào:

def foo():
    %run bar.py
timeit foo()

Tôi đã xem mô-đun thời gian, nhưng có vẻ như nó chỉ dành cho các đoạn mã nhỏ. Tôi muốn thời gian toàn bộ chương trình.

$ python -mtimeit -n1 -r1 -t -s "from your_module import main" "main()"

Nó chạy your_module.main()chức năng một lần và in thời gian đã trôi qua bằng cách sử dụng time.time()chức năng như một bộ đếm thời gian.

Để mô phỏng /usr/bin/timetrong Python, hãy xem tiến trình con Python với / usr / bin / time: làm thế nào để nắm bắt thông tin thời gian mà bỏ qua tất cả các đầu ra khác? .

Để đo thời gian CPU (ví dụ: không bao gồm thời gian trong time.sleep()) cho từng chức năng, bạn có thể sử dụng profilemô-đun ( cProfiletrên Python 2):

$ python3 -mprofile your_module.py

Bạn có thể chuyển -psang timeitlệnh ở trên nếu bạn muốn sử dụng cùng một bộ đếm thời gian như profilesử dụng mô-đun.

Xem Làm thế nào bạn có thể hồ sơ một kịch bản Python?

Tôi cũng thích câu trả lời của Paul McGuire và đưa ra một hình thức quản lý bối cảnh phù hợp với nhu cầu của tôi hơn.

import datetime as dt
import timeit

class TimingManager(object):
    """Context Manager used with the statement 'with' to time some execution.

    Example:

    with TimingManager() as t:
       # Code to time
    """

    clock = timeit.default_timer

    def __enter__(self):
        """
        """
        self.start = self.clock()
        self.log('\n=> Start Timing: {}')

        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        """
        """
        self.endlog()

        return False

    def log(self, s, elapsed=None):
        """Log current time and elapsed time if present.
        :param s: Text to display, use '{}' to format the text with
            the current time.
        :param elapsed: Elapsed time to display. Dafault: None, no display.
        """
        print s.format(self._secondsToStr(self.clock()))

        if(elapsed is not None):
            print 'Elapsed time: {}\n'.format(elapsed)

    def endlog(self):
        """Log time for the end of execution with elapsed time.
        """
        self.log('=> End Timing: {}', self.now())

    def now(self):
        """Return current elapsed time as hh:mm:ss string.
        :return: String.
        """
        return str(dt.timedelta(seconds = self.clock() - self.start))

    def _secondsToStr(self, sec):
        """Convert timestamp to h:mm:ss string.
        :param sec: Timestamp.
        """
        return str(dt.datetime.fromtimestamp(sec))

Đối với những người sử dụng dữ liệu bằng Jupyter Notebook

Trong một ô, bạn có thể sử dụng %%timelệnh ma thuật của Jupyter để đo thời gian thực hiện:

%%time
[ x**2 for x in range(10000)]

Đầu ra

CPU times: user 4.54 ms, sys: 0 ns, total: 4.54 ms
Wall time: 4.12 ms

Điều này sẽ chỉ nắm bắt thời gian thực hiện của một ô cụ thể. Nếu bạn muốn nắm bắt thời gian thực hiện của toàn bộ sổ ghi chép (tức là chương trình), bạn có thể tạo một sổ ghi chép mới trong cùng thư mục và trong sổ ghi chép mới thực hiện tất cả các ô:

Giả sử máy tính xách tay ở trên được gọi example_notebook.ipynb. Trong một sổ ghi chép mới trong cùng một thư mục:

# Convert your notebook to a .py script:
!jupyter nbconvert --to script example_notebook.ipynb

# Run the example_notebook with -t flag for time
%run -t example_notebook

Đầu ra

IPython CPU timings (estimated):
  User   :       0.00 s.
  System :       0.00 s.
Wall time:       0.00 s.

Có một timeitmô-đun có thể được sử dụng để tính thời gian thực hiện mã Python.

Nó có tài liệu chi tiết và ví dụ trong tài liệu Python, 26.6. timeit - Đo thời gian thực hiện của các đoạn mã nhỏ .

Sử dụng line_profiler .

line_profiler sẽ cấu hình thời gian các dòng mã riêng lẻ thực hiện. Trình lược tả được triển khai trong C thông qua Cython để giảm chi phí cấu hình.

from line_profiler import LineProfiler
import random

def do_stuff(numbers):
    s = sum(numbers)
    l = [numbers[i]/43 for i in range(len(numbers))]
    m = ['hello'+str(numbers[i]) for i in range(len(numbers))]

numbers = [random.randint(1,100) for i in range(1000)]
lp = LineProfiler()
lp_wrapper = lp(do_stuff)
lp_wrapper(numbers)
lp.print_stats()

Kết quả sẽ là:

Timer unit: 1e-06 s

Total time: 0.000649 s
File: <ipython-input-2-2e060b054fea>
Function: do_stuff at line 4

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
     4                                           def do_stuff(numbers):
     5         1           10     10.0      1.5      s = sum(numbers)
     6         1          186    186.0     28.7      l = [numbers[i]/43 for i in range(len(numbers))]
     7         1          453    453.0     69.8      m = ['hello'+str(numbers[i]) for i in range(len(numbers))]

Tôi đã sử dụng một hàm rất đơn giản để xác định thời gian thực hiện một phần của mã:

import time
def timing():
    start_time = time.time()
    return lambda x: print("[{:.2f}s] {}".format(time.time() - start_time, x))

Và để sử dụng nó, chỉ cần gọi nó trước mã để đo để lấy thời gian của hàm, và sau đó gọi hàm sau mã với các bình luận. Thời gian sẽ xuất hiện trước các ý kiến. Ví dụ:

t = timing()
train = pd.read_csv('train.csv',
                        dtype={
                            'id': str,
                            'vendor_id': str,
                            'pickup_datetime': str,
                            'dropoff_datetime': str,
                            'passenger_count': int,
                            'pickup_longitude': np.float64,
                            'pickup_latitude': np.float64,
                            'dropoff_longitude': np.float64,
                            'dropoff_latitude': np.float64,
                            'store_and_fwd_flag': str,
                            'trip_duration': int,
                        },
                        parse_dates = ['pickup_datetime', 'dropoff_datetime'],
                   )
t("Loaded {} rows data from 'train'".format(len(train)))

Sau đó, đầu ra sẽ như thế này:

[9.35s] Loaded 1458644 rows data from 'train'

Tôi đã gặp vấn đề tương tự ở nhiều nơi, vì vậy tôi đã tạo ra một gói tiện lợi horology. Bạn có thể cài đặt nó pip install horologyvà sau đó thực hiện theo cách thanh lịch:

from horology import Timing

with Timing(name='Important calculations: '):
    prepare()
    do_your_stuff()
    finish_sth()

sẽ xuất ra:

Important calculations: 12.43 ms

Hoặc thậm chí đơn giản hơn (nếu bạn có một chức năng):

from horology import timed

@timed
def main():
    ...

sẽ xuất ra:

main: 7.12 h

Nó chăm sóc các đơn vị và làm tròn. Nó hoạt động với python 3.6 hoặc mới hơn.

Đây là câu trả lời của Paul McGuire phù hợp với tôi. Chỉ trong trường hợp ai đó gặp khó khăn khi chạy cái đó.

import atexit
from time import clock

def reduce(function, iterable, initializer=None):
    it = iter(iterable)
    if initializer is None:
        value = next(it)
    else:
        value = initializer
    for element in it:
        value = function(value, element)
    return value

def secondsToStr(t):
    return "%d:%02d:%02d.%03d" % \
        reduce(lambda ll,b : divmod(ll[0],b) + ll[1:],
            [(t*1000,),1000,60,60])

line = "="*40
def log(s, elapsed=None):
    print (line)
    print (secondsToStr(clock()), '-', s)
    if elapsed:
        print ("Elapsed time:", elapsed)
    print (line)

def endlog():
    end = clock()
    elapsed = end-start
    log("End Program", secondsToStr(elapsed))

def now():
    return secondsToStr(clock())

def main():
    start = clock()
    atexit.register(endlog)
    log("Start Program")

Gọi timing.main()từ chương trình của bạn sau khi nhập tệp.

Timeit là một lớp trong Python được sử dụng để tính thời gian thực hiện của các khối mã nhỏ.

Default_timer là một phương thức trong lớp này được sử dụng để đo thời gian của đồng hồ treo tường, không phải thời gian thực hiện CPU. Do đó, quá trình thực thi khác có thể can thiệp vào điều này. Do đó, nó rất hữu ích cho các khối mã nhỏ.

Một mẫu của mã như sau:

from timeit import default_timer as timer

start= timer()

# Some logic

end = timer()

print("Time taken:", end-start)

Trả lời sau, nhưng tôi sử dụng timeit:

import timeit
code_to_test = """
a = range(100000)
b = []
for i in a:
    b.append(i*2)
"""
elapsed_time = timeit.timeit(code_to_test, number=500)
print(elapsed_time)
# 10.159821493085474

• Gói tất cả mã của bạn, bao gồm mọi nhập khẩu bạn có thể có, bên trong code_to_test.
• number đối số chỉ định số lần mã sẽ lặp lại.
• Bản giới thiệu

Thời gian thực hiện biện pháp thực thi của chương trình Python có thể không nhất quán tùy thuộc vào:

• Cùng một chương trình có thể được đánh giá bằng các thuật toán khác nhau
• Thời gian chạy khác nhau giữa các thuật toán
• Thời gian chạy khác nhau giữa các lần thực hiện
• Thời gian chạy khác nhau giữa các máy tính
• Thời gian chạy không thể dự đoán được dựa trên đầu vào nhỏ

Điều này là do cách hiệu quả nhất là sử dụng "Thứ tự tăng trưởng" và tìm hiểu ký hiệu "O" lớn để thực hiện đúng.

Dù sao, bạn có thể thử đánh giá hiệu suất của bất kỳ chương trình Python nào trong các bước đếm máy cụ thể mỗi giây bằng thuật toán đơn giản này: điều chỉnh nó theo chương trình bạn muốn đánh giá

import time

now = time.time()
future = now + 10
step = 4 # Why 4 steps? Because until here already four operations executed
while time.time() < future:
    step += 3 # Why 3 again? Because a while loop executes one comparison and one plus equal statement
step += 4 # Why 3 more? Because one comparison starting while when time is over plus the final assignment of step + 1 and print statement
print(str(int(step / 10)) + " steps per second")

Bạn làm điều này đơn giản bằng Python. Không cần phải làm cho nó phức tạp.

import time

start = time.localtime()
end = time.localtime()
"""Total execution time in seconds$ """
print(end.tm_sec - start.tm_sec)

Tương tự như phản hồi từ @rogeriopvl, tôi đã thêm một sửa đổi nhỏ để chuyển đổi thành giây phút giây sử dụng cùng một thư viện cho các công việc chạy dài.

import time
start_time = time.time()
main()
seconds = time.time() - start_time
print('Time Taken:', time.strftime("%H:%M:%S",time.gmtime(seconds)))

Đầu ra mẫu

Time Taken: 00:00:08

Đầu tiên, cài đặt humanfriendly gói bằng cách mở Command Prompt (CMD) as administrator và gõ ở đó - pip install humanfriendly

Mã số:

from humanfriendly import format_timespan
import time
begin_time = time.time()
# Put your code here
end_time = time.time() - begin_time
print("Total execution time: ", format_timespan(end_time))

Đầu ra:

Để sử dụng câu trả lời được cập nhật của metakermit cho Python 2.7, bạn sẽ cần gói đơn điệu .

Mã sau đó sẽ như sau:

from datetime import timedelta
from monotonic import monotonic

start_time = monotonic()
end_time = monotonic()
print(timedelta(seconds=end_time - start_time))

Tôi đã thử và tìm thấy sự khác biệt thời gian bằng cách sử dụng các kịch bản sau đây.

import time

start_time = time.perf_counter()
[main code here]
print (time.perf_counter() - start_time, "seconds")

Nếu bạn muốn đo thời gian tính bằng micrô giây, thì bạn có thể sử dụng phiên bản sau, hoàn toàn dựa trên câu trả lời của Paul McGuire và Nicojo - đó là mã Python 3. Tôi cũng đã thêm một số màu cho nó:

import atexit
from time import time
from datetime import timedelta, datetime


def seconds_to_str(elapsed=None):
    if elapsed is None:
        return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
    else:
        return str(timedelta(seconds=elapsed))


def log(txt, elapsed=None):
    colour_cyan = '\033[36m'
    colour_reset = '\033[0;0;39m'
    colour_red = '\033[31m'
    print('\n ' + colour_cyan + '  [TIMING]> [' + seconds_to_str() + '] ----> ' + txt + '\n' + colour_reset)
    if elapsed:
        print("\n " + colour_red + " [TIMING]> Elapsed time ==> " + elapsed + "\n" + colour_reset)


def end_log():
    end = time()
    elapsed = end-start
    log("End Program", seconds_to_str(elapsed))


start = time()
atexit.register(end_log)
log("Start Program")

log () => chức năng in ra thông tin thời gian.

txt ==> đối số đầu tiên để đăng nhập và chuỗi của nó để đánh dấu thời gian.

atexit ==> Mô-đun Python để đăng ký các chức năng mà bạn có thể gọi khi chương trình thoát.