python समय मॉड्यूल के साथ विलुप्त समय मापना




time elapsed (5)

time.time() नौकरी करेगा।

import time

start = time.time()
# run your code
end = time.time()

elapsed = end - start

आप this सवाल को देखना चाह सकते हैं, लेकिन मुझे नहीं लगता कि यह आवश्यक होगा।

पाइथन में टाइम मॉड्यूल के साथ विलुप्त समय को मापना संभव है? अगर ऐसा है, तो मैं वह कैसे करू?

मुझे ऐसा करने की ज़रूरत है ताकि अगर कर्सर एक निश्चित अवधि के लिए विजेट में रहा हो तो एक घटना होती है।


start_time = time.time()
# your code
elapsed_time = time.time() - start_time

आप विभिन्न कार्यों के निष्पादन समय के माप को सरल बनाने के लिए सरल सजावट भी लिख सकते हैं:

import time
from functools import wraps

PROF_DATA = {}

def profile(fn):
    @wraps(fn)
    def with_profiling(*args, **kwargs):
        start_time = time.time()

        ret = fn(*args, **kwargs)

        elapsed_time = time.time() - start_time

        if fn.__name__ not in PROF_DATA:
            PROF_DATA[fn.__name__] = [0, []]
        PROF_DATA[fn.__name__][0] += 1
        PROF_DATA[fn.__name__][1].append(elapsed_time)

        return ret

    return with_profiling

def print_prof_data():
    for fname, data in PROF_DATA.items():
        max_time = max(data[1])
        avg_time = sum(data[1]) / len(data[1])
        print "Function %s called %d times. " % (fname, data[0]),
        print 'Execution time max: %.3f, average: %.3f' % (max_time, avg_time)

def clear_prof_data():
    global PROF_DATA
    PROF_DATA = {}

उपयोग:

@profile
def your_function(...):
    ...

आप एक साथ एक समारोह को और अधिक प्रोफ़ाइल कर सकते हैं। फिर मापन प्रिंट करने के लिए बस print_prof_data () को कॉल करें:


उन उपयोगकर्ताओं के लिए जो बेहतर स्वरूपण चाहते हैं,

import time
start_time = time.time()
# your script
elapsed_time = time.time() - start_time
time.strftime("%H:%M:%S", time.gmtime(elapsed_time))

2 सेकंड के लिए मुद्रित होगा:

'00:00:02'

और 7 मिनट के लिए एक सेकंड:

'00:07:01'

ध्यान दें कि जीएमटाइम के साथ न्यूनतम समय इकाई सेकेंड है। यदि आपको माइक्रोसेकंड की आवश्यकता है तो निम्न पर विचार करें:

import datetime
start = datetime.datetime.now()
# some code
end = datetime.datetime.now()
elapsed = end - start
print(elapsed)
# or
print(elapsed.seconds,":",elapsed.microseconds) 

strftime documentation


आपको समय आयात करने और फिर वर्तमान समय जानने के लिए time.time () विधि का उपयोग करने की आवश्यकता है।

import time

start_time=time.time() #taking current time as starting time

#here your code

elapsed_time=time.time()-start_time #again taking current time - starting time 

time.perf_counter() समय के सर्वोत्तम उपाय के लिए (पायथन 3.3 के बाद से) time.perf_counter() उपयोग करें।

एक प्रदर्शन काउंटर के मान (आंशिक सेकंड में) वापस करें, यानी एक छोटी अवधि को मापने के लिए उच्चतम उपलब्ध रिज़ॉल्यूशन वाले घड़ी। इसमें सोने के दौरान समय बीत गया है और सिस्टम-व्यापी है। लौटाए गए मान का संदर्भ बिंदु अपरिभाषित है, ताकि लगातार कॉल के परिणामों के बीच केवल अंतर मान्य हो।

घंटों / दिनों के आदेश पर माप के लिए, आपको उप-दूसरे रिज़ॉल्यूशन की परवाह नहीं है, इसलिए इसके बजाय docs.python.org/3/library/time.html#time.monotonic उपयोग करें।

एक monotonic घड़ी के मान (fractional सेकंड में), यानी एक घड़ी जो पीछे की ओर नहीं जा सकते हैं। घड़ी घड़ी घड़ी अद्यतन से प्रभावित नहीं है। लौटाए गए मान का संदर्भ बिंदु अपरिभाषित है, ताकि लगातार कॉल के परिणामों के बीच केवल अंतर मान्य हो।

कई कार्यान्वयन में, ये वास्तव में एक ही बात हो सकती है।

3.3 से पहले, आप time.clock() साथ अटक गए हैं।

यूनिक्स पर, वर्तमान प्रोसेसर समय को सेकंड में व्यक्त फ़्लोटिंग पॉइंट नंबर के रूप में वापस कर दें। परिशुद्धता, और वास्तव में "प्रोसेसर समय" के अर्थ की परिभाषा, उसी नाम के सी कार्य के आधार पर निर्भर करती है।

विंडोज़ पर, यह फ़ंक्शन Win32 फ़ंक्शन QueryPerformanceCounter () के आधार पर फ़्लोटिंग पॉइंट नंबर के रूप में, इस फ़ंक्शन के पहले कॉल के बाद वॉल-घड़ी सेकंड को समाप्त कर देता है। संकल्प आमतौर पर एक माइक्रोसेकंड से बेहतर होता है।

पायथन 3.7 के लिए अद्यतन करें

पायथन 3.7 में नया पीईपी 564 है - नैनोसेकंद संकल्प के साथ नए समय के कार्यों को जोड़ें।

इनका उपयोग गोल और फ़्लोटिंग-पॉइंट त्रुटियों को और खत्म कर सकता है, खासकर यदि आप बहुत कम अवधि माप रहे हैं, या आपका एप्लिकेशन (या विंडोज मशीन) लंबे समय से चल रहा है।





elapsed