पायथन

Question

में टाइमर टिक प्राप्त करें मैं बस कोड का एक टुकड़ा समय की कोशिश कर रहा हूं। छद्म कोड जैसा दिखता है:

start = get_ticks() 
do_long_code() 
print "It took " + (get_ticks() - start) + " seconds." 

यह पायथन में कैसा दिखता है?

अधिक विशेष रूप से, मैं मध्यरात्रि के बाद से टिकों की संख्या कैसे प्राप्त करूं (या फिर पाइथन उस समय का आयोजन करता है)?

import time 
start = time.time() 
do_long_code() 
print "it took", time.time() - start, "seconds." 

आप हालांकि अधिक विकल्पों के लिए timeit मॉड्यूल का उपयोग कर सकते हैं:

Answer 1

time मॉड्यूल में, वहाँ दो समय कार्य हैं। time आपको "दीवार" समय देता है, अगर यह आपकी परवाह करता है।

हालांकि, पाइथन docs का कहना है कि clock का उपयोग बेंचमार्किंग के लिए किया जाना चाहिए। ध्यान दें कि clock अलग प्रणालियों के विभिन्न बर्ताव करता है:

एमएस विंडोज पर
• , यह "संकल्प आम तौर पर एक माइक्रोसेकंड की तुलना में बेहतर" के साथ, Win32 समारोह QueryPerformanceCounter() का उपयोग करता है। इसका कोई विशेष अर्थ नहीं है, यह केवल एक संख्या है (यह पहली बार गिनती शुरू करता है जब आप अपनी प्रक्रिया में clock पर कॉल करते हैं)।

 
    # ms windows 
    t0= time.clock() 
    do_something() 
    t= time.clock() - t0 # t is wall seconds elapsed (floating point) 

* nix पर
• , clock रिपोर्ट CPU समय। अब, यह अलग है, और संभवतः वह मूल्य जो आप चाहते हैं, क्योंकि आपका प्रोग्राम शायद ही कभी सीपीयू समय का अनुरोध करने वाली एकमात्र प्रक्रिया है (भले ही आपके पास कोई अन्य प्रक्रिया न हो, कर्नेल अब CPU समय का उपयोग करता है)। तो, यह संख्या है, जो आम तौर पर दीवार समय की तुलना में smaller¹ है (यानी time.time() - t0), और अधिक सार्थक है जब कोड बेंचमार्किंग:

 
    # linux 
    t0= time.clock() 
    do_something() 
    t= time.clock() - t0 # t is CPU seconds elapsed (floating point) 

सब से

अलावा, timeit मॉड्यूल है Timer कक्षा जो उपलब्ध कार्यक्षमता से बेंचमार्किंग के लिए सबसे अच्छी है का उपयोग करने के लिए माना जाता है।

¹ जब तक सूत्रण रास्ते में हो जाता है ...

² अजगर ≥3.3: वहाँ time.perf_counter() and time.process_time() हैं। perf_counter का उपयोग timeit मॉड्यूल द्वारा किया जा रहा है।

class Timer: 
    def __enter__(self): 
     self.begin = now() 

    def __exit__(self, type, value, traceback): 
     print(format_delta(self.begin, now())) 

आप इस तरह उपयोग (आप अजगर 2.5 कम से कम जरूरत है):

with Timer(): 
    do_long_code() 

जब आपके कोड समाप्त होने पर, टाइमर स्वचालित रूप से बाहर प्रिंट

Answer 2

आपको क्या चाहिए time मॉड्यूल से time() कार्य है।

Answer 3

import datetime 

start = datetime.datetime.now() 
do_long_code() 
finish = datetime.datetime.now() 
delta = finish - start 
print delta.seconds 

आधी रात से

: आप घड़ी() फ़ंक्शन, जो एक चल बिन्दु के रूप में सेकंड में समय रिटर्न के लिए पहुँच

import datetime 

midnight = datetime.datetime.now().replace(hour=0, minute=0, second=0, microsecond=0) 
now = datetime.datetime.now() 
delta = now - midnight 
print delta.seconds 

Answer 4

time module अजगर में देता है।

विभिन्न प्रणालियों में उनके आंतरिक घड़ी सेटअप (प्रति सेकंड टिक) के आधार पर अलग-अलग सटीकता होगी, लेकिन आमतौर पर यह कम से कम 20 मिलीसेकंड के तहत होती है, और कुछ मामलों में कुछ माइक्रोसेकंड से बेहतर होती है। time और clock:

-Adam

Answer 5

यहाँ एक समाधान है कि मैं हाल ही में उपयोग शुरू कर दिया है रन टाइम मिठाई! अगर मैं पाइथन इंटरप्रेटर में कुछ जल्दी से बेंच करने की कोशिश कर रहा हूं, तो यह जाने का सबसे आसान तरीका है।

और यहां 'अब' और 'format_delta' का नमूना कार्यान्वयन है, हालांकि आपका पसंदीदा समय और स्वरूपण विधि का उपयोग करने में संकोच न करें।

import datetime 

def now(): 
    return datetime.datetime.now() 

# Prints one of the following formats*: 
# 1.58 days 
# 2.98 hours 
# 9.28 minutes # Not actually added yet, oops. 
# 5.60 seconds 
# 790 milliseconds 
# *Except I prefer abbreviated formats, so I print d,h,m,s, or ms. 
def format_delta(start,end): 

    # Time in microseconds 
    one_day = 86400000000 
    one_hour = 3600000000 
    one_second = 1000000 
    one_millisecond = 1000 

    delta = end - start 

    build_time_us = delta.microseconds + delta.seconds * one_second + delta.days * one_day 

    days = 0 
    while build_time_us > one_day: 
     build_time_us -= one_day 
     days += 1 

    if days > 0: 
     time_str = "%.2fd" % (days + build_time_us/float(one_day)) 
    else: 
     hours = 0 
     while build_time_us > one_hour: 
      build_time_us -= one_hour 
      hours += 1 
     if hours > 0: 
      time_str = "%.2fh" % (hours + build_time_us/float(one_hour)) 
     else: 
      seconds = 0 
      while build_time_us > one_second: 
       build_time_us -= one_second 
       seconds += 1 
      if seconds > 0: 
       time_str = "%.2fs" % (seconds + build_time_us/float(one_second)) 
      else: 
       ms = 0 
       while build_time_us > one_millisecond: 
        build_time_us -= one_millisecond 
        ms += 1 
       time_str = "%.2fms" % (ms + build_time_us/float(one_millisecond)) 
    return time_str 

करें यदि आप एक पसंदीदा स्वरूपण विधि है मुझे पता है, या जाने वहाँ यह सब करने के लिए एक आसान तरीका है!

Answer 6

आप कई बयानों आप समय करना चाहते है, तो आप कुछ इस तरह इस्तेमाल कर सकते हैं:

tick = Ticker() 
# first command 
print('first took {}ms'.format(tick()) 
# second group of commands 
print('second took {}ms'.format(tick()) 
# third group of commands 
print('third took {}ms'.format(tick()) 

इस तरह आप की जरूरत नहीं है:

class Ticker: 
    def __init__(self): 
     self.t = clock() 

    def __call__(self): 
     dt = clock() - self.t 
     self.t = clock() 
     return 1000 * dt 

फिर अपने कोड की तरह लग सकता है प्रत्येक ब्लॉक और 1000 * (time() - t) से पहले t = time() टाइप करें, फिर भी स्वरूपण पर नियंत्रण रखें (हालांकि आप आसानी से इसे Ticket में भी डाल सकते हैं)।

यह न्यूनतम लाभ है, लेकिन मुझे लगता है कि यह सुविधाजनक है।