সময় মডিউল দিয়ে অতিবাহিত সময় পরিমাপ করা

Question

পাইথনে টাইম মডিউলটি দিয়ে কি অতিবাহিত সময় পরিমাপ করা সম্ভব? যদি তা হয় তবে আমি কীভাবে করব?

আমার এটি করা দরকার যাতে কার্সার যদি একটি নির্দিষ্ট সময়ের জন্য একটি উইজেটে থাকে তবে একটি ঘটনা ঘটে।

Comments

এনবি যে কোনও উত্তর ব্যবহার করে time.time()ভুল। সবচেয়ে সহজ উদাহরণটি যদি পরিমাপের সময়কালে সিস্টেমের সময় পরিবর্তন হয়।

— অরেঞ্জডগ

কোনও ইভেন্টে গুলি চালানোর বিষয়ে আপনার আসল প্রশ্নের জন্য যদি কোনও কার্সার একটি উইজেটের নির্দিষ্ট সময়কালের জন্য থাকে, ডকস.পিথথন.আর / 3 / লাইবারি / থ্রেডিং এইচটিএমএল আপনার প্রয়োজনীয় সমস্ত সরবরাহ করে, আমি মনে করি। মাল্টিথ্রেডিং এবং সময়সীমা সহ শর্তের পরিবর্তনশীল সমাধানগুলির মধ্যে একটি হতে পারে। আপনার পরিস্থিতি অবশ্য উত্তর দেওয়ার ক্ষেত্রে অস্পষ্ট।

— তোরা

time.time()আধুনিক অজগর (ম্যানুয়াল পরিবর্তনগুলি, প্রবাহিত, লিপ সেকেন্ড ইত্যাদি দ্বারা প্রভাবিত) এর অতিবাহিত সময় পরিমাপ করার জন্য কারও ব্যবহার করা উচিত নয় এমন কোনও কারণ নেই । নীচের এই উত্তরটি আরও বেশি হওয়া দরকার, এই প্রশ্নটি বিবেচনা করে অতিবাহিত সময় পরিমাপের জন্য এখন গুগলে শীর্ষ ফলাফল।

— এনপ্রাস

আপনি ভাল হিসাবে cProfile প্রোফাইলার সঙ্গে সময় পরিমাপ করতে পারেন: docs.python.org/3/library/profile.html#module-cProfile stackoverflow.com/questions/582336/...

— আন্তন Tarasenko

@ এনপ্রাস "আধুনিক অজগর" ভুলে গেছেন। এটি ব্যবহার করা সর্বদা ভুল ছিল time.time()।

— অরেঞ্জডোগ

Answer 1

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(...):
    ...

আপনি একই সাথে আরও একটি ফাংশন প্রোফাইল করতে পারেন। তারপরে পরিমাপগুলি মুদ্রণের জন্য কেবল মুদ্রণ_প্রেম_ডেটা () কল করুন:

Comments

আপনি প্রোফাইল হুকস pip install profilehooks এবং এর হোমপেজটি এখানে দেখতে পারেন

— পাইজামা

দ্রষ্টব্য যে পাইথন ৩.৩ থেকে সময়সীমা বা সময়কাল পরিমাপ করার সময় সম্ভবত তার time.monotonic()পরিবর্তে ব্যবহার করা উচিত time.time()। docs.python.org/3/library/time.html#time.monotonic

— দেবিলেস্কি

এখানে যুক্ত / উল্লেখযোগ্য যে অতিবাহিত সময়ের জন্য পরিমাপের এককটি সেকেন্ড হবে।

— এরিক ক্র্যামার

@ এরিকক্রার আপনাকে ধন্যবাদ! আমার বিশাল পোষা প্রাণী, পরিমাপের এককটি নির্ধারণ না করে পরিমাপের ব্যাখ্যা। এবং। নেট হিসাবে প্রথমবার পাইথনে পা আঙ্গুল দিয়ে, আমি স্বয়ংক্রিয়ভাবে "মিলিসেকেন্ড" ভেবেছিলাম।

— অ্যাডাম প্লোচার

(ঘ।) সিস্টেমের ঘড়িটি পরিবর্তিত হলে, এবং সাবসেকেন্ড রেজোলিউশন নাও পেতে পারে। সঠিক উত্তর: stackoverflow.com/a/47637891/476716

— OrangeDog

Answer 2

time.time() কাজ করবে

import time

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

elapsed = end - start

আপনি এই প্রশ্নটি দেখতে চাইতে পারেন , তবে আমার মনে হয় না এটি প্রয়োজনীয় হবে।

Comments

হ্যাঁ, সময়টি সেকেন্ডের মধ্যে রয়েছে

— এরিক ক্রামার

আপনার শুরু_সময়ের সময় পরিবর্তন করা উচিত।

— জোড়ান পান্ডভস্কি

time.time()একটি খারাপ ধারণা কারণ সিস্টেম ঘড়িটি পুনরায় সেট করা যেতে পারে যা আপনাকে সময়মতো ফিরে যেতে বাধ্য করবে। time.monotonic()এটির যত্ন নেয় (একঘেয়ে = এটি কেবল এগিয়ে যায়)। time.perf_counter()এছাড়াও মনোোটোনিক তবে এর চেয়েও উচ্চতর নির্ভুলতা রয়েছে, সুতরাং এটি প্রাচীর-ঘড়ির জন্য প্রস্তাবিত।

— এক্সজেসিএল

Answer 3

যে ব্যবহারকারীরা আরও ভাল ফর্ম্যাট করতে চান তাদের জন্য,

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) 

স্ট্রফটাইম ডকুমেন্টেশন

Comments

আপনার উত্তরের জন্য আপনাকে ধন্যবাদ, যা আমাকে অনুপ্রাণিত করে। আমি e = time.time() - start_time ; print("%02d:%02d:%02d" % (e // 3600, (e % 3600 // 60), (e % 60 // 1)))প্রায় একই ফলনটি ব্যবহার করতে যাচ্ছি এবং 24 ঘন্টােরও বেশি সময় কেটে যাওয়া পরিস্থিতিটি coveringেকে রাখছি।

— তোরা

@ তোরা আপনি ভবিষ্যতের সামঞ্জস্যতা সমস্যাগুলির জন্য% 02d এর পরিবর্তে "{}" ফর্ম্যাট () দেখতে চাইতে পারেন।

— রাটার হাফস্টে

ধন্যবাদ! এখন আমি নতুনটির সাথে অভ্যস্ত হয়ে যাচ্ছি। '{: 02d}: {: 02d}: {: 02d}'। ফর্ম্যাট (ই // 3600, (ই% 3600 // 60), ই% 60)

— তোরা

আপনি time.monotonic()অন্যান্য উত্তর হিসাবে ব্যবহার করতে পারেন ?

— এন্ডোলিথ

elapsed.secondsসময়কাল এক দিনের চেয়ে বেশি হলে ভুল হবে। আপনি elapsed.total_seconds()নমনীয় হতে চান

— অ্যাশ বার্লিন-টেলর

Answer 4

অতিবাহিত সময়ের সেরা পরিমাপের জন্য (পাইথন ৩.৩ থেকে) ব্যবহার করুন time.perf_counter()।

পারফরম্যান্স কাউন্টারটির মান (ভগ্নাংশের সেকেন্ডে), অর্থাত্ একটি স্বল্প সময়কাল পরিমাপের জন্য সর্বোচ্চ উপলব্ধ রেজোলিউশন সহ একটি ঘড়ি Return এটি ঘুমের সময় অতিবাহিত সময় অন্তর্ভুক্ত করে না এবং এটি সিস্টেম-ব্যাপী। প্রত্যাশিত মানের রেফারেন্স পয়েন্টটি অপরিজ্ঞাত, যাতে কেবলমাত্র পরপর কলগুলির ফলাফলের মধ্যে পার্থক্য বৈধ থাকে।

ঘন্টা / দিনের ক্রম অনুসারে পরিমাপের জন্য, আপনি সাব-সেকেন্ড রেজোলিউশনটির বিষয়ে চিন্তা করেন না তাই time.monotonic()পরিবর্তে ব্যবহার করুন।

একঘেয়ে ঘড়ির মান (ভগ্নাংশের সেকেন্ডে), অর্থাত্ একটি ঘড়ি যা পিছনে যেতে পারে না Return ঘড়ি সিস্টেম ঘড়ির আপডেট দ্বারা প্রভাবিত হয় না। প্রত্যাশিত মানের রেফারেন্স পয়েন্টটি অপরিজ্ঞাত, যাতে কেবলমাত্র পরপর কলগুলির ফলাফলের মধ্যে পার্থক্য বৈধ থাকে।

অনেক বাস্তবায়নে এগুলি আসলে একই জিনিস হতে পারে।

3.3 এর আগে, আপনি আটকে গেছেন time.clock()।

ইউনিক্সে, সেকেন্ডে প্রকাশিত ভাসমান পয়েন্ট সংখ্যা হিসাবে বর্তমান প্রসেসরের সময়টি ফিরুন। যথার্থতা এবং প্রকৃতপক্ষে "প্রসেসরের সময়" এর অর্থের খুব সংজ্ঞা, একই নামের সি ফাংশনের উপর নির্ভর করে।

উইন্ডোজে, উইন 32 ফাংশন কোয়েরি পারফরম্যান্স কাউন্টার () এর উপর ভিত্তি করে এই ফাংশনটি প্রথম কল করার পরে ভাসমান পয়েন্ট সংখ্যা হিসাবে এই ফাংশনটির প্রথম কল হওয়ার পরে অবধি প্রাচীর-ঘড়ির সেকেন্ড ফিরে আসে। রেজোলিউশনটি সাধারণত একটি মাইক্রোসেকেন্ডের চেয়ে ভাল।

---

পাইথন ৩.7 এর জন্য আপডেট

পাইথন 3.7-এ নতুন হল পিইপি 564 - ন্যানোসেকেন্ড রেজোলিউশনের সাথে নতুন সময় ফাংশন যুক্ত করুন।

এগুলির ব্যবহারটি বৃত্তাকার এবং ভাসমান-পয়েন্ট ত্রুটিগুলি আরও দূর করতে পারে, বিশেষত যদি আপনি খুব স্বল্প সময়সীমার পরিমাপ করছেন বা আপনার অ্যাপ্লিকেশন (বা উইন্ডোজ মেশিন) দীর্ঘস্থায়ী।

perf_counter()প্রায় 100 দিন পরে রেজুলেশন ভেঙে যেতে শুরু করে । উদাহরণস্বরূপ, আপটাইম এক বছর পরে, সংক্ষিপ্ত বিরতি (0 এর চেয়ে বেশি) এটি পরিমাপ করতে পারে এটি শুরু হওয়ার চেয়ে বড় হবে।

---

পাইথন ৩.৮ এর জন্য আপডেট

time.clock এখন চলে গেছে।

Comments

"অনেকগুলি বাস্তবায়নে এগুলি আসলে একই জিনিস হতে পারে।" সত্য, আমার লিনাক্স মিন্ট পিসিতে টাইম.মোনোটোনিক () এবং সময়.perf_counter () অভিন্ন মানগুলি ফেরত বলে মনে হচ্ছে।

— এক্সজেসিএল

Answer 5

দীর্ঘ সময়ের জন্য।

import time
start_time = time.time()
...
e = int(time.time() - start_time)
print('{:02d}:{:02d}:{:02d}'.format(e // 3600, (e % 3600 // 60), e % 60))

মুদ্রণ হবে

00:03:15

24 ঘন্টা বেশি হলে

25:33:57

যা রাজার হাফস্টের উত্তর দ্বারা অনুপ্রাণিত হয়। আপনাকে ধন্যবাদ রাটার!

Answer 6

আপনার সময়কে আমদানি করতে হবে এবং তারপরে বর্তমান সময়টি জানতে সময়.টাইম () পদ্ধতি ব্যবহার করতে হবে।

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 

Answer 7

সময়ের জিনিসগুলির আরেকটি সুন্দর উপায় হ'ল পাইথন স্ট্রাকচার সহ এটি ব্যবহার করা ।

স্ট্রাকচার সহ স্বয়ংক্রিয়ভাবে __enter__ এবং __exit__ পদ্ধতিগুলি কল করা হচ্ছে যা আমাদের সময় ঠিক করার জন্য প্রয়োজন।

আসুন একটি টাইমার ক্লাস তৈরি করা যাক ।

from time import time

class Timer():
    def __init__(self, message):
        self.message = message
    def __enter__(self):
        self.start = time()
        return None  # could return anything, to be used like this: with Timer("Message") as value:
    def __exit__(self, type, value, traceback):
        elapsed_time = (time() - self.start) * 1000
        print(self.message.format(elapsed_time))

তারপরে, কেউ টাইমার শ্রেণিটি এর মতো ব্যবহার করতে পারেন:

with Timer("Elapsed time to compute some prime numbers: {}ms"):
    primes = []
    for x in range(2, 500):
        if not any(x % p == 0 for p in primes):
            primes.append(x)
    print("Primes: {}".format(primes))

ফলাফল নিম্নলিখিত:

পুরষ্কার: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89 , 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227 , 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373 , 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 459, 457, 461, 463, 467, 479, 487, 491, 499]

কিছু প্রাথমিক সংখ্যা গণনা করার জন্য সময় অতিবাহিত হয়েছে: 5.01704216003418ms

Answer 8

ভাদিম শেন্ডার প্রতিক্রিয়া দুর্দান্ত। আপনি নীচের মতো একটি সাধারণ সাজসজ্জা ব্যবহার করতে পারেন:

import datetime
def calc_timing(original_function):                            
    def new_function(*args,**kwargs):                        
        start = datetime.datetime.now()                     
        x = original_function(*args,**kwargs)                
        elapsed = datetime.datetime.now()                      
        print("Elapsed Time = {0}".format(elapsed-start))     
        return x                                             
    return new_function()  

@calc_timing
def a_func(*variables):
    print("do something big!")

Answer 9

প্রোগ্রামিংয়ে, বিভিন্ন ফলাফল সহ সময় মাপার জন্য দুটি প্রধান উপায় রয়েছে :

>>> print(time.process_time()); time.sleep(10); print(time.process_time())
0.11751394000000001
0.11764988400000001  # took  0 seconds and a bit
>>> print(time.perf_counter()); time.sleep(10); print(time.perf_counter())
3972.465770326
3982.468109075       # took 10 seconds and a bit

• প্রসেসরের সময় : এই নির্দিষ্ট প্রক্রিয়াটি কতক্ষণ সক্রিয়ভাবে সিপিইউতে সম্পাদন করতে ব্যয় করে। ঘুম, ওয়েব অনুরোধের জন্য অপেক্ষা করা, বা কেবল যখন অন্য প্রক্রিয়াগুলি সম্পাদন করা হয় তখন এটি এতে অবদান রাখবে না।

  • ব্যবহার time.process_time()

• ওয়াল-ক্লকের সময় : এটি "দেয়ালের সাথে ঝুলন্ত একটি ঘড়ির উপরে" অর্থাৎ বাস্তব সময়ের বাইরে কতটা সময় কেটে গেছে তার বোঝায়।

  • ব্যবহার time.perf_counter()

    • time.time() প্রাচীর-ঘড়ির সময়ও পরিমাপ করে তবে পুনরায় সেট করা যায়, যাতে আপনি সময়মতো ফিরে যেতে পারেন
    • time.monotonic() পুনরায় সেট করা যায় না (একঘেয়েমি = কেবল এগিয়ে যায়) তবে এর চেয়ে কম নির্ভুলতা রয়েছে time.perf_counter()

Answer 10

এখানে টেবুলার আউটপুট সহ ভাদিম শেন্দারের চতুর কোডটির একটি আপডেট রয়েছে:

import collections
import time
from functools import wraps

PROF_DATA = collections.defaultdict(list)

def profile(fn):
    @wraps(fn)
    def with_profiling(*args, **kwargs):
        start_time = time.time()
        ret = fn(*args, **kwargs)
        elapsed_time = time.time() - start_time
        PROF_DATA[fn.__name__].append(elapsed_time)
        return ret
    return with_profiling

Metrics = collections.namedtuple("Metrics", "sum_time num_calls min_time max_time avg_time fname")

def print_profile_data():
    results = []
    for fname, elapsed_times in PROF_DATA.items():
        num_calls = len(elapsed_times)
        min_time = min(elapsed_times)
        max_time = max(elapsed_times)
        sum_time = sum(elapsed_times)
        avg_time = sum_time / num_calls
        metrics = Metrics(sum_time, num_calls, min_time, max_time, avg_time, fname)
        results.append(metrics)
    total_time = sum([m.sum_time for m in results])
    print("\t".join(["Percent", "Sum", "Calls", "Min", "Max", "Mean", "Function"]))
    for m in sorted(results, reverse=True):
        print("%.1f\t%.3f\t%d\t%.3f\t%.3f\t%.3f\t%s" % (100 * m.sum_time / total_time, m.sum_time, m.num_calls, m.min_time, m.max_time, m.avg_time, m.fname))
    print("%.3f Total Time" % total_time)