मैं जो चाहता हूं वह मेरे कोड में कहीं समय गिनना शुरू करना है और फिर पारित समय प्राप्त करना है, कुछ फ़ंक्शन को निष्पादित करने में लगने वाले समय को मापने के लिए। मुझे लगता है कि मैं टाइमटाइम मॉड्यूल का गलत उपयोग कर रहा हूं, लेकिन डॉक्स मेरे लिए भ्रमित कर रहे हैं।
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(धन्यवाद एम्बर )। हालाँकि, यह वर्तमान में पदावनत है:
यूनिक्स पर, वर्तमान प्रोसेसर समय को सेकंड में व्यक्त किए गए फ्लोटिंग पॉइंट नंबर के रूप में लौटाएं। सटीक, और वास्तव में "प्रोसेसर समय" के अर्थ की बहुत परिभाषा, उसी नाम के सी फ़ंक्शन पर निर्भर करता है।
Windows पर, यह फ़ंक्शन Win32 फ़ंक्शन के आधार पर, फ्लोटिंग पॉइंट नंबर के रूप में इस फ़ंक्शन पर पहली कॉल के बाद से दीवार-घड़ी सेकंड लौटाता है
QueryPerformanceCounter()। रिज़ॉल्यूशन आमतौर पर एक माइक्रोसेकंड से बेहतर है।संस्करण 3.3 के बाद से पदावनत : इस फ़ंक्शन का व्यवहार प्लेटफ़ॉर्म पर निर्भर करता है: अपनी आवश्यकताओं के आधार पर, उपयोग
perf_counter()याprocess_time()इसके बजाय , एक अच्छी तरह से परिभाषित व्यवहार करने के लिए।
time.clock()वास्तव में पसंद किया जाता है, क्योंकि इसमें हस्तक्षेप नहीं किया जा सकता है अगर सिस्टम घड़ी के साथ गड़बड़ हो जाती है, लेकिन .time()ज्यादातर एक ही उद्देश्य को पूरा करता है।)
print(timedelta(seconds=execution_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.38091952400282timeit.default_timer OS के आधार पर time.time () या time.clock () को असाइन किया गया है। अजगर पर 3.3+ default_timer है time.perf_counter () सभी प्लेटफार्मों पर। पायथन देखें - time.clock () बनाम time.time () - सटीकता?
यह सभी देखें:
default_timer() measurations can be affected by other programs running on the same machine, so the best thing to do when accurate timing is necessary is to repeat the timing a few times and use the best time. The -r option is good for this; the default of 3 repetitions is probably enough in most cases. On Unix, you can use time.clock() to measure CPU time.
perfमॉड्यूल में भी रुचि हो सकती है (उत्तर के समय कोई भी नहीं) जो समान इंटरफ़ेस प्रदान करता है लेकिन यह कभी-कभी timeitमॉड्यूल के निर्णयों से अलग होता है कि समय के प्रदर्शन को कैसे मापें।
चूंकि time.clock () Python 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में नींद के दौरान बीता हुआ समय शामिल नहीं होगा।
timeit.default_timer बजाय का उपयोग करेंtime.perf_counter । पूर्व आपके प्लेटफ़ॉर्म और पायथन संस्करण के लिए ट्यून किए गए समय के प्रदर्शन को मापने के लिए उपयुक्त टाइमर का चयन करेगा। नींद के दौरान समय को शामिल नहीं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 सेकंड) वापस आती है।
यह मेरे लिए ज़्यादा प्रधान है। 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 पेज अधिक जानकारी के लिए।
t.tic()कोड में दफनाया जाना था, तो यह मेरे लिए डेवलपर है कि मैं इस बात की मानसिक सूची रखूं कि मुझे श्रृंखला में कहां होना चाहिए। क्या आप अपने आप को घोंसले या बस कई tictocs स्थापित कर पाते हैं?
ttictoc। काफी गड़बड़ मेरे पास थी, लेकिन यह अब अच्छा होना चाहिए।
यहाँ कई अच्छे उत्तरों के साथ-साथ कुछ अन्य लेखों के माध्यम से जाने के बाद मेरे निष्कर्ष हैं।
सबसे पहले, यदि आप के बीच बहस कर रहे हैं timeitऔर time.time, timeitदो फायदे हैं:
timeit आपके OS और पायथन संस्करण पर उपलब्ध सर्वोत्तम टाइमर का चयन करता है। 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लाभ:
कई आधे-समर्थित संस्करण तैर रहे हैं इसलिए मैं कुछ हाइलाइट्स को इंगित करना चाहता हूं:
with utils.MeasureBlockTime() as tऔर फिर t.elapsed)।time.timeनिष्पादन को मापने के लिए उपयोग करने से आपको अपने आदेशों का समग्र निष्पादन समय मिलता है, जिसमें आपके कंप्यूटर पर अन्य प्रक्रियाओं द्वारा खर्च किया गया समय भी शामिल है। यह उपयोगकर्ता के नोटिस का समय है, लेकिन यदि आप विभिन्न कोड स्निपेट / एल्गोरिदम / फ़ंक्शन / ... की तुलना करना चाहते हैं तो यह अच्छा नहीं है ...
अधिक जानकारी पर timeit:
यदि आप रूपरेखा में गहरी जानकारी चाहते हैं:
अपडेट : मैंने पिछले वर्ष के दौरान 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 मॉड्यूल मौजूदा कार्यों के आसपास किसी भी कोड को जोड़ने के बिना कुछ कार्यों में गुजरे समय को मापने के लिए बहुत समर्थन प्रदान करते हैं।
उदाहरण के लिए यदि आपके पास एक पायथन लिपि का समय है।
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यह क्या कर रहा है cProfile मॉड्यूल का उपयोग करके सभी कार्यों को 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)डमी उदाहरण बहुत कुछ नहीं करता है लेकिन आपको यह अंदाजा देता है कि क्या किया जा सकता है। इस दृष्टिकोण के बारे में सबसे अच्छी बात यह है कि मुझे इन नंबरों को प्राप्त करने के लिए अपने किसी भी मौजूदा कोड को संपादित करने की आवश्यकता नहीं है और जाहिर है कि यह प्रोफाइलिंग के साथ मदद करता है।
python -m pstats timeStats.profile ValueError: bad marshal data (unknown type code)अपने अजगर संस्करण की जाँच कर रहे हैं जो आप चला रहे हैं। मैं यह मिल गया जब मैं भाग गया python3 -m cProfile...और python -m pstats। मेरी गलती लेकिन मुझे एक सेकंड के लिए मिला, इसलिए, मैं साझा करना चाहता था don't forget consistency। =)
टाइमिंग कोड के लिए यहां एक और संदर्भ प्रबंधक दिया गया है -
उपयोग:
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मानदंड :
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 = tHttp://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)मैंने इसे बहुत जानकारीपूर्ण पाया है।
main()? यदि आप एक सरल कोड उदाहरण प्रदान कर सकते हैं तो अधिक उपयोगी होगा।
मुझे यह सरल लगता है (अजगर 3):
from timeit import timeit
timeit(lambda: print("hello"))आउटपुट एकल निष्पादन के लिए माइक्रोसेकंड है :
2.430883963010274स्पष्टीकरण : समय-समय पर अनाम फ़ंक्शन को डिफ़ॉल्ट रूप से 1 मिलियन बार निष्पादित किया जाता है और परिणाम सेकंड में दिया जाता है । इसलिए 1 एकल निष्पादन के लिए परिणाम एक ही राशि है लेकिन औसत पर माइक्रोसेकंड में ।
के लिए धीमी गति से संचालन एक कम जोड़ने संख्या दोहराव हैं या आप हमेशा के लिए इंतजार कर किया जा सकता है:
import time
timeit(lambda: time.sleep(1.5), number=1)पुनरावृत्तियों की कुल संख्या के लिए आउटपुट हमेशा सेकंड में होता है :
1.5015795179999714(केवल खसखस के साथ) आप औसत प्रसंस्करण समय को मापने के लिए % timeit का उपयोग कर सकते हैं :
def foo():
print "hello"और फिर:
%timeit foo()परिणाम कुछ इस प्रकार है:
10000 loops, best of 3: 27 µs per loopअजगर 3 पर:
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। हालाँकि, यह किसी अन्य फ़ंक्शन के साथ काम करता है। चीयर्स!
आप समयसीमा का उपयोग कर सकते हैं।
यहाँ एक उदाहरण है कि कैसे 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 यदि फ़ंक्शन में कोई पैरामीटर नहीं है, तो आपको रैपर फ़ंक्शन की आवश्यकता नहीं है।
lambdaअधिक print(timeit.timeit(lambda: naive_func(1_000), number=1_000_000))
हम समय को मानव-पठनीय समय में भी बदल सकते हैं।
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')मैंने इसके लिए एक पुस्तकालय बनाया है, यदि आप एक फ़ंक्शन को मापना चाहते हैं तो आप इसे इस तरह से कर सकते हैं
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)%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)नोटबुक के बाहर सर्पविज़ को चलाना भी संभव लगता है। स्नेकविज़ वेबसाइट पर अधिक जानकारी ।
यह अद्वितीय वर्ग-आधारित दृष्टिकोण एक मुद्रण योग्य स्ट्रिंग प्रतिनिधित्व, अनुकूलन गोलाई, और एक स्ट्रिंग या फ्लोट के रूप में बीता समय के लिए सुविधाजनक पहुंच प्रदान करता है। इसे पायथन 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 (कचरा संग्रहकर्ता) को फिर से सक्षम किया जा सकता है। उदाहरण के लिए:
timeit.Timer('li = list(map(lambda x:x*2,[1,2,3,4,5]))',setup='gc.enable()')
स्रोत पायथन डॉक्स !
यदि आप आसानी से समय के कार्यों में सक्षम होना चाहते हैं, तो आप एक साधारण डेकोरेटर का उपयोग कर सकते हैं:
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 द्वारा दिए गए प्रसंग समाधान के आधार पर , लैम्ब्डा फ्री वर्जन को सम्मिलित करें, जैसा कि फ्लैक 8 ई 731 के अनुसार लैम्ब्डा के उपयोग पर चेतावनी देता है :
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एक ही तरीका है जिसके बारे में मैं सोच सकता हूं time.time()।
import time
start = time.time()
sleep(5) #just to give it some delay to show it working
finish = time.time()
elapsed = finish - start
print(elapsed)आशा है कि मदद मिलेगी।
timeitमॉड्यूल अजगर कोड का एक छोटा सा टुकड़ा समय के लिए अच्छा है। इसका उपयोग कम से कम तीन रूपों में किया जा सकता है:
1- कमांड-लाइन मॉड्यूल के रूप में
python2 -m timeit 'for i in xrange(10): oct(i)' 2- एक छोटे कोड के लिए, इसे तर्क के रूप में पास करें।
import timeit
timeit.Timer('for i in xrange(10): oct(i)').timeit()3- अधिक लंबे समय तक कोड के लिए:
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=100)/100
print(elapsed_time)