अजगर में कोड की लाइनों के बीच समय को कैसे मापें?

Question

तो जावा में, हम निष्पादित करने के लिए एक फ़ंक्शन द्वारा उठाए गए समय को मापने के लिए कैसे कर सकते हैं

लेकिन यह अजगर में कैसे किया जाता है? कोड की लाइनों के बीच समय शुरू और अंत समय को मापने के लिए? कुछ ऐसा करता है:

import some_time_library

starttime = some_time_library.some_module()
code_tobe_measured() 
endtime = some_time_library.some_module()

time_taken = endtime - starttime

Answer 1

यदि आप CPU समय को मापना चाहते हैं time.process_time(), तो Python 3.3 और इसके बाद के संस्करण के लिए उपयोग कर सकते हैं :

import time
start = time.process_time()
# your code here    
print(time.process_time() - start)

पहला कॉल टाइमर को चालू करता है, और दूसरा कॉल आपको बताता है कि कितने सेकंड बीत चुके हैं।

एक फ़ंक्शन भी है time.clock(), लेकिन इसे पायथन 3.3 के बाद से हटा दिया गया है और इसे पायथन 3.8 में हटा दिया जाएगा।

बेहतर प्रोफाइलिंग टूल हैं जैसे timeitऔर profile, हालांकि time.process_time () CPU समय को मापेगा और यही आप के बारे में पूछ रहे हैं।

यदि आप इसके बजाय दीवार घड़ी समय को मापना चाहते हैं, तो उपयोग करें time.time()।

Comments

यह वह नहीं है जिसका आप उपयोग करते हैं time.clock(), और time.clock()यूनिक्स पर सीपीयू समय को मापते हैं लेकिन विंडोज पर दीवार समय यह उपयोग करना बेहतर है time.time()जहां व्यवहार ओएस के साथ भिन्न नहीं होता है। stackoverflow.com/questions/85451/…

— टिम

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

— येवगेन यमपोलस्की

Time.time () के बारे में एक बहुत बुरी बात यह है कि यह समय sunchronization ntpdate आदि से प्रभावित है। मैं कहूंगा कि time.clock () इस वजह से एकमात्र विश्वसनीय विकल्प होगा

— www.jensolsson.se

DeprecationWarning: time.clock has been deprecated in Python 3.3 and will be removed from Python 3.8: use time.perf_counter or time.process_time instead

— ०६:५५ पर ०६

हम्मम ... मुझे यकीन नहीं है कि मैं क्या गलत कर रहा हूं। मैंने प्रतिस्थापित # your code hereकिया time.sleep(10)और 0.0 सेकंड मिले। for i in range(10000):/passउसी परिणाम को जोड़ना । किसी भी परिस्थिति में मैंने कोशिश की, time.process_time()हमेशा एक ही नंबर देता है। time.perf_counter()हालांकि मुझे उम्मीद है कि परिणाम का उपयोग कर

— biscuit314

Answer 2

आप timeपुस्तकालय का उपयोग भी कर सकते हैं :

import time

start = time.time()

# your code

# end

print(f'Time: {time.time() - start}')

Comments

@ हयात - यह विधि यूटीसी में, युग के बाद से सेकंड में व्यक्त फ्लोटिंग पॉइंट संख्या के रूप में समय लौटाती है। [ docs.python.org/3/library/time.html]

— सूत्रधार

@AnumoySutradhar वास्तव में नहीं है, क्योंकि यह एक युग से एक युग का स्थान ले रहा है, आपको दो समय के बीच का अंतर मिलता है।

— नास्ता

Answer 3

एक छोटी सुविधा वर्ग की मदद से, आप इस तरह से इंडेंटेड लाइनों में बिताए गए समय को माप सकते हैं :

with CodeTimer():
   line_to_measure()
   another_line()
   # etc...

जो इंडेंटेड लाइन को अंजाम देने के बाद निम्नलिखित दिखाएगा:

Code block took: x.xxx ms

अद्यतन: आप अब pip install linetimerऔर फिर के साथ वर्ग प्राप्त कर सकते हैं from linetimer import CodeTimer। इस GitHub परियोजना को देखें ।

उपरोक्त वर्ग के लिए कोड:

import timeit

class CodeTimer:
    def __init__(self, name=None):
        self.name = " '"  + name + "'" if name else ''

    def __enter__(self):
        self.start = timeit.default_timer()

    def __exit__(self, exc_type, exc_value, traceback):
        self.took = (timeit.default_timer() - self.start) * 1000.0
        print('Code block' + self.name + ' took: ' + str(self.took) + ' ms')

आप तब कोड ब्लॉकों को नाम दे सकते हैं जिन्हें आप मापना चाहते हैं:

with CodeTimer('loop 1'):
   for i in range(100000):
      pass

with CodeTimer('loop 2'):
   for i in range(100000):
      pass

Code block 'loop 1' took: 4.991 ms
Code block 'loop 2' took: 3.666 ms

और उन्हें घोंसला दें:

with CodeTimer('Outer'):
   for i in range(100000):
      pass

   with CodeTimer('Inner'):
      for i in range(100000):
         pass

   for i in range(100000):
      pass

Code block 'Inner' took: 2.382 ms
Code block 'Outer' took: 10.466 ms

इसके संबंध में timeit.default_timer(), यह ओएस और पायथन संस्करण पर आधारित सर्वश्रेष्ठ टाइमर का उपयोग करता है, इस उत्तर को देखें ।

Answer 4

मैं हमेशा समय, मिनट और सेकंड (% H:% M:% S) प्रारूप में समय की जांच करना पसंद करता हूं:

from datetime import datetime
start = datetime.now()
# your code
end = datetime.now()
time_taken = end - start
print('Time: ',time_taken) 

उत्पादन:

Time:  0:00:00.000019

Answer 5

मैं एक तरीका खोज रहा था कि कैसे न्यूनतम कोड के साथ एक स्वरूपित समय का उत्पादन किया जाए, इसलिए यहां मेरा समाधान है। बहुत से लोग वैसे भी पंडों का उपयोग करते हैं, इसलिए कुछ मामलों में यह अतिरिक्त पुस्तकालय आयात से बचा सकता है।

import pandas as pd
start = pd.Timestamp.now()
# code
print(pd.Timestamp.now()-start)

आउटपुट:

0 days 00:05:32.541600

मैं इसका उपयोग करने की सलाह दूंगा यदि समय सटीक सबसे महत्वपूर्ण नहीं है, अन्यथा timeपुस्तकालय का उपयोग करें :

%timeit pd.Timestamp.now() आउटपुट 3.29 3.s 4 214 ns प्रति लूप

%timeit time.time() प्रति पाश 154 एनएम 154 13.3 एनएस आउटपुट

Answer 6

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

सबसे पहले, timerडेकोरेटर को परिभाषित करें :

import functools
import time

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.perf_counter()
        value = func(*args, **kwargs)
        end_time = time.perf_counter()
        run_time = end_time - start_time
        print("Finished {} in {} secs".format(repr(func.__name__), round(run_time, 3)))
        return value

    return wrapper

फिर, फ़ंक्शन को परिभाषित करते समय डेकोरेटर का उपयोग करें:

@timer
def doubled_and_add(num):
    res = sum([i*2 for i in range(num)])
    print("Result : {}".format(res))

कोशिश करते हैं:

doubled_and_add(100000)
doubled_and_add(1000000)

आउटपुट:

Result : 9999900000
Finished 'doubled_and_add' in 0.0119 secs
Result : 999999000000
Finished 'doubled_and_add' in 0.0897 secs

नोट: मुझे यकीन है कि क्यों उपयोग करने के लिए नहीं कर रहा हूँ time.perf_counterके बजाय time.time। टिप्पणियों का स्वागत है।

Answer 7

आप इसे भी आजमा सकते हैं:

from time import perf_counter

t0 = perf_counter()

...

t1 = perf_counter()
time_taken = t1 - t0