পাইথন প্রোগ্রামের সম্পাদনের সময় কীভাবে পাব?
উত্তর:
পাইথনের সহজতম উপায়:
import time
start_time = time.time()
main()
print("--- %s seconds ---" % (time.time() - start_time))এটি ধরে নিয়েছে যে আপনার প্রোগ্রামটি চালাতে কমপক্ষে দশমাংশ লাগবে।
ছাপে:
--- 0.764891862869 seconds ---round(time.time() - start_time, 2)(বা আপনি যে দশমিক দশমিক চান), আমি বৈজ্ঞানিক নম্বরগুলি পেয়েছি ১.২৪ ই -৫ এর মতো।
'%.2f'পরিবর্তে চাইবেন round()।
আমি এই timing.pyমডিউলটি আমার নিজের site-packagesডিরেক্টরিতে রেখেছি এবং import timingআমার মডিউলটির শীর্ষে সন্নিবেশ করলাম:
import atexit
from time import clock
def secondsToStr(t):
return "%d:%02d:%02d.%03d" % \
reduce(lambda ll,b : divmod(ll[0],b) + ll[1:],
[(t*1000,),1000,60,60])
line = "="*40
def log(s, elapsed=None):
print line
print secondsToStr(clock()), '-', s
if elapsed:
print "Elapsed time:", elapsed
print line
print
def endlog():
end = clock()
elapsed = end-start
log("End Program", secondsToStr(elapsed))
def now():
return secondsToStr(clock())
start = clock()
atexit.register(endlog)
log("Start Program")আমি timing.logযে প্রোগ্রামটি দেখাতে চাই তার মধ্যে উল্লেখযোগ্য পর্যায়ে থাকলে আমি আমার প্রোগ্রামের মধ্যে থেকেও কল করতে পারি। তবে কেবল অন্তর্ভুক্ত import timingশুরু এবং শেষ সময়গুলি এবং সামগ্রিকভাবে সময় কাটানো প্রিন্ট করবে। (আমার অস্পষ্ট secondsToStrফাংশনটি ক্ষমা করুন , এটি সেকেন্ডের এক ভাসমান পয়েন্ট সংখ্যাকে hh: মিমি: এসএসএসএস ফর্মিতে ফর্ম্যাট করে))
দ্রষ্টব্য: উপরের কোডের পাইথন 3 সংস্করণটি এখানে বা এখানে পাওয়া যাবে ।
from functools import reduceশীর্ষে যুক্ত করুন এবং প্রতিটি মুদ্রণ বিবৃতিতে চারদিকে বন্ধনী রাখুন। দুর্দান্ত কাজ!
লিনাক্স বা ইউনিক্সে:
$ time python yourprogram.pyউইন্ডোজে, এই স্ট্যাকওভারফ্লো প্রশ্নটি দেখুন: আমি উইন্ডোজ কমান্ড লাইনে কোনও আদেশের কার্যকরকরণের সময়কে কীভাবে পরিমাপ করব?
আরও ভার্বোজ আউটপুট জন্য,
$ time -v python yourprogram.py
Command being timed: "python3 yourprogram.py"
User time (seconds): 0.08
System time (seconds): 0.02
Percent of CPU this job got: 98%
Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.10
Average shared text size (kbytes): 0
Average unshared data size (kbytes): 0
Average stack size (kbytes): 0
Average total size (kbytes): 0
Maximum resident set size (kbytes): 9480
Average resident set size (kbytes): 0
Major (requiring I/O) page faults: 0
Minor (reclaiming a frame) page faults: 1114
Voluntary context switches: 0
Involuntary context switches: 22
Swaps: 0
File system inputs: 0
File system outputs: 0
Socket messages sent: 0
Socket messages received: 0
Signals delivered: 0
Page size (bytes): 4096
Exit status: 0secondsToStr()কার্যকারিতা দেখুন।
আমি পল ম্যাকগুয়ারের উত্তরটি সত্যিই পছন্দ করি তবে আমি পাইথন ৩ ব্যবহার করি So সুতরাং যারা আগ্রহী তাদের জন্য: এখানে তাঁর উত্তরটির একটি পরিবর্তন রয়েছে যা পাইথন 3 এর সাথে * নিক্সে কাজ করে (আমি ধারণা করি উইন্ডোজের অধীনে এর clock()পরিবর্তে ব্যবহার করা উচিত time()):
#python3
import atexit
from time import time, strftime, localtime
from datetime import timedelta
def secondsToStr(elapsed=None):
if elapsed is None:
return strftime("%Y-%m-%d %H:%M:%S", localtime())
else:
return str(timedelta(seconds=elapsed))
def log(s, elapsed=None):
line = "="*40
print(line)
print(secondsToStr(), '-', s)
if elapsed:
print("Elapsed time:", elapsed)
print(line)
print()
def endlog():
end = time()
elapsed = end-start
log("End Program", secondsToStr(elapsed))
start = time()
atexit.register(endlog)
log("Start Program")যদি আপনি এটি দরকারী মনে করেন তবে তার উত্তরটির পরিবর্তে আপনার উত্তর দেওয়া উচিত, যেমন তিনি বেশিরভাগ কাজ করেছেন;)।
timedelta(seconds=t).total_seconds()সহায়ক খুঁজে পেয়েছি ।
import time
start_time = time.clock()
main()
print time.clock() - start_time, "seconds"time.clock()প্রসেসরের সময়টি ফেরত দেয়, যা আমাদের কেবল এই প্রক্রিয়াটি (ইউনিক্সে যাইহোক) ব্যবহৃত সময় গণনা করতে দেয়। ডকুমেন্টেশনটিতে বলা হয়েছে "যে কোনও ক্ষেত্রে পাইথন বা টাইমিং অ্যালগরিদমকে বেঞ্চমার্ক করার জন্য এটি ব্যবহার করা"
আমি datetimeমডিউলটি যে আউটপুট সরবরাহ করে তা পছন্দ করি , যেখানে সময় ব-দ্বীপ অবজেক্টগুলি মানব-পঠনযোগ্য উপায়ে প্রয়োজনীয় সময়, ঘন্টা, মিনিট ইত্যাদি প্রদর্শন করে।
উদাহরণ স্বরূপ:
from datetime import datetime
start_time = datetime.now()
# do your work here
end_time = datetime.now()
print('Duration: {}'.format(end_time - start_time))নমুনা আউটপুট যেমন
Duration: 0:00:08.309267অথবা
Duration: 1 day, 1:51:24.269711জেএফ সেবাস্তিয়ান যেমন উল্লেখ করেছেন, এই পদ্ধতির স্থানীয় সময়ের সাথে কিছু জটিল বিষয়গুলির মুখোমুখি হতে পারে, সুতরাং এটি ব্যবহার করা নিরাপদ:
import time
from datetime import timedelta
start_time = time.monotonic()
end_time = time.monotonic()
print(timedelta(seconds=end_time - start_time))timedelta(seconds=time.monotonic()-start)এখানে ব্যবহার করতে পারেন (বা time.time()যদি ব্যবধানটি বড় হয়)। স্থানীয় সময় প্রতিনিধিত্বমূলক নিষ্পাপ ডেটটাইম অবজেক্টগুলি বিয়োগ করবেন না; স্থানীয় সময় একঘেয়ে নয়
start_time = time.monotonic(); end_time = time.monotonic(); timedelta(seconds=end_time - start_time)। আমি বিশ্বাস করি আপনি ঠিক বলেছেন, তবে ফিরে আসার সাথে সাথে আপনাকে এটি ফর্ম্যাটও করতে হবে datetime.timedelta(0, 0, 76)। এছাড়াও, মনে হয় একঘেয়ে মেথডটি কেবল পাইথন 3-এ যুক্ত হয়েছিল
str()এটি "মানব" করার জন্য এটি পাস করতে পারেন । আমি উত্তর আপডেট করব, ধন্যবাদ।
আপনি সিপিইউ সময় এবং এটি ছাড়াও প্রতিটি ফাংশনের ভিতরে কত সময় ব্যয় করা হয় এবং প্রতিটি ফাংশনটি কতবার ডাকা হয় তা পরিমাপ করতে পাইথন প্রোফাইলার সিপি প্রফিল ব্যবহার করতে পারেন । আপনি কোথায় শুরু করবেন তা না জেনে যদি আপনার স্ক্রিপ্টের পারফরম্যান্স উন্নত করতে চান তবে এটি খুব কার্যকর। অন্য স্ট্যাক ওভারফ্লো প্রশ্নের এই উত্তরটি বেশ ভাল। ডকুমেন্টেশনেও একবার নজর রাখা ভাল ।
কমান্ড লাইন থেকে সিপ্রোফিল ব্যবহার করে কোনও স্ক্রিপ্ট প্রোফাইল করা যায় তার একটি উদাহরণ এখানে রয়েছে:
$ python -m cProfile euler048.py
1007 function calls in 0.061 CPU seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.000 0.000 0.061 0.061 <string>:1(<module>)
1000 0.051 0.000 0.051 0.000 euler048.py:2(<lambda>)
1 0.005 0.005 0.061 0.061 euler048.py:2(<module>)
1 0.000 0.000 0.061 0.061 {execfile}
1 0.002 0.002 0.053 0.053 {map}
1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler objects}
1 0.000 0.000 0.000 0.000 {range}
1 0.003 0.003 0.003 0.003 {sum}X function calls in Y CPU seconds। যদি আপনি প্রাচীর ঘড়ির সময় চান, তবে অন্য একটি উত্তর এখানে ব্যবহার করুন।
লিনাক্সের জন্য আরও ভাল: time
$ time -v python rhtest2.py
Command being timed: "python rhtest2.py"
User time (seconds): 4.13
System time (seconds): 0.07
Percent of CPU this job got: 91%
Elapsed (wall clock) time (h:mm:ss or m:ss): 0:04.58
Average shared text size (kbytes): 0
Average unshared data size (kbytes): 0
Average stack size (kbytes): 0
Average total size (kbytes): 0
Maximum resident set size (kbytes): 0
Average resident set size (kbytes): 0
Major (requiring I/O) page faults: 15
Minor (reclaiming a frame) page faults: 5095
Voluntary context switches: 27
Involuntary context switches: 279
Swaps: 0
File system inputs: 0
File system outputs: 0
Socket messages sent: 0
Socket messages received: 0
Signals delivered: 0
Page size (bytes): 4096
Exit status: 0নির্দিষ্ট সময় নির্ধারণকারী ঘড়ি()
সংস্করণ 3.3 থেকে থামানো হয়েছে: এই ফাংশন আচরণ প্ল্যাটফর্মের উপর নির্ভর করে: ব্যবহার perf_counter () বা process_time () পরিবর্তে আপনার প্রয়োজনীয়তা উপর নির্ভর করে, একটি ভালভাবে সংজ্ঞায়িত আচরণ আছে।
time.perf_counter ()
পারফরম্যান্স কাউন্টারটির মান (ভগ্নাংশের সেকেন্ডে), অর্থাত্ একটি স্বল্প সময়কাল পরিমাপের জন্য সর্বোচ্চ উপলব্ধ রেজোলিউশন সহ একটি ঘড়ি Return এটি ঘুমের সময় অতিবাহিত সময় অন্তর্ভুক্ত করে না এবং এটি সিস্টেম-ব্যাপী।
time.process_time ()
বর্তমান প্রক্রিয়াটির সিস্টেম এবং ব্যবহারকারীর সিপিইউ সময়ের যোগফলের (ভগ্নাংশ সেকেন্ডে) মানটি প্রদান করুন। এটি ঘুমের সময় অতিবাহিত সময় অন্তর্ভুক্ত করে না ।
start = time.process_time()
... do something
elapsed = (time.process_time() - start)শুধু timeitমডিউল ব্যবহার করুন । এটি পাইথন 2 এবং পাইথন 3 উভয়ের সাথেই কাজ করে।
import timeit
start = timeit.default_timer()
# All the program statements
stop = timeit.default_timer()
execution_time = stop - start
print("Program Executed in "+str(execution_time)) # It returns time in secondsএটি সেকেন্ডের মধ্যে ফিরে আসে এবং আপনার মৃত্যুদন্ড কার্যকর করার সময় থাকতে পারে। এটি সহজ, তবে আপনার প্রোগ্রামটি কার্যকর করা শুরু হওয়া মূল ফাংশনে এগুলি লিখতে হবে। আপনি যদি কোনও ত্রুটি পেয়েও মৃত্যুদণ্ডের সময় পেতে চান তবে আপনার পরামিতিটিকে "শুরু" করুন এবং সেখানে গণনা করুন:
def sample_function(start,**kwargs):
try:
# Your statements
except:
# except statements run when your statements raise an exception
stop = timeit.default_timer()
execution_time = stop - start
print("Program executed in " + str(execution_time))finally?
নীচের স্নিপেট প্রিন্টগুলি একটি সুন্দর মানব পঠনযোগ্য <HH:MM:SS>ফর্ম্যাটে সময় অতিবাহিত করেছে ।
import time
from datetime import timedelta
start_time = time.time()
#
# Perform lots of computations.
#
elapsed_time_secs = time.time() - start_time
msg = "Execution took: %s secs (Wall clock time)" % timedelta(seconds=round(elapsed_time_secs))
print(msg) from time import time
start_time = time()
...
end_time = time()
time_taken = end_time - start_time # time_taken is in seconds
hours, rest = divmod(time_taken,3600)
minutes, seconds = divmod(rest, 60)আমি টাইমিট মডিউলটি দেখেছি, তবে মনে হচ্ছে এটি কেবল কোডের ছোট ছোট স্নিপেটের জন্য। আমি পুরো প্রোগ্রামটি সময় করতে চাই।
$ python -mtimeit -n1 -r1 -t -s "from your_module import main" "main()"এটি একবারে your_module.main()ফাংশন চালায় এবং time.time()একটি টাইমার হিসাবে ফাংশন ব্যবহার করে অতিবাহিত সময় মুদ্রণ করে ।
/usr/bin/timeপাইথনে অনুকরণ করতে পাইথন উপ-প্রসেসটি / usr / বিন / সময়ের সাথে দেখুন: কীভাবে সময় সংক্রান্ত তথ্য ক্যাপচার করবেন তবে অন্যান্য সমস্ত আউটপুট উপেক্ষা করবেন? ।
time.sleep()প্রতিটি ফাংশনের সিপিইউ সময় (যেমন, সময় অন্তর্ভুক্ত করবেন না ) পরিমাপ করতে আপনি profileমডিউলটি ব্যবহার করতে পারেন ( cProfileপাইথন 2 তে):
$ python3 -mprofile your_module.pyআপনি পাস পারে -pথেকে timeitউপরোক্ত কমান্ডের আপনি একই টাইমার ব্যবহার করতে চানprofile মডিউল ব্যবহার।
আমি পল ম্যাকগুয়ারের উত্তরটিও পছন্দ করেছি এবং একটি প্রসঙ্গে ম্যানেজার ফর্ম নিয়ে এসেছি যা আমার প্রয়োজনের সাথে আরও উপযুক্ত।
import datetime as dt
import timeit
class TimingManager(object):
"""Context Manager used with the statement 'with' to time some execution.
Example:
with TimingManager() as t:
# Code to time
"""
clock = timeit.default_timer
def __enter__(self):
"""
"""
self.start = self.clock()
self.log('\n=> Start Timing: {}')
return self
def __exit__(self, exc_type, exc_val, exc_tb):
"""
"""
self.endlog()
return False
def log(self, s, elapsed=None):
"""Log current time and elapsed time if present.
:param s: Text to display, use '{}' to format the text with
the current time.
:param elapsed: Elapsed time to display. Dafault: None, no display.
"""
print s.format(self._secondsToStr(self.clock()))
if(elapsed is not None):
print 'Elapsed time: {}\n'.format(elapsed)
def endlog(self):
"""Log time for the end of execution with elapsed time.
"""
self.log('=> End Timing: {}', self.now())
def now(self):
"""Return current elapsed time as hh:mm:ss string.
:return: String.
"""
return str(dt.timedelta(seconds = self.clock() - self.start))
def _secondsToStr(self, sec):
"""Convert timestamp to h:mm:ss string.
:param sec: Timestamp.
"""
return str(dt.datetime.fromtimestamp(sec))জুপিটার নোটবুক ব্যবহার করে ডেটা ভাবার জন্য
একটি ঘরে, আপনি %%timeকার্যকর করার সময়টি পরিমাপ করতে জুপিটারের যাদু আদেশটি ব্যবহার করতে পারেন :
%%time
[ x**2 for x in range(10000)]আউটপুট
CPU times: user 4.54 ms, sys: 0 ns, total: 4.54 ms
Wall time: 4.12 msএটি কেবলমাত্র একটি নির্দিষ্ট কক্ষের কার্যকরকরণের সময়টি ক্যাপচার করবে। আপনি যদি পুরো নোটবুকের (যেমন প্রোগ্রাম) কার্যকর করার সময়টি ক্যাপচার করতে চান তবে আপনি একই ডিরেক্টরিতে এবং নতুন নোটবুকে সমস্ত কক্ষ কার্যকর করতে একটি নতুন নোটবুক তৈরি করতে পারেন:
ধরুন উপরের নোটবুকটি বলা হয়েছে example_notebook.ipynb। একই ডিরেক্টরিতে একটি নতুন নোটবুক:
# Convert your notebook to a .py script:
!jupyter nbconvert --to script example_notebook.ipynb
# Run the example_notebook with -t flag for time
%run -t example_notebookআউটপুট
IPython CPU timings (estimated):
User : 0.00 s.
System : 0.00 s.
Wall time: 0.00 s.একটি timeitমডিউল রয়েছে যা পাইথন কোডের প্রয়োগের সময় ব্যবহার করতে ব্যবহৃত হতে পারে।
পাইথন ডকুমেন্টেশনে এর বিস্তারিত ডকুমেন্টেশন এবং উদাহরণ রয়েছে, ২ 26..6। সময়সূচি - ছোট কোড স্নিপেটের কার্যকরকরণের সময় পরিমাপ করুন ।
timeitপ্রশ্নে ওপি স্পষ্টভাবে উল্লেখ করেছে। প্রশ্নটি কীভাবে এটি এখানে ব্যবহার করা যেতে পারে (বা এটি এখানে ব্যবহার করা উচিত এবং বিকল্পগুলি কী)। এখানে সম্ভাব্য উত্তর ।
লাইন_প্রফেলার ব্যবহার করুন ।
লাইন_প্রোফাইলার কোডের স্বতন্ত্র রেখাগুলি কার্যকর করতে সময় লাগবে। প্রোফাইলিংয়ের ওভারহেড হ্রাস করার জন্য প্রোফাইলার সিটিতে সিটিতে প্রয়োগ করা হয়েছিল ।
from line_profiler import LineProfiler
import random
def do_stuff(numbers):
s = sum(numbers)
l = [numbers[i]/43 for i in range(len(numbers))]
m = ['hello'+str(numbers[i]) for i in range(len(numbers))]
numbers = [random.randint(1,100) for i in range(1000)]
lp = LineProfiler()
lp_wrapper = lp(do_stuff)
lp_wrapper(numbers)
lp.print_stats()ফলাফলগুলি হবে:
Timer unit: 1e-06 s
Total time: 0.000649 s
File: <ipython-input-2-2e060b054fea>
Function: do_stuff at line 4
Line # Hits Time Per Hit % Time Line Contents
==============================================================
4 def do_stuff(numbers):
5 1 10 10.0 1.5 s = sum(numbers)
6 1 186 186.0 28.7 l = [numbers[i]/43 for i in range(len(numbers))]
7 1 453 453.0 69.8 m = ['hello'+str(numbers[i]) for i in range(len(numbers))]কোড প্রয়োগের একটি অংশ সময় করতে আমি খুব সাধারণ ফাংশন ব্যবহার করেছি:
import time
def timing():
start_time = time.time()
return lambda x: print("[{:.2f}s] {}".format(time.time() - start_time, x))এবং এটি ব্যবহার করতে, ফাংশনের সময় পুনরুদ্ধার করার জন্য পরিমাপের জন্য কোডের আগে এটিকে কল করুন এবং তারপরে মন্তব্যে কোডের পরে ফাংশনটি কল করুন। সময় মতামত সামনে উপস্থিত হবে। উদাহরণ স্বরূপ:
t = timing()
train = pd.read_csv('train.csv',
dtype={
'id': str,
'vendor_id': str,
'pickup_datetime': str,
'dropoff_datetime': str,
'passenger_count': int,
'pickup_longitude': np.float64,
'pickup_latitude': np.float64,
'dropoff_longitude': np.float64,
'dropoff_latitude': np.float64,
'store_and_fwd_flag': str,
'trip_duration': int,
},
parse_dates = ['pickup_datetime', 'dropoff_datetime'],
)
t("Loaded {} rows data from 'train'".format(len(train)))তারপরে আউটপুটটি এর মতো দেখাবে:
[9.35s] Loaded 1458644 rows data from 'train'আমার অনেক জায়গায় একই সমস্যা ছিল, তাই আমি একটি সুবিধা প্যাকেজ তৈরি করেছি horology। আপনি এটি দিয়ে ইনস্টল করতে পারেন pip install horologyএবং তারপরে এটি মার্জিত উপায়ে করতে পারেন:
from horology import Timing
with Timing(name='Important calculations: '):
prepare()
do_your_stuff()
finish_sth()আউটপুট হবে:
Important calculations: 12.43 msবা এমনকি সহজ (যদি আপনার একটি ফাংশন থাকে):
from horology import timed
@timed
def main():
...আউটপুট হবে:
main: 7.12 hএটি ইউনিট এবং রাউন্ডিংয়ের যত্ন নেয়। এটি অজগর 3.6 বা আরও নতুন দিয়ে কাজ করে।
main.interval।
এটি পল ম্যাকগুইয়ারের উত্তর যা আমার পক্ষে কাজ করে। সেক্ষেত্রে কারও যদি এটি চালাতে সমস্যা হয়।
import atexit
from time import clock
def reduce(function, iterable, initializer=None):
it = iter(iterable)
if initializer is None:
value = next(it)
else:
value = initializer
for element in it:
value = function(value, element)
return value
def secondsToStr(t):
return "%d:%02d:%02d.%03d" % \
reduce(lambda ll,b : divmod(ll[0],b) + ll[1:],
[(t*1000,),1000,60,60])
line = "="*40
def log(s, elapsed=None):
print (line)
print (secondsToStr(clock()), '-', s)
if elapsed:
print ("Elapsed time:", elapsed)
print (line)
def endlog():
end = clock()
elapsed = end-start
log("End Program", secondsToStr(elapsed))
def now():
return secondsToStr(clock())
def main():
start = clock()
atexit.register(endlog)
log("Start Program")timing.main()ফাইলটি আমদানির পরে আপনার প্রোগ্রাম থেকে কল করুন।
টাইমিট হ'ল পাইথনের একটি শ্রেণি যা কোডের ছোট ব্লকের প্রয়োগের সময় গণনা করতে ব্যবহৃত হয়।
ডিফল্ট_টাইমার এই শ্রেণীর একটি পদ্ধতি যা প্রাচীর ঘড়ির সময় নির্ধারণ করতে ব্যবহৃত হয়, সিপিইউ প্রয়োগের সময় নয়। সুতরাং অন্যান্য প্রক্রিয়া সম্পাদন এতে হস্তক্ষেপ করতে পারে। সুতরাং এটি কোডের ছোট ব্লকগুলির জন্য দরকারী।
কোডের একটি নমুনা নিম্নরূপ:
from timeit import default_timer as timer
start= timer()
# Some logic
end = timer()
print("Time taken:", end-start)timeitঅনেক উদাহরণের জন্য আরও ভাল উত্তর আইএমও।
পরে উত্তর, কিন্তু আমি ব্যবহার timeit:
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=500)
print(elapsed_time)
# 10.159821493085474- ভিতরে থাকা কোনও আমদানি সহ আপনার সমস্ত কোড মোড়ানো
code_to_test। numberযুক্তি কোডটির পুনরাবৃত্তি হওয়া উচিত পরিমাণ নির্দিষ্ট করে।- ডেমো
পাইথন প্রোগ্রামের প্রয়োগের পরিমাপের সময়টি নির্ভর করে:
- একই প্রোগ্রামটি বিভিন্ন অ্যালগোরিদম ব্যবহার করে মূল্যায়ন করা যেতে পারে
- চলমান সময় অ্যালগরিদমের মধ্যে পরিবর্তিত হয়
- চলমান সময় বাস্তবায়নের মধ্যে পরিবর্তিত হয়
- চলমান সময় কম্পিউটারের মধ্যে পরিবর্তিত হয়
- ছোট ইনপুটগুলির উপর নির্ভর করে চলমান সময় অনুমানযোগ্য নয়
এটি হ'ল কারণ সবচেয়ে কার্যকর উপায়টি "অর্ডার অফ গ্রোথ" ব্যবহার করছে এবং এটি সঠিকভাবে করতে বড় "ও" স্বরলিপিটি শিখবে ।
যাইহোক, আপনি এই সাধারণ অ্যালগরিদমটি ব্যবহার করে সেকেন্ডে নির্দিষ্ট মেশিন গণনা পদক্ষেপগুলিতে পাইথন প্রোগ্রামের যে কোনও পারফরম্যান্স মূল্যায়নের চেষ্টা করতে পারেন: আপনি যে প্রোগ্রামটি মূল্যায়ন করতে চান তার সাথে এটি মানিয়ে নিন
import time
now = time.time()
future = now + 10
step = 4 # Why 4 steps? Because until here already four operations executed
while time.time() < future:
step += 3 # Why 3 again? Because a while loop executes one comparison and one plus equal statement
step += 4 # Why 3 more? Because one comparison starting while when time is over plus the final assignment of step + 1 and print statement
print(str(int(step / 10)) + " steps per second")আপনি কেবল পাইথনে এটি করেন। এটিকে জটিল করার দরকার নেই।
import time
start = time.localtime()
end = time.localtime()
"""Total execution time in seconds$ """
print(end.tm_sec - start.tm_sec)@ আরজিরিওভিএল এর প্রতিক্রিয়ার অনুরূপ আমি দীর্ঘ চলমান কাজের জন্য একই লাইব্রেরিটি ব্যবহার করে ঘন্টা মিনিট সেকেন্ডে রূপান্তর করতে কিছুটা পরিবর্তন করেছি।
import time
start_time = time.time()
main()
seconds = time.time() - start_time
print('Time Taken:', time.strftime("%H:%M:%S",time.gmtime(seconds)))নমুনা আউটপুট
Time Taken: 00:00:08প্রথমে প্রশাসক হিসাবে কমান্ড প্রম্পট (সিএমডি) খোলার মাধ্যমে মানবিক বন্ধুত্বপূর্ণ প্যাকেজ ইনস্টল করুন এবং সেখানে টাইপ করুন -
pip install humanfriendly
কোড:
from humanfriendly import format_timespan
import time
begin_time = time.time()
# Put your code here
end_time = time.time() - begin_time
print("Total execution time: ", format_timespan(end_time))আউটপুট:
ব্যবহার করার জন্য metakermit এর আপডেট উত্তর পাইথন 2.7 স্বরূপ, আপনি প্রয়োজন হবে একঘেয়ে প্যাকেজ ।
কোডটি তখন নিম্নলিখিত হিসাবে থাকবে:
from datetime import timedelta
from monotonic import monotonic
start_time = monotonic()
end_time = monotonic()
print(timedelta(seconds=end_time - start_time))নিম্নলিখিত স্ক্রিপ্টগুলি ব্যবহার করে আমি চেষ্টা করেছি এবং সময়ের পার্থক্য পেয়েছি।
import time
start_time = time.perf_counter()
[main code here]
print (time.perf_counter() - start_time, "seconds")আপনি যদি মাইক্রোসেকেন্ডগুলিতে সময় পরিমাপ করতে চান, তবে আপনি পল ম্যাকগুইয়ার এবং নিকোজোর উত্তরগুলির উপর ভিত্তি করে নীচের সংস্করণটি ব্যবহার করতে পারেন - এটি পাইথন 3 কোড। আমি এতে কিছু রঙ যুক্ত করেছি:
import atexit
from time import time
from datetime import timedelta, datetime
def seconds_to_str(elapsed=None):
if elapsed is None:
return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
else:
return str(timedelta(seconds=elapsed))
def log(txt, elapsed=None):
colour_cyan = '\033[36m'
colour_reset = '\033[0;0;39m'
colour_red = '\033[31m'
print('\n ' + colour_cyan + ' [TIMING]> [' + seconds_to_str() + '] ----> ' + txt + '\n' + colour_reset)
if elapsed:
print("\n " + colour_red + " [TIMING]> Elapsed time ==> " + elapsed + "\n" + colour_reset)
def end_log():
end = time()
elapsed = end-start
log("End Program", seconds_to_str(elapsed))
start = time()
atexit.register(end_log)
log("Start Program")লগ () => ফাংশন যা সময়ের তথ্য প্রিন্ট করে।
txt ==> লগ করার প্রথম যুক্তি এবং সময়টিকে চিহ্নিত করার জন্য এর স্ট্রিং।
atexit ==> কর্মসূচি নিবন্ধ করার জন্য পাইথন মডিউলটি প্রোগ্রামটি প্রস্থান করার সময় কল করতে পারবেন।