আমি যা চাই তা হ'ল আমার কোডের কোথাও সময় গণনা শুরু করা এবং তারপরে অতিক্রান্ত সময়টি পাওয়া, কয়েকটি ফাংশন সম্পাদন করতে যে সময় লাগে তা পরিমাপ করতে। আমি মনে করি আমি টাইমিট মডিউলটি ভুল ব্যবহার করছি তবে ডক্সটি আমার জন্য কেবল বিভ্রান্ত করছে।
import timeit
start = timeit.timeit()
print("hello")
end = timeit.timeit()
print(end - start)উত্তর:
আপনি যদি কেবল দুটি পয়েন্টের মধ্যে অবরুদ্ধ প্রাচীর-ঘড়ির সময়টি পরিমাপ করতে চান তবে আপনি এটি ব্যবহার করতে পারেন time.time():
import time
start = time.time()
print("hello")
end = time.time()
print(end - start)এটি সেকেন্ডে মৃত্যুদন্ড কার্যকর করার সময় দেয়।
৩.৩ এর পরের আর একটি বিকল্প আপনার প্রয়োজনের উপর নির্ভর করে ব্যবহার করা perf_counterবা হতে পারে process_time। 3.3 এর আগে এটি ব্যবহার করার জন্য প্রস্তাব দেওয়া হয়েছিল time.clock(ধন্যবাদ অ্যাম্বার )। তবে এটি বর্তমানে অবচয় করা হয়েছে:
ইউনিক্সে, সেকেন্ডে প্রকাশিত ভাসমান পয়েন্ট সংখ্যা হিসাবে বর্তমান প্রসেসরের সময়টি ফিরুন। যথার্থতা এবং প্রকৃতপক্ষে "প্রসেসরের সময়" এর অর্থের খুব সংজ্ঞা, একই নামের সি ফাংশনের উপর নির্ভর করে।
উইন্ডোজে, এই ফাংশনটি উইন 32 ফাংশনের উপর ভিত্তি করে একটি ফ্লোটিং পয়েন্ট নম্বর হিসাবে এই ফাংশনটিতে প্রথম কল করার পরে প্রাচীর-ঘড়ির সেকেন্ডগুলি কেটে যায়
QueryPerformanceCounter()। রেজোলিউশনটি সাধারণত একটি মাইক্রোসেকেন্ডের চেয়ে ভাল।সংস্করণ ৩.৩ থেকে অবহেলিত : এই ফাংশনের আচরণটি প্ল্যাটফর্মের উপর নির্ভর করে: আপনার প্রয়োজনীয়তার উপর নির্ভর করে একটি ভাল সংজ্ঞায়িত আচরণ করতে ব্যবহার করুন
perf_counter()বাprocess_time()তার পরিবর্তে ।
time.clock()আসলে পছন্দসই, যেহেতু এটির সাথে হস্তক্ষেপ করা যায় না যদি সিস্টেমের ঘড়িটি গোলমাল হয়ে যায় তবে .time()বেশিরভাগ একই উদ্দেশ্যটি সম্পাদন করে))
print(timedelta(seconds=execution_time))। যদিও এটি আলাদা প্রশ্ন।
timeit.default_timerপরিবর্তে ব্যবহার করুন timeit.timeit। প্রাক্তনটি আপনার প্ল্যাটফর্ম এবং পাইথনের সংস্করণে স্বয়ংক্রিয়ভাবে উপলব্ধ সেরা ঘড়ি সরবরাহ করে:
from timeit import default_timer as timer
start = timer()
# ...
end = timer()
print(end - start) # Time in seconds, e.g. 5.38091952400282timeit.default_timer OS এর উপর নির্ভর করে সময়.টাইম () বা টাইমক্লক () নির্ধারিত হয়। পাইথন উপর 3.3+ default_timer হয় time.perf_counter () সব প্ল্যাটফর্মে। দেখুন পাইথন - time.clock () বনাম time.time () - সঠিকতা?
আরো দেখুন:
default_timer() measurations can be affected by other programs running on the same machine, so the best thing to do when accurate timing is necessary is to repeat the timing a few times and use the best time. The -r option is good for this; the default of 3 repetitions is probably enough in most cases. On Unix, you can use time.clock() to measure CPU time.
perfমডিউল (উত্তরের সময়ে অস্তিত্বহীন) এর প্রতিও আগ্রহী হতে পারেন তবে timeitকীভাবে সময়ের কার্যকারিতা পরিমাপ করা যায় সে সম্পর্কে মডিউলের সিদ্ধান্ত থেকে এটি কখনও কখনও আলাদা হয় ।
যেহেতু টাইমক্লক () পাইথন ৩.৩ হিসাবে অবহিত করা হয়েছে , আপনি time.perf_counter()সিস্টেম-ওয়াইড টাইমিংয়ের জন্য, বা time.process_time()প্রক্রিয়া-ওয়াইড টাইমিংয়ের জন্য, যেভাবে আপনি ব্যবহার করেছেন time.clock():
import time
t = time.process_time()
#do some stuff
elapsed_time = time.process_time() - tনতুন কার্যক্রমে process_timeঘুমের সময় অতিবাহিত সময় অন্তর্ভুক্ত করা হবে না।
timeit.default_timerপরিবর্তে ব্যবহার করুনtime.perf_counter । প্রাক্তন আপনার প্ল্যাটফর্ম এবং পাইথন সংস্করণে সুরক্ষিত সময়ের পারফরম্যান্স পরিমাপ করতে উপযুক্ত টাইমারটি বেছে নেবেন। ঘুমের সময়টি অন্তর্ভুক্ত process_time()করে না এবং তাই সময় কাটাতে উপযুক্ত নয়।
আপনি সময় চান এমন একটি ফাংশন দেওয়া হয়েছে,
test.py:
def foo():
# print "hello"
return "hello"ব্যবহারের সবচেয়ে সহজ উপায় timeitহ'ল কমান্ড লাইন থেকে এটি কল করা:
% python -mtimeit -s'import test' 'test.foo()'
1000000 loops, best of 3: 0.254 usec per loopফাংশনগুলির গতির তুলনা করতে time.timeবা time.clock(নিঃসন্দেহে) ব্যবহার করার চেষ্টা করবেন না । তারা বিভ্রান্তিমূলক ফলাফল দিতে পারে ।
পুনশ্চ. আপনি যে ফাংশনটিতে সময় চান তা মুদ্রণ বিবরণী রাখবেন না; অন্যথায় পরিমাপ করা সময়টি টার্মিনালের গতির উপর নির্ভর করবে ।
একটি প্রসঙ্গ-পরিচালক দিয়ে এটি করা মজাদার যা কোনও withব্লকে প্রবেশের পরে স্বয়ংক্রিয়ভাবে শুরুর সময়টিকে মনে রাখে , তারপরে ব্লক প্রস্থান করার সময় শেষ সময়কে হিম করে দেয়। কিছুটা কৌতুকপূর্ণ, আপনি একই প্রসঙ্গ-পরিচালকের ফাংশন থেকে ব্লকের অভ্যন্তরে একটি চলমান সময়-ট্যালি পেতে পারেন।
মূল লাইব্রেরিতে এটি নেই (তবে সম্ভবত হওয়া উচিত)। একবার জায়গা হয়ে গেলে আপনি এই জাতীয় জিনিসগুলি করতে পারেন:
with elapsed_timer() as elapsed:
# some lengthy code
print( "midpoint at %.2f seconds" % elapsed() ) # time so far
# other lengthy code
print( "all done at %.2f seconds" % elapsed() )কৌতুকটি করার জন্য এখানে কনটেক্সট ম্যানেজার কোডটি যথেষ্ট:
from contextlib import contextmanager
from timeit import default_timer
@contextmanager
def elapsed_timer():
start = default_timer()
elapser = lambda: default_timer() - start
yield lambda: elapser()
end = default_timer()
elapser = lambda: end-startএবং কিছু চলমান ডেমো কোড:
import time
with elapsed_timer() as elapsed:
time.sleep(1)
print(elapsed())
time.sleep(2)
print(elapsed())
time.sleep(3)নোট করুন যে এই ফাংশনটির ডিজাইনের দ্বারা, elapsed()ব্লক প্রস্থান করার সময়টির রিটার্নের মান হিমায়িত হয় এবং আরও কলগুলি একই সময়কালে ফিরে আসে (এই খেলনার উদাহরণে প্রায় 6 সেকেন্ডের)।
সেকেন্ডে সময় পরিমাপ :
from timeit import default_timer as timer
from datetime import timedelta
start = timer()
end = timer()
print(timedelta(seconds=end-start))আউটপুট :
0:00:01.946339আমি এই পছন্দ। timeitডক অনেক বেশি বিভ্রান্তিকর।
from datetime import datetime
start_time = datetime.now()
# INSERT YOUR CODE
time_elapsed = datetime.now() - start_time
print('Time elapsed (hh:mm:ss.ms) {}'.format(time_elapsed))দ্রষ্টব্য, এখানে কোনও বিন্যাস চলছে না, আমি hh:mm:ssপ্রিন্টআউটে লিখেছিলাম যাতে কেউ ব্যাখ্যা করতে পারেtime_elapsed
এটি করার আরেকটি উপায় এখানে:
>> from pytictoc import TicToc
>> t = TicToc() # create TicToc instance
>> t.tic() # Start timer
>> # do something
>> t.toc() # Print elapsed time
Elapsed time is 2.612231 seconds.Traditionalতিহ্যগত উপায়ে তুলনা:
>> from time import time
>> t1 = time()
>> # do something
>> t2 = time()
>> elapsed = t2 - t1
>> print('Elapsed time is %f seconds.' % elapsed)
Elapsed time is 2.612231 seconds.স্থাপন:
pip install pytictocআরও বিশদ জানতে পিপিআই পৃষ্ঠাটি দেখুন।
t.tic()কোডটি সমাহিত হয়ে আসি , তবে বিকাশকারী আমার উপর নির্ভর করে যে সিরিজটিতে আমার এটি হওয়ার আশা করা উচিত তার একটি মানসিক তালিকা রাখা উচিত। আপনি কি নিজেকে বাসা বা একাধিক টিকটোক স্থাপন করছেন?
ttictoc। আমার মধ্যে বেশ একটা গণ্ডগোল ছিল, তবে এটি এখন ভাল হওয়া উচিত।
এখানে অনেক ভাল উত্তরের পাশাপাশি কয়েকটি অন্যান্য নিবন্ধের পরে আমার অনুসন্ধানগুলি এখানে রয়েছে।
প্রথমত, যদি আপনি timeitএবং এর মধ্যে বিতর্ক করছেন time.timeতবে timeitএর দুটি সুবিধা রয়েছে:
timeit আপনার ওএস এবং পাইথন সংস্করণে পাওয়া সেরা টাইমার নির্বাচন করে। timeit আবর্জনা সংগ্রহ নিষ্ক্রিয় করে, তবে এটি এমন কিছু নয় যা আপনি চান বা নাও চান।এখন সমস্যাটি হ'ল এটি timeitব্যবহার করা এত সহজ নয় কারণ আপনার একগুচ্ছ আমদানি করার সময় সেটআপ দরকার হয় এবং জিনিসগুলি কুরুচিপূর্ণ হয়। আদর্শভাবে, আপনি কেবল একটি সাজসজ্জা চান বা withব্লক ব্যবহার করুন এবং সময় পরিমাপ করুন। দুর্ভাগ্যক্রমে, এর জন্য বিল্ট-ইন কিছুই উপলভ্য নেই তাই আপনার কাছে দুটি বিকল্প রয়েছে:
বিকল্প 1: টাইমবুড লাইব্রেরি ব্যবহার করুন
Timebudget একটি বহুমুখী এবং খুব সহজ গ্রন্থাগার যে আপনি ইনস্টল পিপ পর কোডের এক লাইন মাত্র ব্যবহার করতে পারেন।
@timebudget # Record how long this function takes
def my_method():
# my codeবিকল্প 2: কোড মডিউলটি সরাসরি ব্যবহার করুন
আমি সামান্য ইউটিলিটি মডিউলটির নীচে তৈরি করেছি।
# utils.py
from functools import wraps
import gc
import timeit
def MeasureTime(f, no_print=False, disable_gc=False):
@wraps(f)
def _wrapper(*args, **kwargs):
gcold = gc.isenabled()
if disable_gc:
gc.disable()
start_time = timeit.default_timer()
try:
result = f(*args, **kwargs)
finally:
elapsed = timeit.default_timer() - start_time
if disable_gc and gcold:
gc.enable()
if not no_print:
print('"{}": {}s'.format(f.__name__, elapsed))
return result
return _wrapper
class MeasureBlockTime:
def __init__(self,name="(block)", no_print=False, disable_gc=False):
self.name = name
self.no_print = no_print
self.disable_gc = disable_gc
def __enter__(self):
self.gcold = gc.isenabled()
if self.disable_gc:
gc.disable()
self.start_time = timeit.default_timer()
def __exit__(self,ty,val,tb):
self.elapsed = timeit.default_timer() - self.start_time
if self.disable_gc and self.gcold:
gc.enable()
if not self.no_print:
print('Function "{}": {}s'.format(self.name, self.elapsed))
return False #re-raise any exceptionsএখন আপনি কেবল কোনও ডেকরেটার সামনে রেখে কোনও ফাংশন সময় করতে পারেন:
import utils
@utils.MeasureTime
def MyBigFunc():
#do something time consuming
for i in range(10000):
print(i)আপনি যদি কোডের অংশ সময় নিতে চান তবে কেবল এটি withব্লকের ভিতরে রাখুন :
import utils
#somewhere in my code
with utils.MeasureBlockTime("MyBlock"):
#do something time consuming
for i in range(10000):
print(i)
# rest of my codeসুবিধাদি:
চারপাশে বেশ কয়েকটি অর্ধ-ব্যাক ভার্সন ভাসমান তাই আমি কয়েকটি হাইলাইট তুলে ধরতে চাই:
with utils.MeasureBlockTime() as tএবং তারপরে t.elapsed)।time.timeকার্যকরকরণ পরিমাপ করতে ব্যবহার করা আপনাকে আপনার কম্পিউটারে অন্যান্য প্রক্রিয়া দ্বারা চালিত সময় সহ আপনার আদেশগুলির সামগ্রিক কার্যকর সময় দেয়। এটি ব্যবহারকারীদের লক্ষ্য করার সময়, তবে আপনি যদি বিভিন্ন কোড স্নিপেট / অ্যালগরিদম / ফাংশন / তুলনা করতে চান তবে ভাল নয় ...
আরও তথ্য timeit:
আপনি যদি প্রোফাইলিংয়ের আরও গভীর অন্তর্দৃষ্টি চান:
আপডেট : আমি গত বছরের বেশিরভাগ সময় http://pythonhosted.org/line_profiler/ ব্যবহার করেছি এবং এটি খুব সহায়ক বলে মনে করি এবং পাইথনসের প্রোফাইল মডিউলটির পরিবর্তে এটি ব্যবহারের পরামর্শ দিই ।
এখানে একটি ছোট টাইমার ক্লাস যা "এইচএইচ: মিমি: এসএস" স্ট্রিংটি ফেরত দেয়:
class Timer:
def __init__(self):
self.start = time.time()
def restart(self):
self.start = time.time()
def get_time_hhmmss(self):
end = time.time()
m, s = divmod(end - self.start, 60)
h, m = divmod(m, 60)
time_str = "%02d:%02d:%02d" % (h, m, s)
return time_strব্যবহার:
# Start timer
my_timer = Timer()
# ... do something
# Get time string:
time_hhmmss = my_timer.get_time_hhmmss()
print("Time elapsed: %s" % time_hhmmss )
# ... use the timer again
my_timer.restart()
# ... do something
# Get time:
time_hhmmss = my_timer.get_time_hhmmss()
# ... etcপাইথন সিপ্রোফাইল এবং pstats মডিউল বিদ্যমান ফাংশনগুলির চারপাশে কোনও কোড যুক্ত না করে নির্দিষ্ট ফাংশনে সময় অতিবাহিত সময় পরিমাপের জন্য দুর্দান্ত সমর্থন সরবরাহ করে।
উদাহরণস্বরূপ যদি আপনার কাছে অজগর স্ক্রিপ্টের সময় রয়েছে ফাংশন.পি:
import time
def hello():
print "Hello :)"
time.sleep(0.1)
def thankyou():
print "Thank you!"
time.sleep(0.05)
for idx in range(10):
hello()
for idx in range(100):
thankyou()প্রোফাইলার চালাতে এবং ফাইলের পরিসংখ্যান উত্পন্ন করতে আপনি কেবল চালাতে পারেন:
python -m cProfile -o timeStats.profile timeFunctions.pyএটি যা করছে তা হ'ল সিফ্রফাইল মডিউলটি টাইমফিউশনস.পি-র সমস্ত ফাংশন প্রোফাইল করতে এবং টাইমস্ট্যাটস.প্রোফাইলে ফাইলের পরিসংখ্যান সংগ্রহ করে। নোট করুন যে আমাদের বিদ্যমান মডিউলে (টাইমফিউশনস.পি) কোনও কোড যুক্ত করতে হয়নি এবং এটি কোনও মডিউল দিয়েই করা যেতে পারে।
আপনার কাছে পরিসংখ্যান ফাইলটি একবার আপনি নীচে pstats মডিউল চালাতে পারেন:
python -m pstats timeStats.profileএটি ইন্টারেক্টিভ পরিসংখ্যান ব্রাউজার চালায় যা আপনাকে প্রচুর সুন্দর কার্যকারিতা দেয়। আপনার নির্দিষ্ট ব্যবহারের ক্ষেত্রে আপনি কেবল আপনার ফাংশনের জন্য পরিসংখ্যান পরীক্ষা করতে পারেন। আমাদের উদাহরণে উভয় ফাংশনের জন্য পরিসংখ্যান পরীক্ষা করে আমাদের নিম্নলিখিতটি দেখায়:
Welcome to the profile statistics browser.
timeStats.profile% stats hello
<timestamp> timeStats.profile
224 function calls in 6.014 seconds
Random listing order was used
List reduced from 6 to 1 due to restriction <'hello'>
ncalls tottime percall cumtime percall filename:lineno(function)
10 0.000 0.000 1.001 0.100 timeFunctions.py:3(hello)
timeStats.profile% stats thankyou
<timestamp> timeStats.profile
224 function calls in 6.014 seconds
Random listing order was used
List reduced from 6 to 1 due to restriction <'thankyou'>
ncalls tottime percall cumtime percall filename:lineno(function)
100 0.002 0.000 5.012 0.050 timeFunctions.py:7(thankyou)ডামি উদাহরণটি তেমন কিছু করে না তবে আপনাকে কী করা যায় তার একটি ধারণা দেয়। এই পদ্ধতির সর্বোত্তম অংশটি হ'ল এই সংখ্যাগুলি পেতে আমার বিদ্যমান কোডের কোনওটি সম্পাদনা করতে হবে না এবং অবশ্যই প্রোফাইলিংয়ে সহায়তা করতে হবে।
python -m pstats timeStats.profile ValueError: bad marshal data (unknown type code)অজগর সংস্করণটি চালাচ্ছেন তবে তা পরীক্ষা করে দেখুন। আমি দৌড়ে এসেছিলাম python3 -m cProfile...এবং যখন python -m pstats। আমার ভুল তবে আমাকে এক সেকেন্ডের জন্য পেয়েছে, তাই, আমি ভাগ করে নিতে চাই don't forget consistency। =)
টাইমিং কোডের জন্য এখানে অন্য প্রসঙ্গ পরিচালক -
ব্যবহার:
from benchmark import benchmark
with benchmark("Test 1+1"):
1+1
=>
Test 1+1 : 1.41e-06 secondsঅথবা, যদি আপনার সময় মূল্য প্রয়োজন হয়
with benchmark("Test 1+1") as b:
1+1
print(b.time)
=>
Test 1+1 : 7.05e-07 seconds
7.05233786763e-07বেঞ্চমার্ক.পি :
from timeit import default_timer as timer
class benchmark(object):
def __init__(self, msg, fmt="%0.3g"):
self.msg = msg
self.fmt = fmt
def __enter__(self):
self.start = timer()
return self
def __exit__(self, *args):
t = timer() - self.start
print(("%s : " + self.fmt + " seconds") % (self.msg, t))
self.time = tHttp://dabeaz.blogspot.fr/2010/02/context-manager-for-timing-benchmark.html থেকে অভিযোজিত
প্রোফাইলার মডিউলটি ব্যবহার করুন। এটি একটি খুব বিস্তারিত প্রোফাইল দেয়।
import profile
profile.run('main()')এটি এরকম কিছু দেয়:
5 function calls in 0.047 seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.000 0.000 0.000 0.000 :0(exec)
1 0.047 0.047 0.047 0.047 :0(setprofile)
1 0.000 0.000 0.000 0.000 <string>:1(<module>)
0 0.000 0.000 profile:0(profiler)
1 0.000 0.000 0.047 0.047 profile:0(main())
1 0.000 0.000 0.000 0.000 two_sum.py:2(twoSum)আমি এটি খুব তথ্যপূর্ণ খুঁজে পেয়েছি।
main()? আপনি যদি একটি সাধারণ কোড উদাহরণ সরবরাহ করতে পারেন তবে আরও দরকারী।
আমি এটি সহজ (অজগর 3) পছন্দ করি :
from timeit import timeit
timeit(lambda: print("hello"))আউটপুট একটি একক মৃত্যুর জন্য মাইক্রোসেকেন্ডস :
2.430883963010274ব্যাখ্যা : টাইমিট অজ্ঞাতনামা ফাংশনটি ডিফল্ট হিসাবে 1 মিলিয়ন বার সম্পাদন করে এবং ফলাফলটি কয়েক সেকেন্ডে দেওয়া হয় । সুতরাং 1 একক মৃত্যুদন্ড কার্যকর করার ফলাফল একই পরিমাণে কিন্তু গড়ে মাইক্রোসেকেন্ডে ।
জন্য ধীর অপারেশন একটি নিম্ন যোগ সংখ্যা পুনরাবৃত্তিও বা তোমাকে সারাজীবন অপেক্ষা করা যেতে পারে:
import time
timeit(lambda: time.sleep(1.5), number=1)মোট পুনরাবৃত্তির সংখ্যার জন্য আউটপুট সর্বদা সেকেন্ডে থাকে :
1.5015795179999714(কেবলমাত্র আইপিথন সহ) আপনি গড় প্রক্রিয়াকরণের সময় পরিমাপ করতে % টাইমিট ব্যবহার করতে পারেন :
def foo():
print "hello"এবং তারপর:
%timeit foo()ফলাফলটি এরকম কিছু:
10000 loops, best of 3: 27 µs per loopপাইথন 3 এ:
from time import sleep, perf_counter as pc
t0 = pc()
sleep(1)
print(pc()-t0)মার্জিত এবং সংক্ষিপ্ত।
পরের ধরণের প্রতিক্রিয়ার মতো, তবে এটি কারও জন্য একটি উদ্দেশ্য করে। এটি করার একটি উপায় যা আমি মনে করি এটি পরিষ্কার clean
import time
def timed(fun, *args):
s = time.time()
r = fun(*args)
print('{} execution took {} seconds.'.format(fun.__name__, time.time()-s))
return(r)
timed(print, "Hello")মনে রাখবেন যে "মুদ্রণ" পাইথন ২.7 নয়, পাইথন ২ এ একটি ফাংশন। তবে এটি অন্য যে কোনও ফাংশনের সাথে কাজ করে। চিয়ার্স!
আপনি সময়কাল ব্যবহার করতে পারেন।
পাইথন আরপিএল ব্যবহার করে প্যারামিটার নেভিগেশন নিখুঁত_ফুঙ্ক কীভাবে পরীক্ষা করতে হয় তার একটি উদাহরণ এখানে:
>>> import timeit
>>> def naive_func(x):
... a = 0
... for i in range(a):
... a += i
... return a
>>> def wrapper(func, *args, **kwargs):
... def wrapper():
... return func(*args, **kwargs)
... return wrapper
>>> wrapped = wrapper(naive_func, 1_000)
>>> timeit.timeit(wrapped, number=1_000_000)
0.4458435332577161 ফাংশনের কোনও পরামিতি না থাকলে আপনার মোড়ক ফাংশনের প্রয়োজন নেই।
lambdaআরও print(timeit.timeit(lambda: naive_func(1_000), number=1_000_000))
সময়কে আমরা মানব-পঠনযোগ্য সময়ে রূপান্তর করতে পারি।
import time, datetime
start = time.clock()
def num_multi1(max):
result = 0
for num in range(0, 1000):
if (num % 3 == 0 or num % 5 == 0):
result += num
print "Sum is %d " % result
num_multi1(1000)
end = time.clock()
value = end - start
timestamp = datetime.datetime.fromtimestamp(value)
print timestamp.strftime('%Y-%m-%d %H:%M:%S')আমি এটির জন্য একটি লাইব্রেরি তৈরি করেছি, আপনি যদি কোনও ফাংশন পরিমাপ করতে চান তবে আপনি এটি ঠিক এটি করতে পারেন
from pythonbenchmark import compare, measure
import time
a,b,c,d,e = 10,10,10,10,10
something = [a,b,c,d,e]
@measure
def myFunction(something):
time.sleep(0.4)
@measure
def myOptimizedFunction(something):
time.sleep(0.2)
myFunction(input)
myOptimizedFunction(input)%load_ext snakeviz
%%snakevizএটি কেবলমাত্র একটি বৃহত্তর নোটবুকে কোডের এই 2 টি লাইন নেয় এবং এটি একটি সুন্দর ইন্টারেক্টিভ ডায়াগ্রাম উত্পন্ন করে। উদাহরণ স্বরূপ:
কোডটি এখানে। আবার, 2 টি লাইন দিয়ে শুরু করা %স্ন্পভিজ ব্যবহারের জন্য প্রয়োজনীয় কোডের একমাত্র অতিরিক্ত লাইন:
# !pip install snakeviz
%load_ext snakeviz
import glob
import hashlib
%%snakeviz
files = glob.glob('*.txt')
def print_files_hashed(files):
for file in files:
with open(file) as f:
print(hashlib.md5(f.read().encode('utf-8')).hexdigest())
print_files_hashed(files)নোটবুকের বাইরেও স্নাপভিজ চালানো সম্ভব বলে মনে হয়। স্নাপভিজ ওয়েবসাইটে আরও তথ্য ।
এই অনন্য শ্রেণিভিত্তিক পদ্ধতির একটি মুদ্রণযোগ্য স্ট্রিং প্রতিনিধিত্ব, কাস্টমাইজযোগ্য রাউন্ডিং এবং স্ট্রিং বা ফ্লোট হিসাবে অতিবাহিত সময়টিতে সুবিধাজনক অ্যাক্সেস সরবরাহ করে। এটি পাইথন ৩.7 দিয়ে তৈরি করা হয়েছিল।
import datetime
import timeit
class Timer:
"""Measure time used."""
# Ref: https://stackoverflow.com/a/57931660/
def __init__(self, round_ndigits: int = 0):
self._round_ndigits = round_ndigits
self._start_time = timeit.default_timer()
def __call__(self) -> float:
return timeit.default_timer() - self._start_time
def __str__(self) -> str:
return str(datetime.timedelta(seconds=round(self(), self._round_ndigits)))ব্যবহার:
# Setup timer
>>> timer = Timer()
# Access as a string
>>> print(f'Time elapsed is {timer}.')
Time elapsed is 0:00:03.
>>> print(f'Time elapsed is {timer}.')
Time elapsed is 0:00:04.
# Access as a float
>>> timer()
6.841332235
>>> timer()
7.970274425সময়ের একক : একটি ফ্লোট হিসাবে সেকেন্ডে পরিমাপ করা হয়
import timeit
t = timeit.Timer('li = list(map(lambda x:x*2,[1,2,3,4,5]))')
t.timeit()
t.repeat()
>[1.2934070999999676, 1.3335035000000062, 1.422568500000125]পুনরাবৃত্তি () পদ্ধতিটি একাধিকবার টাইমিট () কল করতে এবং ফলাফলের একটি তালিকা ফেরত দেওয়া একটি সুবিধা।
repeat(repeat=3)¶এই তালিকার সাহায্যে আমরা সর্বকালের একটি গড় সময় নিতে পারি।
ডিফল্টরূপে টাইমিট () সময়কালে অস্থায়ীভাবে আবর্জনা সংগ্রহ বন্ধ করে দেয়। টাইম.টাইমার () এই সমস্যাটি সমাধান করে।
পেশাদাররা:
টাইমাইট.টাইমার () স্বাধীন সময়কে আরও তুলনীয় করে তোলে। জিসি মাপা হচ্ছে ফাংশনটির পারফরম্যান্সের একটি গুরুত্বপূর্ণ উপাদান হতে পারে। যদি তা হয়, গিসি (আবর্জনা সংগ্রহকারী) সেটআপ স্ট্রিংয়ের প্রথম বিবৃতি হিসাবে পুনরায় সক্ষম করা যায়। উদাহরণ স্বরূপ:
timeit.Timer('li = list(map(lambda x:x*2,[1,2,3,4,5]))',setup='gc.enable()')
উত্স পাইথন ডক্স !
আপনি যদি সুবিধাজনকভাবে ফাংশনগুলি সময় করতে সক্ষম হতে চান তবে আপনি একটি সাধারণ সাজসজ্জা ব্যবহার করতে পারেন:
def timing_decorator(func):
def wrapper(*args, **kwargs):
start = time.time()
original_return_val = func(*args, **kwargs)
end = time.time()
print("time elapsed in ", func.__name__, ": ", end - start, sep='')
return original_return_val
return wrapperআপনি এটি এমন সময়ে ফাংশনটিতে ব্যবহার করতে পারেন:
@timing_decorator
def function_to_time():
time.sleep(1)তারপরে আপনি যখনই কল করবেন function_to_time, এটি কতক্ষণ সময় নিয়েছে এবং ফাংশনটির নাম সময়সাপেক্ষে প্রিন্ট করা হবে।
contextmanager সমাধান কর্তৃক প্রদত্ত উপর ভিত্তি করে https://stackoverflow.com/a/30024601/5095636 , অধীনে ল্যামডা মুক্ত সংস্করণ, যেমন flake8 অনুযায়ী ল্যামডা এর ব্যবহারের উপর সতর্ক E731 :
from contextlib import contextmanager
from timeit import default_timer
@contextmanager
def elapsed_timer():
start_time = default_timer()
class _Timer():
start = start_time
end = default_timer()
duration = end - start
yield _Timer
end_time = default_timer()
_Timer.end = end_time
_Timer.duration = end_time - start_timeপরীক্ষা:
from time import sleep
with elapsed_timer() as t:
print("start:", t.start)
sleep(1)
print("end:", t.end)
t.start
t.end
t.durationআমি ভাবতে পারি একমাত্র উপায় ব্যবহার করা time.time()।
import time
start = time.time()
sleep(5) #just to give it some delay to show it working
finish = time.time()
elapsed = finish - start
print(elapsed)আশা করি এটি সাহায্য করবে।
দ্য timeitমডিউল পাইথন কোড একটি ছোট টুকরা সময়জ্ঞান জন্য ভাল। এটি কমপক্ষে তিনটি আকারে ব্যবহার করা যেতে পারে:
1- একটি কমান্ড-লাইন মডিউল হিসাবে
python2 -m timeit 'for i in xrange(10): oct(i)' 2- একটি সংক্ষিপ্ত কোডের জন্য, এটি আর্গুমেন্ট হিসাবে পাস করুন।
import timeit
timeit.Timer('for i in xrange(10): oct(i)').timeit()3- লম্বা কোডের জন্য হিসাবে:
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=100)/100
print(elapsed_time)