ฉันจะได้รับเวลาในการดำเนินการของโปรแกรม Python ได้อย่างไร

ฉันมีโปรแกรมบรรทัดคำสั่งใน Python ที่ใช้เวลาสักครู่จึงจะเสร็จ ฉันต้องการทราบเวลาที่แน่นอนในการวิ่งให้เสร็จ

ฉันดูtimeitโมดูลแล้ว แต่ดูเหมือนว่าจะเป็นเพียงโค้ดขนาดเล็กเท่านั้น ฉันต้องการเวลาโปรแกรมทั้งหมด

วิธีที่ง่ายที่สุดใน Python:

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

นี่ถือว่าโปรแกรมของคุณใช้เวลาอย่างน้อยหนึ่งในสิบในการรัน

พิมพ์:

--- 0.764891862869 seconds ---

ฉันใส่timing.pyโมดูลนี้ในsite-packagesไดเรกทอรีของฉันและใส่import timingที่ด้านบนของโมดูลของฉัน:

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

ฉันยังสามารถโทรtiming.logจากภายในโปรแกรมของฉันหากมีขั้นตอนที่สำคัญภายในโปรแกรมที่ฉันต้องการแสดง แต่เพียงรวมถึงimport timingจะพิมพ์เวลาเริ่มต้นและสิ้นสุดและเวลาที่ผ่านไปโดยรวม (ให้อภัยsecondsToStrฟังก์ชั่นคลุมเครือของฉันมันเพียงแค่จัดรูปแบบจำนวนจุดลอยตัวของวินาทีเพื่อ hh: mm: ss.sss แบบฟอร์ม.)

หมายเหตุ: งูหลาม 3 รุ่นของรหัสดังกล่าวสามารถพบได้ที่นี่หรือที่นี่

ใน Linux หรือ Unix:

$ time python yourprogram.py

ใน Windows ดูคำถาม StackOverflow: ฉันจะวัดเวลาดำเนินการของคำสั่งในบรรทัดคำสั่ง Windows ได้อย่างไร

สำหรับเอาต์พุต verbose เพิ่มเติม

$ 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

ฉันชอบคำตอบของ Paul McGuireแต่ฉันใช้ Python 3 ดังนั้นสำหรับผู้ที่สนใจ: นี่คือการแก้ไขคำตอบของเขาที่ทำงานกับ Python 3 บน * nix (ฉันจินตนาการว่าภายใต้ Windows clock()ควรใช้แทน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")

หากคุณพบว่าสิ่งนี้มีประโยชน์คุณยังควรโหวตคำตอบของเขาแทนคำตอบนี้

import time

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

time.clock()ส่งคืนเวลาตัวประมวลผลซึ่งทำให้เราสามารถคำนวณเวลาที่ใช้โดยกระบวนการนี้เท่านั้น (ในระบบปฏิบัติการยูนิกซ์) เอกสารอธิบายว่า "ไม่ว่าในกรณีใด ๆ นี่เป็นฟังก์ชั่นที่ใช้สำหรับการเปรียบเทียบ Python หรืออัลกอริธึมกำหนดเวลา"

ฉันชอบผลลัพธ์ datetimeโมดูลจัดให้ซึ่งวัตถุเวลาเดลต้าแสดงวันชั่วโมงนาที ฯลฯ ตามความจำเป็นในแบบที่มนุษย์อ่านได้

ตัวอย่างเช่น:

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

ตัวอย่างผลลัพธ์

Duration: 0:00:08.309267

หรือ

Duration: 1 day, 1:51:24.269711

ดังที่เจเซบาสเตียนพูดถึงวิธีการนี้อาจประสบกับกรณีที่ยุ่งยากในเวลาท้องถิ่นดังนั้นจึงปลอดภัยกว่าที่จะใช้:

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

คุณสามารถใช้ Python profiler cProfile เพื่อวัดเวลา CPUและเพิ่มเวลาที่ใช้ในแต่ละฟังก์ชั่นและเพิ่มจำนวนครั้งที่เรียกใช้แต่ละฟังก์ชัน สิ่งนี้มีประโยชน์มากหากคุณต้องการปรับปรุงประสิทธิภาพของสคริปต์โดยไม่ต้องรู้ว่าจะเริ่มจากตรงไหน คำตอบของคำถาม Stack Overflow นี้ค่อนข้างดี เป็นเรื่องที่ดีเสมอที่ได้ดูในเอกสารประกอบเช่นกัน

นี่คือตัวอย่างวิธีการโปรไฟล์สคริปต์โดยใช้ cProfile จากบรรทัดคำสั่ง:

$ 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}

ดียิ่งขึ้นสำหรับ 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

time.clock ()

เลิกใช้แล้วตั้งแต่เวอร์ชั่น 3.3: พฤติกรรมของฟังก์ชั่นนี้ขึ้นอยู่กับแพลตฟอร์ม: ใช้perf_counter ()หรือprocess_time ()แทนขึ้นอยู่กับความต้องการของคุณเพื่อให้มีพฤติกรรมที่ชัดเจน

time.perf_counter ()

ส่งคืนค่า (ในเสี้ยววินาที) ของตัวนับประสิทธิภาพเช่นนาฬิกาที่มีความละเอียดสูงสุดที่มีอยู่เพื่อวัดระยะเวลาสั้น ๆ มันไม่รวมถึงเวลาที่ผ่านไปในระหว่างการนอนหลับและเป็นทั้งระบบ

time.process_time ()

ส่งคืนค่า (เป็นเสี้ยววินาที) ของผลรวมของระบบและเวลา CPU ผู้ใช้ของกระบวนการปัจจุบัน มันไม่ได้รวมถึงเวลาที่ผ่านไประหว่างการนอนหลับ

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

เพียงแค่ใช้timeitโมดูล ใช้งานได้กับทั้ง Python 2 และ 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

มันกลับมาในไม่กี่วินาทีและคุณสามารถมีเวลาดำเนินการของคุณ มันง่าย แต่คุณควรเขียนสิ่งเหล่านี้ในฟังก์ชั่นหลักของ w ซึ่งเริ่มการทำงานของโปรแกรม หากคุณต้องการรับเวลาดำเนินการแม้ว่าคุณจะได้รับข้อผิดพลาดให้นำพารามิเตอร์ของคุณ "เริ่มต้น" ไปที่มันและคำนวณที่นั่นเช่น:

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

ตัวอย่างต่อไปนี้พิมพ์เวลาที่ผ่านไปใน<HH:MM:SS>รูปแบบที่มนุษย์อ่านได้ดี

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)

ในIPythonให้ "timeit" สคริปต์ใด ๆ :

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

ฉันดูโมดูล timeit แล้ว แต่ดูเหมือนว่าเป็นเพียงโค้ดขนาดเล็กเท่านั้น ฉันต้องการเวลาโปรแกรมทั้งหมด

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

มันทำงานyour_module.main()ฟังก์ชั่นครั้งเดียวและพิมพ์เวลาที่ผ่านไปโดยใช้time.time()ฟังก์ชั่นเป็นตัวจับเวลา

หากต้องการจำลอง/usr/bin/timeใน Python ดูกระบวนการย่อยของ Python ด้วย / usr / bin / time: วิธีจับข้อมูลเวลา แต่ไม่สนใจเอาต์พุตอื่น ๆ ทั้งหมดหรือไม่ .

ในการวัดเวลา CPU (เช่นไม่รวมเวลาระหว่างtime.sleep()) สำหรับแต่ละฟังก์ชันคุณสามารถใช้profileโมดูล ( cProfileบน Python 2):

$ python3 -mprofile your_module.py

คุณสามารถส่ง-pไปยังtimeitคำสั่งด้านบนหากคุณต้องการใช้ตัวจับเวลาเดียวกันกับที่profileโมดูลใช้

ดูวิธีสร้างโปรไฟล์สคริปต์ Python ได้อย่างไร

ฉันชอบคำตอบของ Paul McGuireด้วยเช่นกันและได้รับแบบฟอร์มตัวจัดการบริบทที่เหมาะสมกับความต้องการของฉันมากขึ้น

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

สำหรับกลุ่มข้อมูลที่ใช้Jupyter Notebook

ในเซลล์คุณสามารถใช้%%timeคำสั่งเวทของ Jupyter เพื่อวัดเวลาดำเนินการ:

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

เอาท์พุต

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

การดำเนินการนี้จะจับเวลาดำเนินการของเซลล์เฉพาะเท่านั้น หากคุณต้องการบันทึกเวลาดำเนินการของสมุดบันทึกทั้งหมด (เช่นโปรแกรม) คุณสามารถสร้างสมุดบันทึกใหม่ในไดเรกทอรีเดียวกันและในสมุดบันทึกใหม่ดำเนินการทุกเซลล์:

example_notebook.ipynbสมมติว่าโน๊ตบุ๊คดังกล่าวข้างต้นจะเรียกว่า ในสมุดบันทึกใหม่ภายในไดเรกทอรีเดียวกัน:

# 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

เอาท์พุต

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

มี timeitโมดูลที่สามารถใช้เวลาในการประมวลผลของรหัสหลาม

มันมีเอกสารรายละเอียดและตัวอย่างในเอกสาร Python, 26.6 เวลาดำเนินการวัดตัวอย่างโค้ดขนาดเล็ก - timeit

ใช้line_profiler

line_profiler จะทำโปรไฟล์เวลาที่รหัสแต่ละบรรทัดใช้ในการดำเนินการ ตัวสร้างโปรไฟล์ถูกใช้งานใน C ผ่านทางCythonเพื่อลดค่าใช้จ่ายในการทำโปรไฟล์

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

ผลลัพธ์จะเป็น:

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

ฉันใช้ฟังก์ชั่นที่เรียบง่ายเป็นส่วนหนึ่งของการเรียกใช้โค้ด:

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

และการใช้งานก็เพียงแค่เรียกมันก่อนรหัสเพื่อวัดเพื่อเรียกฟังก์ชั่นจับเวลาแล้วเรียกใช้ฟังก์ชั่นหลังจากรหัสที่มีความคิดเห็น เวลาจะปรากฏขึ้นต่อหน้าความคิดเห็น ตัวอย่างเช่น:

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

จากนั้นเอาต์พุตจะมีลักษณะดังนี้:

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

horologyผมมีปัญหาเดียวกันในหลายสถานที่ดังนั้นฉันสร้างแพคเกจความสะดวกสบาย คุณสามารถติดตั้งด้วยpip install horologyแล้วทำมันอย่างสง่างาม:

from horology import Timing

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

จะส่งออก:

Important calculations: 12.43 ms

หรือง่ายกว่า (หากคุณมีฟังก์ชั่นเดียว):

from horology import timed

@timed
def main():
    ...

จะส่งออก:

main: 7.12 h

ดูแลหน่วยและปัดเศษ ใช้งานได้กับ python 3.6 หรือใหม่กว่า

นี่คือคำตอบของ Paul McGuireที่เหมาะกับฉัน ในกรณีที่มีใครบางคนกำลังประสบปัญหาในการทำงานอันนั้น

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

โทรtiming.main()จากโปรแกรมของคุณหลังจากนำเข้าไฟล์

Timeit เป็นคลาสใน Python ที่ใช้ในการคำนวณเวลาดำเนินการของโค้ดขนาดเล็ก

Default_timer เป็นวิธีการในคลาสนี้ซึ่งใช้ในการวัดระยะเวลาของนาฬิกาแขวนไม่ใช่เวลาดำเนินการ CPU ดังนั้นการดำเนินการกระบวนการอื่นอาจรบกวนสิ่งนี้ ดังนั้นจึงมีประโยชน์สำหรับบล็อกเล็ก ๆ ของรหัส

ตัวอย่างของรหัสมีดังนี้:

from timeit import default_timer as timer

start= timer()

# Some logic

end = timer()

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

ตอบภายหลัง แต่ฉันใช้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

• ห่อรหัสของคุณทั้งหมดรวมทั้งการนำเข้าใด ๆ code_to_testที่คุณอาจจะมีภายใน
• number อาร์กิวเมนต์ระบุจำนวนครั้งที่รหัสควรทำซ้ำ
• การสาธิต

เวลาของการวัดการดำเนินการของโปรแกรม Python อาจไม่สอดคล้องกันขึ้นอยู่กับ:

• สามารถประเมินโปรแกรมเดียวกันโดยใช้อัลกอริทึมที่แตกต่างกัน
• เวลาทำงานแตกต่างกันระหว่างอัลกอริทึม
• เวลาทำงานแตกต่างกันไประหว่างการใช้งาน
• เวลาทำงานแตกต่างกันระหว่างคอมพิวเตอร์
• เวลาในการทำงานไม่สามารถคาดการณ์ได้จากปัจจัยการผลิตขนาดเล็ก

นี่เป็นเพราะวิธีที่มีประสิทธิภาพมากที่สุดคือการใช้ "ลำดับการเติบโต" และเรียนรู้สัญลักษณ์"O" ที่ยิ่งใหญ่เพื่อทำอย่างถูกต้อง

อย่างไรก็ตามคุณสามารถลองประเมินประสิทธิภาพของโปรแกรม Python ใด ๆ ในขั้นตอนการนับเครื่องต่อวินาทีโดยใช้อัลกอริธึมแบบง่าย ๆ นี้: ปรับใช้สิ่งนี้กับโปรแกรมที่คุณต้องการประเมิน

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

คุณทำสิ่งนี้ได้ง่ายๆใน Python ไม่จำเป็นต้องทำให้ซับซ้อน

import time

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

คล้ายกับการตอบสนองจาก @rogeriopvl ฉันได้เพิ่มการดัดแปลงเล็กน้อยเพื่อแปลงเป็นชั่วโมงนาทีวินาทีโดยใช้ไลบรารีเดียวกันสำหรับงานที่รันนาน

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

ตัวอย่างผลลัพธ์

Time Taken: 00:00:08

ขั้นแรกให้ติดตั้งแพคเกจอย่างเป็นมิตรโดยเปิด Command Prompt (CMD) ในฐานะผู้ดูแลระบบและพิมพ์ที่นั่น - pip install humanfriendly

รหัส:

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

เอาท์พุท:

ในการใช้คำตอบที่ปรับปรุงล่าสุดของ metakermitสำหรับ Python 2.7 คุณจะต้องใช้แพ็คเกจmonotonic

รหัสจะเป็นดังนี้:

from datetime import timedelta
from monotonic import monotonic

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

ฉันลองและพบความแตกต่างของเวลาโดยใช้สคริปต์ต่อไปนี้

import time

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

หากคุณต้องการวัดเวลาเป็นไมโครวินาทีคุณสามารถใช้เวอร์ชันต่อไปนี้โดยยึดตามคำตอบของPaul McGuireและNicojo - เป็นรหัส Python 3 ฉันได้เพิ่มสีเข้าไปด้วย:

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 () => ฟังก์ชันที่พิมพ์ข้อมูลเวลา

txt ==> อาร์กิวเมนต์แรกที่เข้าสู่ระบบและสตริงเพื่อทำเครื่องหมายกำหนดเวลา

atexit ==> โมดูล Python เพื่อลงทะเบียนฟังก์ชั่นที่คุณสามารถเรียกใช้เมื่อโปรแกรมออก