මට අවශ්‍ය වන්නේ මගේ කේතයේ කොතැනක හෝ කාලය ගණනය කිරීම ආරම්භ කර පසුව ගත වූ කාලය ලබා ගැනීමයි, එය ශ්‍රිත කිහිපයක් ක්‍රියාත්මක කිරීමට ගතවන කාලය මැනීමයි. මම හිතන්නේ මම කාලරාමු මොඩියුලය වැරදියි, නමුත් ලියකියවිලි මට ව්‍යාකූලයි.

import timeit

start = timeit.timeit()
print("hello")
end = timeit.timeit()
print(end - start)

ඔබට ලකුණු දෙකක් අතර ගත වූ බිත්ති ඔරලෝසු කාලය මැනීමට අවශ්‍ය නම්, ඔබට මෙය භාවිතා කළ හැකිය time.time():

import time

start = time.time()
print("hello")
end = time.time()
print(end - start)

මෙය තත්පර කිහිපයකින් ක්‍රියාත්මක කිරීමේ කාලය ලබා දෙයි.

3.3 සිට තවත් විකල්පය භාවිතා කිරීමට විය හැකි perf_counterහෝ process_timeඔබගේ අවශ්යතා මත පදනම්ව,. 3.3 ට පෙර එය භාවිතා කිරීම රෙකමදාරු කරන ලදී time.clock(ස්තූතියි ඇම්බර් ). කෙසේ වෙතත්, එය දැනට අතහැර දමා ඇත:

යුනික්ස් හි, තත්පර කිහිපයකින් ප්‍රකාශිත පාවෙන ලක්ෂ්‍ය අංකයක් ලෙස වත්මන් ප්‍රොසෙසරයේ වේලාව ආපසු එවන්න. නිරවද්‍යතාවය සහ ඇත්ත වශයෙන්ම “ප්‍රොසෙසර් වේලාව” යන්නෙහි අර්ථය රඳා පවතින්නේ එකම නමින් සී ශ්‍රිතය මත ය.

වින්ඩෝස් හි, මෙම ශ්‍රිතය වින් 32 ශ්‍රිතය මත පදනම්ව පාවෙන ලක්ෂ්‍ය අංකයක් ලෙස මෙම ශ්‍රිතයට පළමු ඇමතුමෙන් පසු බිත්ති-ඔරලෝසු තත්පර ලබා දෙයි QueryPerformanceCounter(). විභේදනය සාමාන්‍යයෙන් එක් මයික්‍රෝ තත්පරයකට වඩා හොඳය.

3.3 අනුවාදයෙන් ඉවත් කර ඇත : මෙම ශ්‍රිතයේ හැසිරීම වේදිකාව මත රඳා පවතී: හොඳින් නිර්වචනය කළ හැසිරීමක් සඳහා ඔබේ අවශ්‍යතා අනුව භාවිතා කරන්න perf_counter()හෝ process_time()ඒ වෙනුවට භාවිතා කරන්න.

timeit.default_timerවෙනුවට භාවිතා කරන්න timeit.timeit. කලින් ඔබේ වේදිකාවේ සහ පයිතන් අනුවාදයේ ඇති හොඳම ඔරලෝසුව ස්වයංක්‍රීයව සපයයි:

from timeit import default_timer as timer

start = timer()
# ...
end = timer()
print(end - start) # Time in seconds, e.g. 5.38091952400282

timeit.default_timer මෙහෙයුම් පද්ධතිය මත පදනම්ව (time.time අනුයුක්ත කර ඇත) හෝ time.clock (). Python 3.3+ default_timer යනු සියලුම වේදිකා වල time.perf_counter () වේ. ශුද්ධාසනයේ Python - time.clock () එදිරිව time.time () - නිරවද්යතාව?

මෙයද බලන්න:

• කේතය ප්‍රශස්ත කිරීම
• වේගය සඳහා ප්‍රශස්තිකරණය කරන්නේ කෙසේද

පයිතන් 3 පමණි:

Time.clock () පයිතන් 3.3 වන විට ඉවත් කර ඇති හෙයින් , ඔබ භාවිතා කළ ආකාරයටමtime.perf_counter() පද්ධතිය පුරා කාල වේලාව time.process_time()සඳහා හෝ ක්‍රියාවලි-කාල වේලාවන් සඳහා භාවිතා කිරීමට ඔබට අවශ්‍ය වනු ඇත time.clock():

import time

t = time.process_time()
#do some stuff
elapsed_time = time.process_time() - t

නව ශ්‍රිතයට process_timeනින්දේ ගතවන කාලය ඇතුළත් නොවේ.

ඔබ කාලයට කැමති ශ්‍රිතයක් ලබා දී,

test.py:

def foo(): 
    # print "hello"   
    return "hello"

භාවිතා කිරීමට ඇති පහසුම ක්‍රමය timeitඑය විධාන රේඛාවෙන් ඇමතීමයි:

% python -mtimeit -s'import test' 'test.foo()'
1000000 loops, best of 3: 0.254 usec per loop

භාවිතා කිරීමට උත්සාහ කරන්න එපා time.timeහෝ time.clockකාර්යයන් වේගය සංසන්දනය කිරීමට (උදාවෙති යි). ඔවුන්ට නොමඟ යවන ප්‍රති .ල ලබා දිය හැකිය .

පීඑස්. ඔබ වේලාවට කැමති ශ්‍රිතයක මුද්‍රණ ප්‍රකාශ නොකරන්න; එසේ නොමැතිනම් මනින කාලය පර්යන්තයේ වේගය මත රඳා පවතී .

සන්දර්භය-කළමණාකරුවෙකු සමඟ මෙය කිරීම විනෝදජනක වන අතර එය වාරණයකට ඇතුල් වූ පසු ආරම්භක වේලාව ස්වයංක්‍රීයව සිහිපත් කරයි with, පසුව වාරණයෙන් පිටවීමේ අවසන් කාලය කැටි කරයි. කුඩා උපක්‍රමයකින්, ඔබට එකම සන්දර්භය-කළමණාකරණ ශ්‍රිතයෙන් වාරණය තුළ ධාවන කාල සීමාව ලබා ගත හැකිය.

මූලික පුස්තකාලයට මෙය නොමැත (නමුත් බොහෝ විට එසේ විය යුතුය). ක්‍රියාත්මක වූ පසු, ඔබට මෙවැනි දේ කළ හැකිය:

with elapsed_timer() as elapsed:
    # some lengthy code
    print( "midpoint at %.2f seconds" % elapsed() )  # time so far
    # other lengthy code

print( "all done at %.2f seconds" % elapsed() )

උපක්‍රමය කිරීමට ප්‍රමාණවත් සන්දර්භ කේත කළමනාකරු කේතය මෙන්න :

from contextlib import contextmanager
from timeit import default_timer

@contextmanager
def elapsed_timer():
    start = default_timer()
    elapser = lambda: default_timer() - start
    yield lambda: elapser()
    end = default_timer()
    elapser = lambda: end-start

සහ ක්‍රියාත්මක කළ හැකි ආදර්ශන කේත කිහිපයක්:

import time

with elapsed_timer() as elapsed:
    time.sleep(1)
    print(elapsed())
    time.sleep(2)
    print(elapsed())
    time.sleep(3)

මෙම ශ්‍රිතය සැලසුම් කිරීමෙන්, ආපසු පැමිණීමේ අගය elapsed()බ්ලොක් පිටවීමේදී ශීත කළ අතර, තවත් ඇමතුම් එම කාල සීමාවම ලබා දෙයි (මෙම සෙල්ලම් උදාහරණයේ තත්පර 6 ක් පමණ).

තත්පර කිහිපයකින් කාලය මැනීම :

from timeit import default_timer as timer
from datetime import timedelta

start = timer()
end = timer()
print(timedelta(seconds=end-start))

ප්‍රතිදානය :

0:00:01.946339

මම මේකට කැමතියි. timeitලේඛනය බොහෝ ව්‍යාකූල ය.

from datetime import datetime 

start_time = datetime.now() 

# INSERT YOUR CODE 

time_elapsed = datetime.now() - start_time 

print('Time elapsed (hh:mm:ss.ms) {}'.format(time_elapsed))

සටහන, මෙහි කිසිදු හැඩතල ගැන්වීමක් සිදු නොවන බව, මම මුද්‍රණාලයට ලියා hh:mm:ssඇති බැවින් කෙනෙකුට අර්ථ නිරූපණය කළ හැකියtime_elapsed

මෙය කිරීමට තවත් ක්‍රමයක් මෙන්න:

>> from pytictoc import TicToc
>> t = TicToc() # create TicToc instance
>> t.tic() # Start timer
>> # do something
>> t.toc() # Print elapsed time
Elapsed time is 2.612231 seconds.

සාම්ප්‍රදායික ක්‍රමයට සාපේක්ෂව:

>> from time import time
>> t1 = time()
>> # do something
>> t2 = time()
>> elapsed = t2 - t1
>> print('Elapsed time is %f seconds.' % elapsed)
Elapsed time is 2.612231 seconds.

ස්ථාපනය:

pip install pytictoc

වෙත යොමු වන්න PyPi පිටුව බලන්න.

මෙන්න බොහෝ හොඳ පිළිතුරු මෙන්ම තවත් ලිපි කිහිපයක් බැලීමෙන් පසු මගේ සොයා ගැනීම්.

පළමුව, ඔබ timeitසහ අතර විවාද කරන්නේ නම් time.time, එහි timeitවාසි දෙකක් ඇත:

1. timeit ඔබගේ මෙහෙයුම් පද්ධතිය සහ පයිතන් අනුවාදයේ ඇති හොඳම ටයිමරය තෝරා ගනී.
2. timeit කසළ එකතු කිරීම අක්‍රීය කරයි, කෙසේ වෙතත්, මෙය ඔබට අවශ්‍ය හෝ අවශ්‍ය නොවන දෙයක් නොවේ.

දැන් ගැටළුව එය timeitභාවිතා කිරීම එතරම් සරල නොවන නිසා එයට සැකසීම් අවශ්‍ය වන අතර ඔබට ආනයන පොකුරක් ඇති විට දේවල් කැත වේ. ඉතා මැනවින්, ඔබට අවශ්‍ය වන්නේ සැරසිලි කරුවෙකු හෝ withබ්ලොක් භාවිතා කර කාලය මැනීමයි. අවාසනාවට, මේ සඳහා කිසිවක් ගොඩනගා නැති නිසා ඔබට විකල්ප දෙකක් තිබේ:

විකල්ප 1: කාල බජට් පුස්තකාලය භාවිතා කරන්න

මෙම timebudget ඔබ ස්ථාපනය එක පිප්ස් එකකට පසු පමණක් කේතය එක් රේඛාව භාවිතා කළ හැකි බහුකාර්ය හා ඉතා සරල පුස්තකාලයකි.

@timebudget  # Record how long this function takes
def my_method():
    # my code

විකල්ප 2: කේත මොඩියුලය කෙලින්ම භාවිතා කරන්න

මම පහළින් කුඩා උපයෝගිතා මොඩියුලයක් නිර්මාණය කළෙමි.

# utils.py
from functools import wraps
import gc
import timeit

def MeasureTime(f, no_print=False, disable_gc=False):
    @wraps(f)
    def _wrapper(*args, **kwargs):
        gcold = gc.isenabled()
        if disable_gc:
            gc.disable()
        start_time = timeit.default_timer()
        try:
            result = f(*args, **kwargs)
        finally:
            elapsed = timeit.default_timer() - start_time
            if disable_gc and gcold:
                gc.enable()
            if not no_print:
                print('"{}": {}s'.format(f.__name__, elapsed))
        return result
    return _wrapper

class MeasureBlockTime:
    def __init__(self,name="(block)", no_print=False, disable_gc=False):
        self.name = name
        self.no_print = no_print
        self.disable_gc = disable_gc
    def __enter__(self):
        self.gcold = gc.isenabled()
        if self.disable_gc:
            gc.disable()
        self.start_time = timeit.default_timer()
    def __exit__(self,ty,val,tb):
        self.elapsed = timeit.default_timer() - self.start_time
        if self.disable_gc and self.gcold:
            gc.enable()
        if not self.no_print:
            print('Function "{}": {}s'.format(self.name, self.elapsed))
        return False #re-raise any exceptions

දැන් ඔබට ඕනෑම කාර්යයක් සැරසිලි කරුවෙකු ඉදිරිපිට තැබීමෙන් කාලය ගත කළ හැකිය:

import utils

@utils.MeasureTime
def MyBigFunc():
    #do something time consuming
    for i in range(10000):
        print(i)

ඔබට කේතයෙන් කොටසක් වෙන් කිරීමට අවශ්‍ය නම් එය withබ්ලොක් තුළ තබන්න :

import utils

#somewhere in my code

with utils.MeasureBlockTime("MyBlock"):
    #do something time consuming
    for i in range(10000):
        print(i)

# rest of my code

වාසි:

අර්ධ පිටුබලය සහිත අනුවාද කිහිපයක් වටා පාවෙමින් තිබේ, එබැවින් මට විශේෂ අවස්ථා කිහිපයක් පෙන්වා දීමට අවශ්‍යය:

1. කලින් විස්තර කර ඇති හේතු සඳහා time.time වෙනුවට timeit වෙතින් ටයිමරය භාවිතා කරන්න.
2. ඔබට අවශ්‍ය නම් වේලාව තුළ GC අක්‍රීය කළ හැකිය.
3. සැරසිලි කරන්නා නම් කරන ලද හෝ නම් නොකළ පරාමිතීන් සමඟ කාර්යයන් භාර ගනී.
4. වාරණ කාලවලදී මුද්‍රණය අක්‍රීය කිරීමේ හැකියාව (භාවිතා with utils.MeasureBlockTime() as tකර පසුව භාවිතා කරන්නt.elapsed ).
5. වාරණ කාලය සඳහා gc සක්‍රීයව තබා ගැනීමේ හැකියාව.

time.timeක්‍රියාත්මක කිරීම මැනීම සඳහා භාවිතා කිරීම මඟින් ඔබේ පරිගණකයේ වෙනත් ක්‍රියාවලීන් විසින් ගත කරන කාලය ඇතුළුව ඔබේ විධානවල සමස්ත ක්‍රියාත්මක කිරීමේ කාලය ලබා දේ. එය පරිශීලකයා දකින කාලයයි, නමුත් ඔබට විවිධ කේත ස්නිපෙට් / ඇල්ගොරිතම / කාර්යයන් / සංසන්දනය කිරීමට අවශ්‍ය නම් එය හොඳ නැත.

වැඩි විස්තර timeit:

• ටයිමිට් මොඩියුලය භාවිතා කිරීම
• timeit - පයිතන් කේතයේ කුඩා බිටු ක්‍රියාත්මක කරන වේලාව

පැතිකඩ පිළිබඳ ගැඹුරු අවබෝධයක් ඔබට අවශ්‍ය නම්:

• http://wiki.python.org/moin/PythonSpeed/PerformanceTips#Profiling_Code
• ඔබට පයිතන් පිටපතක් පැතිකඩ කළ හැක්කේ කෙසේද?

යාවත්කාලීන කිරීම : මම පසුගිය වසර තුළ http://pythonhosted.org/line_profiler/ භාවිතා කළ අතර එය ඉතා ප්‍රයෝජනවත් බව සොයාගෙන පයිතන්ස් පැතිකඩ මොඩියුලය වෙනුවට එය භාවිතා කිරීමට නිර්දේශ කරමි.

මෙන්න "hh: mm: ss" string ලබා දෙන ඉතා කුඩා ටයිමර් පන්තියක්:

class Timer:
  def __init__(self):
    self.start = time.time()

  def restart(self):
    self.start = time.time()

  def get_time_hhmmss(self):
    end = time.time()
    m, s = divmod(end - self.start, 60)
    h, m = divmod(m, 60)
    time_str = "%02d:%02d:%02d" % (h, m, s)
    return time_str

භාවිතය:

# Start timer
my_timer = Timer()

# ... do something

# Get time string:
time_hhmmss = my_timer.get_time_hhmmss()
print("Time elapsed: %s" % time_hhmmss )

# ... use the timer again
my_timer.restart()

# ... do something

# Get time:
time_hhmmss = my_timer.get_time_hhmmss()

# ... etc

පවත්නා කාර්යයන් වටා කිසිදු කේතයක් එකතු නොකර ඇතැම් කාර්යයන් සඳහා ගතවන කාලය මැනීම සඳහා පයිතන් cProfile සහ pstats මොඩියුල විශාල සහයෝගයක් ලබා දෙයි.

උදාහරණයක් ලෙස ඔබට පයිතන් ස්ක්‍රිප්ට් තිබේ නම් timeFunctions.py:

import time

def hello():
    print "Hello :)"
    time.sleep(0.1)

def thankyou():
    print "Thank you!"
    time.sleep(0.05)

for idx in range(10):
    hello()

for idx in range(100):
    thankyou()

පැතිකඩ ධාවනය කිරීමට සහ ගොනුව සඳහා සංඛ්‍යාලේඛන ජනනය කිරීමට ඔබට ක්‍රියාත්මක කළ හැකිය:

python -m cProfile -o timeStats.profile timeFunctions.py

මෙය කරන්නේ cFrofile මොඩියුලය භාවිතා කරමින් timeFunctions.py හි සියලුම කාර්යයන් පැතිකඩ කිරීම සහ timeStats.profile ගොනුවේ සංඛ්‍යාලේඛන එකතු කිරීමයි. පවතින මොඩියුලයට (timeFunctions.py) අපට කිසිදු කේතයක් එක් කිරීමට අවශ්‍ය නොවූ බවත් මෙය ඕනෑම මොඩියුලයක් සමඟ කළ හැකි බවත් සලකන්න.

ඔබ සංඛ්‍යාලේඛන ගොනුව ලබා ගත් පසු ඔබට pstats මොඩියුලය පහත පරිදි ක්‍රියාත්මක කළ හැකිය:

python -m pstats timeStats.profile

මෙය අන්තර්ක්‍රියාකාරී සංඛ්‍යාලේඛන බ්‍රව්සරය ක්‍රියාත්මක කරන අතර එමඟින් ඔබට හොඳ ක්‍රියාකාරිත්වයක් ලබා දේ. ඔබේ විශේෂිත භාවිත අවස්ථාව සඳහා ඔබේ ක්‍රියාකාරිත්වය සඳහා සංඛ්‍යාලේඛන පරීක්ෂා කළ හැකිය. අපගේ උදාහරණයේ දී කාර්යයන් දෙකම සඳහා සංඛ්‍යාලේඛන පරීක්ෂා කිරීමෙන් අපට පහත දේ පෙන්වයි:

Welcome to the profile statistics browser.
timeStats.profile% stats hello
<timestamp>    timeStats.profile

         224 function calls in 6.014 seconds

   Random listing order was used
   List reduced from 6 to 1 due to restriction <'hello'>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
       10    0.000    0.000    1.001    0.100 timeFunctions.py:3(hello)

timeStats.profile% stats thankyou
<timestamp>    timeStats.profile

         224 function calls in 6.014 seconds

   Random listing order was used
   List reduced from 6 to 1 due to restriction <'thankyou'>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
      100    0.002    0.000    5.012    0.050 timeFunctions.py:7(thankyou)

ව්‍යාජ උදාහරණය බොහෝ දේ නොකරන නමුත් කළ හැකි දේ පිළිබඳ අදහසක් ඔබට ලබා දෙයි. මෙම ප්‍රවේශයේ ඇති හොඳම කොටස නම්, මෙම සංඛ්‍යා ලබා ගැනීම සඳහා මගේ දැනට පවතින කේත කිසිවක් සංස්කරණය කිරීමට අවශ්‍ය නොවන අතර පැහැදිලිවම පැතිකඩ සඳහා සහාය වීමයි.

කාල කේතය සඳහා තවත් සන්දර්භ කළමනාකරුවෙකු මෙන්න -

භාවිතය:

from benchmark import benchmark

with benchmark("Test 1+1"):
    1+1
=>
Test 1+1 : 1.41e-06 seconds

හෝ, ඔබට කාල අගය අවශ්‍ය නම්

with benchmark("Test 1+1") as b:
    1+1
print(b.time)
=>
Test 1+1 : 7.05e-07 seconds
7.05233786763e-07

benchmark.py :

from timeit import default_timer as timer

class benchmark(object):

    def __init__(self, msg, fmt="%0.3g"):
        self.msg = msg
        self.fmt = fmt

    def __enter__(self):
        self.start = timer()
        return self

    def __exit__(self, *args):
        t = timer() - self.start
        print(("%s : " + self.fmt + " seconds") % (self.msg, t))
        self.time = t

අනුවර්තනය කරන ලද්දේ http://dabeaz.blogspot.fr/2010/02/context-manager-for-timing-benchmarks.html

පැතිකඩ මොඩියුලය භාවිතා කරන්න. එය ඉතා සවිස්තරාත්මක පැතිකඩක් ලබා දෙයි.

import profile
profile.run('main()')

එය මෙවැනි දෙයක් ප්‍රතිදානය කරයි:

          5 function calls in 0.047 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    0.000    0.000 :0(exec)
        1    0.047    0.047    0.047    0.047 :0(setprofile)
        1    0.000    0.000    0.000    0.000 <string>:1(<module>)
        0    0.000             0.000          profile:0(profiler)
        1    0.000    0.000    0.047    0.047 profile:0(main())
        1    0.000    0.000    0.000    0.000 two_sum.py:2(twoSum)

මම එය ඉතා තොරතුරු සහිත බව සොයාගෙන ඇත.

මම එයට සරලයි (පයිතන් 3):

from timeit import timeit

timeit(lambda: print("hello"))

ප්‍රතිදානය තනි ක්‍රියාත්මක කිරීම සඳහා මයික්‍රෝ තත්පර වේ:

2.430883963010274

පැහැදිලි කිරීම : ටයිමිට් විසින් පෙරනිමියෙන් නිර්නාමික ශ්‍රිතය මිලියනය වතාවක් ක්‍රියාත්මක කරන අතර ප්‍රති result ලය තත්පර කිහිපයකින් දෙනු ලැබේ . එබැවින් තනි ක්‍රියාත්මක කිරීමක ප්‍රති result ලය එකම ප්‍රමාණයකි නමුත් සාමාන්‍යයෙන් මයික්‍රෝ තත්පර වලින්.

සඳහා මන්දගාමී මෙහෙයුම් අඩු එකතු අංකය : අනුකරණ හෝ ඔබ සදහටම බලා ගත හැකි

import time

timeit(lambda: time.sleep(1.5), number=1)

සම්පූර්ණ පුනරාවර්තන ගණන සඳහා ප්‍රතිදානය සෑම විටම තත්පර වලින් වේ :

1.5015795179999714

(Ipython සමඟ පමණක්) සාමාන්‍ය සැකසුම් කාලය මැනීමට ඔබට % timeit භාවිතා කළ හැකිය :

def foo():
    print "hello"

ඊළගට:

%timeit foo()

ප්‍රති result ලය මෙවැනි දෙයක්:

10000 loops, best of 3: 27 µs per loop

වේලාසන භාවිතා කිරීමට තවත් එක් ක්‍රමයක් :

from timeit import timeit

def func():
    return 1 + 1

time = timeit(func, number=1)
print(time)

python3 මත:

from time import sleep, perf_counter as pc
t0 = pc()
sleep(1)
print(pc()-t0)

අලංකාර සහ කෙටි.

සුපිරි පසුකාලීන ප්‍රතිචාරයක්, නමුත් සමහර විට එය යමෙකුට අරමුණක් ඉටු කරයි. මෙය සුපිරි පිරිසිදු යැයි මා සිතන එය කළ හැකි ක්‍රමයකි.

import time

def timed(fun, *args):
    s = time.time()
    r = fun(*args)
    print('{} execution took {} seconds.'.format(fun.__name__, time.time()-s))
    return(r)

timed(print, "Hello")

"මුද්‍රණය" යනු පයිතන් 3 හි ශ්‍රිතයක් මිස පයිතන් 2.7 නොවන බව මතක තබා ගන්න. කෙසේ වෙතත්, එය වෙනත් ඕනෑම කාර්යයක් සමඟ ක්රියා කරයි. චියර්ස්!

ඔබට timeit භාවිතා කළ හැකිය.

පයිතන් REPL භාවිතා කරමින් පරාමිතිය ගන්නා naive_func පරීක්ෂා කරන්නේ කෙසේද යන්න පිළිබඳ උදාහරණයක් මෙන්න:

>>> import timeit                                                                                         

>>> def naive_func(x):                                                                                    
...     a = 0                                                                                             
...     for i in range(a):                                                                                
...         a += i                                                                                        
...     return a                                                                                          

>>> def wrapper(func, *args, **kwargs):                                                                   
...     def wrapper():                                                                                    
...         return func(*args, **kwargs)                                                                  
...     return wrapper                                                                                    

>>> wrapped = wrapper(naive_func, 1_000)                                                                  

>>> timeit.timeit(wrapped, number=1_000_000)                                                              
0.4458435332577161  

ශ්‍රිතයට පරාමිතීන් නොමැති නම් ඔබට එතීමේ කාර්යය අවශ්‍ය නොවේ.

අපට කාලය මිනිස් කියවිය හැකි කාලය බවට පරිවර්තනය කළ හැකිය.

import time, datetime

start = time.clock()

def num_multi1(max):
    result = 0
    for num in range(0, 1000):
        if (num % 3 == 0 or num % 5 == 0):
            result += num

    print "Sum is %d " % result

num_multi1(1000)

end = time.clock()
value = end - start
timestamp = datetime.datetime.fromtimestamp(value)
print timestamp.strftime('%Y-%m-%d %H:%M:%S')

සෑම ක්‍රියාකාරී ඇමතුමකම පුනරාවර්තන ලෙස අවබෝධය ලබා ගැනීම සඳහා, කරන්න:

%load_ext snakeviz
%%snakeviz

එය ජුපිටර් නෝට්බුක් එකක ඇති කේත පේළි 2 ක් පමණක් ගන්නා අතර එය හොඳ අන්තර්ක්‍රියාකාරී රූප සටහනක් ජනනය කරයි. උදාහරණයක් වශයෙන්:

මෙන්න කේතය. නැවතත්, ආරම්භ වන පේළි 2 %සර්ප විවිස් භාවිතා කිරීමට අවශ්‍ය එකම අතිරේක කේත රේඛා වේ:

# !pip install snakeviz
%load_ext snakeviz
import glob
import hashlib

%%snakeviz

files = glob.glob('*.txt')
def print_files_hashed(files):
    for file in files:
        with open(file) as f:
            print(hashlib.md5(f.read().encode('utf-8')).hexdigest())
print_files_hashed(files)

නෝට්බුක් වලින් පිටත සර්පයන් ධාවනය කළ හැකි බව පෙනේ. Snakeviz වෙබ් අඩවියේ වැඩි විස්තර .

මම මේ සඳහා පුස්තකාලයක් සාදා, ඔබට ශ්‍රිතයක් මැනීමට අවශ්‍ය නම් ඔබට එය මේ ආකාරයෙන් කළ හැකිය

from pythonbenchmark import compare, measure
import time

a,b,c,d,e = 10,10,10,10,10
something = [a,b,c,d,e]

@measure
def myFunction(something):
    time.sleep(0.4)

@measure
def myOptimizedFunction(something):
    time.sleep(0.2)

myFunction(input)
myOptimizedFunction(input)

https://github.com/Karlheinzniebuhr/pythonbenchmark

මෙහෙයුමක කාලය ගණනය කිරීමට පහසුම ක්‍රමය:

import time

start_time = time.monotonic()
print(time.ctime())

<operations, programs>

print('minutes: ',(time.monotonic() - start_time)/60)

මෙන්න මම සාමාන්‍ය උපයෝගීතාවයක් ලෙස භාවිතා කරන මනාව ලේඛනගත කර ඇති සහ සම්පුර්ණයෙන්ම ටයිප් කළ ඉඟි සැරසිලි කරුවෙක්:

from functools import wraps
from time import perf_counter
from typing import Any, Callable, Optional, TypeVar, cast

F = TypeVar("F", bound=Callable[..., Any])


def timer(prefix: Optional[str] = None, precision: int = 6) -> Callable[[F], F]:
    """Use as a decorator to time the execution of any function.

    Args:
        prefix: String to print before the time taken.
            Default is the name of the function.
        precision: How many decimals to include in the seconds value.

    Examples:
        >>> @timer()
        ... def foo(x):
        ...     return x
        >>> foo(123)
        foo: 0.000...s
        123
        >>> @timer("Time taken: ", 2)
        ... def foo(x):
        ...     return x
        >>> foo(123)
        Time taken: 0.00s
        123

    """
    def decorator(func: F) -> F:
        @wraps(func)
        def wrapper(*args: Any, **kwargs: Any) -> Any:
            nonlocal prefix
            prefix = prefix if prefix is not None else f"{func.__name__}: "
            start = perf_counter()
            result = func(*args, **kwargs)
            end = perf_counter()
            print(f"{prefix}{end - start:.{precision}f}s")
            return result
        return cast(F, wrapper)
    return decorator

උදාහරණ භාවිතය:

from timer import timer


@timer(precision=9)
def takes_long(x: int) -> bool:
    return x in (i for i in range(x + 1))


result = takes_long(10**8)
print(result)

ප්‍රතිදානය:

takes_long: 4.942629056s
True

පහත සඳහන් කරුණු සමඟ පරීක්ෂා කළ හැකිය:

$ python3 -m doctest --verbose -o=ELLIPSIS timer.py

වර්ගය සමඟ ඉඟි කරන්නේ:

$ mypy timer.py

මෙම අද්විතීය පංති පාදක ප්‍රවේශය මඟින් මුද්‍රණය කළ හැකි නූල් නිරූපණයක්, අභිරුචිකරණය කළ හැකි වටකුරු කිරීමක් සහ ගත වූ වේලාවට නූලක් හෝ පාවීමක් ලෙස පහසු ප්‍රවේශයක් ලබා දේ. එය පයිතන් 3.7 සමඟ සංවර්ධනය කරන ලදී.

import datetime
import timeit


class Timer:
    """Measure time used."""
    # Ref: https://stackoverflow.com/a/57931660/

    def __init__(self, round_ndigits: int = 0):
        self._round_ndigits = round_ndigits
        self._start_time = timeit.default_timer()

    def __call__(self) -> float:
        return timeit.default_timer() - self._start_time

    def __str__(self) -> str:
        return str(datetime.timedelta(seconds=round(self(), self._round_ndigits)))

භාවිතය:

# Setup timer
>>> timer = Timer()

# Access as a string
>>> print(f'Time elapsed is {timer}.')
Time elapsed is 0:00:03.
>>> print(f'Time elapsed is {timer}.')
Time elapsed is 0:00:04.

# Access as a float
>>> timer()
6.841332235
>>> timer()
7.970274425

කුඩා කේත ස්නිපෙට් ක්‍රියාත්මක කිරීමේ කාලය මැනීම.

කාල ඒකකය : තත්පරයකින් පාවෙන ලෙස මනිනු ලැබේ

import timeit
t = timeit.Timer('li = list(map(lambda x:x*2,[1,2,3,4,5]))')
t.timeit()
t.repeat()
>[1.2934070999999676, 1.3335035000000062, 1.422568500000125]

පුනරාවර්තන () ක්‍රමය ටයිමිට් () කිහිප වතාවක් ඇමතීමට සහ ප්‍රති .ල ලැයිස්තුවක් ලබා දීමට පහසුවකි.

repeat(repeat=3)¶

මෙම ලැයිස්තුව සමඟ අපට සෑම විටම මධ්යන්ය ගත හැකිය.

පෙරනිමියෙන්, ටයිමිට් () වේලාව තුළ කසළ එකතු කිරීම තාවකාලිකව අක්‍රිය කරයි. time.Timer () මෙම ගැටළුව විසඳයි.

වාසි:

timeit.Timer () ස්වාධීන වේලාවන් වඩාත් සැසඳිය හැකිය. මනිනු ලබන ශ්‍රිතයේ ක්‍රියාකාරීත්වයේ වැදගත් අංගයක් gc විය හැකිය. එසේ නම්, සැකසුම් නූලෙහි පළමු ප්‍රකාශය ලෙස gc (කසළ එකතු කරන්නා) නැවත සක්‍රීය කළ හැකිය. උදාහරණයක් වශයෙන්:

timeit.Timer('li = list(map(lambda x:x*2,[1,2,3,4,5]))',setup='gc.enable()')

මූලාශ්‍රය පයිතන් ලියකියවිලි !

import time

def getElapsedTime(startTime, units):
    elapsedInSeconds = time.time() - startTime
    if units == 'sec':
        return elapsedInSeconds
    if units == 'min':
        return elapsedInSeconds/60
    if units == 'hour':
        return elapsedInSeconds/(60*60)

ඔබට පහසුවෙන් වේලාවට කටයුතු කිරීමට අවශ්‍ය නම්, ඔබට සරල සැරසිලි කරුවෙකු භාවිතා කළ හැකිය:

def timing_decorator(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        original_return_val = func(*args, **kwargs)
        end = time.time()
        print("time elapsed in ", func.__name__, ": ", end - start, sep='')
        return original_return_val

    return wrapper

ඔබට මේ ආකාරයට කාලය ගත කිරීමට අවශ්‍ය ශ්‍රිතයක් මත එය භාවිතා කළ හැකිය:

@timing_decorator
def function_to_time():
    time.sleep(1)

එවිට ඔබ අමතන ඕනෑම වේලාවක function_to_time, එය කොපමණ කාලයක් ගතවේද යන්න සහ ශ්‍රිතයේ නම කාලානුරූපව මුද්‍රණය කරනු ඇත.

https://stackoverflow.com/a/30024601/5095636 විසින් ලබා දී ඇති සන්දර්භ කළමණාකරණ විසඳුම මත පදනම්ව , මෙහි ලැම්බඩා නිදහස් අනුවාදය, E731 අනුව ලැම්බඩා භාවිතය පිළිබඳව flake8 අනතුරු අඟවයි :

from contextlib import contextmanager
from timeit import default_timer

@contextmanager
def elapsed_timer():
    start_time = default_timer()

    class _Timer():
      start = start_time
      end = default_timer()
      duration = end - start

    yield _Timer

    end_time = default_timer()
    _Timer.end = end_time
    _Timer.duration = end_time - start_time

පරීක්ෂණය:

from time import sleep

with elapsed_timer() as t:
    print("start:", t.start)
    sleep(1)
    print("end:", t.end)

t.start
t.end
t.duration