मेरे पास पायथन में एक कमांड लाइन कार्यक्रम है जिसे समाप्त करने में कुछ समय लगता है। मैं यह जानना चाहता हूं कि रनिंग को पूरा करने में कितना समय लगता है।
मैंने timeitमॉड्यूल को देखा है , लेकिन ऐसा लगता है कि यह केवल कोड के छोटे स्निपेट के लिए है। मैं पूरे कार्यक्रम को समय देना चाहता हूं।
जवाबों:
पायथन में सबसे सरल तरीका:
import time
start_time = time.time()
main()
print("--- %s seconds ---" % (time.time() - start_time))
यह मानता है कि आपके कार्यक्रम को चलने में कम से कम दसवां हिस्सा लगता है।
प्रिंटों:
--- 0.764891862869 seconds ---round(time.time() - start_time, 2)(या जो भी दशमलव आप चाहते हैं), मुझे 1.24e-5 जैसे वैज्ञानिक नंबर वापस मिल रहे थे।
'%.2f'बजाय चाहते round()हैं।
मैंने इस 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 संस्करण यहां या यहां पाया जा सकता है ।
from functools import reduceलिए शीर्ष पर जोड़ें और प्रत्येक प्रिंट स्टेटमेंट के चारों ओर कोष्ठक लगाएं। बहुत अच्छा काम करता है!
लिनक्स या यूनिक्स में:
$ time python yourprogram.pyविंडोज में, यह स्टैकऑवरफ्लो प्रश्न देखें: मैं विंडोज कमांड लाइन पर कमांड के निष्पादन समय को कैसे मापता हूं?
अधिक क्रिया उत्पादन के लिए,
$ 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: 0secondsToStr()कार्य को देखें।
मैं वास्तव में पॉल मैकगायर के उत्तर को पसंद करता हूं , लेकिन मैं पायथन 3 का उपयोग करता हूं। इसलिए उन लोगों के लिए जो रुचि रखते हैं: यहां उनके उत्तर का एक संशोधन है जो पायथन 3 के साथ * निक्स (मैं सोचता हूं, विंडोज के तहत काम करता हूं, जिसका 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")यदि आपको यह उपयोगी लगता है, तो आपको अभी भी इस एक के बजाय उसके जवाब को वोट देना चाहिए, क्योंकि उसने अधिकांश काम किया था;)।
timedelta(seconds=t).total_seconds()मददगार पाया ।
import time
start_time = time.clock()
main()
print time.clock() - start_time, "seconds"time.clock()प्रोसेसर समय लौटाता है, जो हमें इस प्रक्रिया द्वारा उपयोग किए गए केवल समय की गणना करने की अनुमति देता है (वैसे भी यूनिक्स पर)। दस्तावेज़ीकरण "किसी भी मामले में, यह पायथन या टाइमिंग एल्गोरिदम बेंचमार्किंग के लिए उपयोग करने के लिए फ़ंक्शन है"
मुझे वह आउटपुट पसंद है जो 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जैसा कि JF सेबेस्टियन ने उल्लेख किया है, यह दृष्टिकोण स्थानीय समय के साथ कुछ मुश्किल मामलों का सामना कर सकता है, इसलिए इसका उपयोग करना सुरक्षित है:
import time
from datetime import timedelta
start_time = time.monotonic()
end_time = time.monotonic()
print(timedelta(seconds=end_time - start_time))timedelta(seconds=time.monotonic()-start)यहाँ उपयोग कर सकते हैं (या time.time()यदि अंतराल बड़ा है)। स्थानीय समय का प्रतिनिधित्व करने वाली भोली डेटाइम वस्तुओं को घटाना न करें; स्थानीय समय नीरस नहीं है
start_time = time.monotonic(); end_time = time.monotonic(); timedelta(seconds=end_time - start_time)। मुझे विश्वास है कि आप सही हैं, लेकिन फिर आपको इसे भी प्रारूपित करना होगा, जैसे ही आप वापस आते हैं datetime.timedelta(0, 0, 76)। इसके अलावा, लगता है कि मोनोटोनिक विधि केवल पायथन 3 में जोड़ी गई थी
str()इसे "मानव" बनाने के लिए इसे पारित कर सकते हैं । मैं जवाब को अपडेट करूंगा, धन्यवाद।
आप CPU समय को मापने के लिए पायथन प्रोफाइलर cProfile का उपयोग कर सकते हैं और इसके अलावा प्रत्येक फ़ंक्शन के अंदर कितना समय बिताया जाता है और प्रत्येक फ़ंक्शन को कितनी बार कहा जाता है। यह बहुत उपयोगी है अगर आप अपनी स्क्रिप्ट के प्रदर्शन में सुधार करना चाहते हैं, बिना यह जाने कि कहां से शुरू करना है। एक और स्टैक ओवरफ्लो प्रश्न का यह उत्तर बहुत अच्छा है। प्रलेखन में एक नज़र रखना भी हमेशा अच्छा होता है ।
यहाँ एक उदाहरण है कि कमांड लाइन से 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}X function calls in Y CPU seconds। यदि आप दीवार घड़ी का समय चाहते हैं, तो यहां अन्य उत्तरों में से एक का उपयोग करें।
लिनक्स के लिए और भी बेहतर: 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समय घड़ी()
संस्करण 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मॉड्यूल का उपयोग करें । यह पायथन 2 और पायथन 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यह सेकंड में वापस आ जाता है और आपके निष्पादन का समय हो सकता है। यह सरल है, लेकिन आपको इन inw मुख्य फ़ंक्शन को लिखना चाहिए जो प्रोग्राम निष्पादन शुरू करता है। यदि आप एक त्रुटि मिलने पर भी निष्पादन का समय प्राप्त करना चाहते हैं तो अपना पैरामीटर "प्रारंभ" करके उसमें ले जाएं और इस तरह से गणना करें:
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))finally?
निम्नलिखित स्निपेट प्रिंट एक अच्छा मानव पठनीय <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) मैंने टाइमटाइम मॉड्यूल को देखा है, लेकिन ऐसा लगता है कि यह केवल कोड के छोटे स्निपेट के लिए है। मैं पूरे कार्यक्रम को समय देना चाहता हूं।
$ python -mtimeit -n1 -r1 -t -s "from your_module import main" "main()"यह your_module.main()एक बार फ़ंक्शन चलाता है और उपयोग किए गए बीते समय को प्रिंट करता हैtime.time() टाइमर के रूप में फ़ंक्शन करते ।
/usr/bin/timeपाइथन में अनुकरण करने के लिए पाइथन सबप्रोसेस को / usr / bin / time के साथ देखें: टाइमिंग की जानकारी कैसे कैप्चर करें लेकिन सभी आउटपुट को अनदेखा करें?।
time.sleep()प्रत्येक फ़ंक्शन के लिए सीपीयू समय (जैसे, समय के दौरान शामिल न करें ) को मापने के लिए, आप profileमॉड्यूल ( cProfileपायथन 2 पर) का उपयोग कर सकते हैं :
$ python3 -mprofile your_module.pyआप दे सकते हैं -pकरने के लिए timeitउपरोक्त आदेश आप के रूप में ही टाइमर का उपयोग करना चाहते हैंprofile मॉड्यूल का उपयोग करता है।
मुझे पॉल मैकगायर का उत्तर भी पसंद आया और एक संदर्भ प्रबंधक के रूप में आया, जिसने मेरी आवश्यकताओं को अधिक अनुकूल बनाया।
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))एक सेल में, आप %%timeनिष्पादन समय को मापने के लिए जुपिटर के मैजिक कमांड का उपयोग कर सकते हैं :
%%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_notebookIPython CPU timings (estimated):
User : 0.00 s.
System : 0.00 s.
Wall time: 0.00 s.एक timeitमॉड्यूल है जिसका उपयोग पायथन कोड के निष्पादन के समय के लिए किया जा सकता है।
इसका विस्तार दस्तावेज़ीकरण और पायथन प्रलेखन, 26.6 में उदाहरण हैं । timeit - छोटे कोड स्निपेट के निष्पादन समय को मापें ।
timeitप्रश्न में स्पष्ट रूप से उल्लेख करता है। सवाल यह है कि इसका उपयोग यहां कैसे किया जा सकता है (या इसका उपयोग यहां किया जाना चाहिए और विकल्प क्या हैं)। यहाँ संभावित उत्तर है ।
लाइन_प्रोफाइलर का उपयोग करें ।
line_profiler उस समय को कोडित करने के लिए अलग-अलग लाइनों के कोड को प्रोफाइल करेगा। प्रोफाइलर के ओवरहेड को कम करने के लिए साइथॉन के माध्यम से सी में प्रोफाइलर को लागू किया जाता है ।
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इसमें इकाइयों और गोलाई का ध्यान रखा जाता है। यह अजगर 3.6 या नए के साथ काम करता है।
main.interval।
यह पॉल मैकगायर का जवाब है जो मेरे लिए काम करता है। बस मामले में किसी को उस एक को चलाने में परेशानी हो रही थी।
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()फ़ाइल आयात करने के बाद अपने प्रोग्राम से कॉल करें।
टाइमिट पायथन में एक वर्ग है जिसका उपयोग कोड के छोटे ब्लॉकों के निष्पादन समय की गणना करने के लिए किया जाता है।
Default_timer इस वर्ग में एक विधि है जिसका उपयोग दीवार घड़ी की समय को मापने के लिए किया जाता है, न कि सीपीयू निष्पादन समय के लिए। इस प्रकार अन्य प्रक्रिया निष्पादन में हस्तक्षेप हो सकता है। इस प्रकार यह कोड के छोटे ब्लॉक के लिए उपयोगी है।
कोड का एक नमूना इस प्रकार है:
from timeit import default_timer as timer
start= timer()
# Some logic
end = timer()
print("Time taken:", end-start)timeitकई उदाहरणों के लिए बेहतर जवाब IMO है।
बाद में उत्तर दें, लेकिन मैं उपयोग करता हूं 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.159821493085474code_to_test ।number तर्क निर्दिष्ट करता है कि कोड को कितनी बार दोहराना चाहिए।एक अजगर कार्यक्रम के निष्पादन के उपाय का समय इसके आधार पर असंगत हो सकता है:
ऐसा इसलिए है क्योंकि सबसे प्रभावी तरीका "ऑर्डर ऑफ ग्रोथ" का उपयोग करना है और इसे ठीक से करने के लिए बिग "ओ" अंकन सीखें ।
वैसे भी, आप इस सरल एल्गोरिथ्म का उपयोग करके विशिष्ट मशीन गिनती के चरणों में किसी भी पायथन कार्यक्रम के प्रदर्शन का मूल्यांकन करने की कोशिश कर सकते हैं: जिस कार्यक्रम का आप मूल्यांकन करना चाहते हैं, उसके लिए इसे अनुकूलित करें
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")आप इसे केवल पायथन में करते हैं। इसे जटिल बनाने की कोई आवश्यकता नहीं है।
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सबसे पहले, कमांड प्रॉम्प्ट (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))आउटपुट:
पायथन 2.7 के लिए मेटाकार्मिट के अद्यतन उत्तर का उपयोग करने के लिए , आपको मोनोटोनिक की आवश्यकता होगी पैकेज की ।
फिर कोड इस प्रकार होगा:
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")यदि आप माइक्रोसेकंड में समय को मापना चाहते हैं, तो आप निम्न संस्करण का उपयोग कर सकते हैं, पूरी तरह से पॉल मैकगायर और निकोज़ो के उत्तर के आधार पर - यह पायथन 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")लॉग () => फ़ंक्शन जो समय की जानकारी को प्रिंट करता है।
txt ==> लॉग करने के लिए पहला तर्क, और टाइमिंग को चिह्नित करने के लिए इसकी स्ट्रिंग।
atexit ==> पायथन मॉड्यूल फ़ंक्शन को पंजीकृत करने के लिए जिसे आप प्रोग्राम से बाहर निकलने पर कॉल कर सकते हैं।