පයිතන් වැඩසටහනක් ක්‍රියාත්මක කිරීමට මට කාලය ලැබෙන්නේ කෙසේද?

මට පයිතන් හි විධාන රේඛා වැඩසටහනක් ඇති අතර එය අවසන් කිරීමට ටික කාලයක් ගතවේ. ධාවනය අවසන් කිරීමට ගතවන කාලය දැන ගැනීමට මට අවශ්‍යය.

මම timeitමොඩියුලය දෙස බැලුවෙමි , නමුත් එය කුඩා කේත කුඩා කොටස් සඳහා පමණක් බව පෙනේ. මට මුළු වැඩසටහනම කාලය ගත කිරීමට අවශ්‍යයි.

පයිතන්හි සරලම ක්‍රමය:

import time
start_time = time.time()
main()
print("--- %s seconds ---" % (time.time() - start_time))

මෙය උපකල්පනය කරන්නේ ඔබේ වැඩසටහන ක්‍රියාත්මක වීමට අවම වශයෙන් තත්පරයෙන් දහයෙන් එකක්වත් ගත වන බවයි.

මුද්‍රණ:

--- 0.764891862869 seconds ---

මම මේක දැම්මා 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: mm: ss.sss ආකෘතියට සංයුති කරයි.)

සටහන: ඉහත කේතයේ පයිතන් 3 අනුවාදය මෙතැනින් හෝ මෙතැනින් සොයාගත හැකිය .

ලිනක්ස් හෝ යුනික්ස් හි:

$ time python yourprogram.py

වින්ඩෝස් හි, මෙම StackOverflow ප්‍රශ්නය බලන්න: වින්ඩෝස් විධාන රේඛාවේ විධානයක් ක්‍රියාත්මක කිරීමේ වේලාව මා ගණනය කරන්නේ කෙසේද?

තවත් වාචික ප්‍රතිදානය සඳහා,

$ 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: 0

පෝල් මැක්ගුවර්ගේ පිළිතුරට මම ඇත්තෙන්ම කැමතියි , නමුත් මම පයිතන් 3 භාවිතා කරමි. එබැවින් උනන්දුවක් දක්වන අය සඳහා: පයිතන් 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")

ඔබ මෙය ප්‍රයෝජනවත් යැයි සිතන්නේ නම්, ඔහු බොහෝ කාර්යයන් කළ පරිදි, ඔහුගේ පිළිතුර වෙනුවට මේ පිළිතුර වෙනුවට ඡන්දය දිය යුතුය.).

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))

CPU කාලය මැනීමට ඔබට පයිතන් ප්‍රොෆයිලර් cProfile භාවිතා කළ හැකි අතර ඊට අමතරව එක් එක් ශ්‍රිතය තුළ කොපමණ කාලයක් ගත වේද සහ එක් එක් ශ්‍රිතය කොපමණ වාරයක් කැඳවනු ලැබේ. ආරම්භ කළ යුත්තේ කොතැනදැයි නොදැන ඔබේ ස්ක්‍රිප්ටයේ ක්‍රියාකාරිත්වය වැඩි දියුණු කිරීමට අවශ්‍ය නම් මෙය ඉතා ප්‍රයෝජනවත් වේ. තවත් තොග පිටාර ගැලීමේ ප්‍රශ්නයකට මෙම පිළිතුර ඉතා හොඳයි. ප්‍රලේඛනය දෙස බැලීම සැමවිටම හොඳයි .

විධාන රේඛාවකින් cProfile භාවිතා කර ස්ක්‍රිප්ට් එකක් පැතිකඩ කරන්නේ කෙසේද යන්න පිළිබඳ උදාහරණයක් මෙන්න:

$ 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}

ලිනක්ස් සඳහා ඊටත් වඩා හොඳයි: 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

time.clock ()

3.3 අනුවාදයෙන් ඉවත් කර ඇත: මෙම ශ්‍රිතයේ හැසිරීම වේදිකාව මත රඳා පවතී: ඔබේ අවශ්‍යතා අනුව මනාව නිර්වචනය කළ හැසිරීමක් සඳහා perf_counter () හෝ process_time () භාවිතා කරන්න.

time.perf_counter ()

කාර්ය සාධන කවුන්ටරයක අගය (භාගික තත්පර වලින්) ආපසු ලබා දෙන්න, එනම් කෙටි කාලයක් මැනීම සඳහා ලබා ගත හැකි ඉහළම විභේදනය සහිත ඔරලෝසුව. එය කරන්නේ කාලය නින්දේ දී ගත සහ පද්ධති පුරා වේ ඇතුළත් වේ.

time.process_time ()

වත්මන් ක්‍රියාවලියේ පද්ධතියේ එකතුව සහ පරිශීලක CPU කාලයෙහි අගය (භාගික තත්පර වලින්) ආපසු එවන්න. එය කරන්නේ නැහැ නින්දේ දී ගත කාලය ඇතුළත් වේ.

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))

පහත දැක්වෙන ස්නිපෙට් මුද්‍රණයන් කාලය ගත කළේ ලස්සන මිනිස් කියවිය හැකි <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)

මම පෝල් මැක්ගුවර්ගේ පිළිතුරටද කැමති වූ අතර මගේ අවශ්‍යතාවන්ට සරිලන සන්දර්භ කළමනාකරු පෝරමයක් ඉදිරිපත් කළෙමි .

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))

දී IPython , "timeit" ඕනෑම තිර රචනය:

def foo():
    %run bar.py
timeit foo()

මම ටයිමිට් මොඩියුලය දෙස බැලුවෙමි, නමුත් එය කුඩා කේත කුඩා කොටස් සඳහා පමණක් බව පෙනේ. මට මුළු වැඩසටහනම කාලය ගත කිරීමට අවශ්‍යයි.

$ python -mtimeit -n1 -r1 -t -s "from your_module import main" "main()"

එය your_module.main()එක් වරක් ක්‍රියාත්මක වන අතර ගත වූ කාලය මුද්‍රණය කරයිtime.time() .

/usr/bin/timeපයිතන් අනුකරණය කිරීම සඳහා / usr / bin / time සමඟ පයිතන් උපප්‍රොසෙස් බලන්න : කාල තොරතුරු ග්‍රහණය කරගන්නේ කෙසේද නමුත් අනෙක් සියලුම ප්‍රතිදානයන් නොසලකා හරින්නේ කෙසේද?.

time.sleep()එක් එක් ශ්‍රිතය සඳහා CPU වේලාව මැනීමට (උදා: කාලය ඇතුළත් නොකරන්න ), ඔබට profileමොඩියුලය භාවිතා කළ හැකිය ( cProfileපයිතන් 2 හි):

$ python3 -mprofile your_module.py

ඔබට එකම ටයිමරයක් භාවිතා කිරීමට අවශ්‍ය නම් ඔබට ඉහත විධානය -pවෙත යා හැකියtimeitprofileමොඩියුලය භාවිතා ටයිමරය භාවිතා .

බලන්න ඔබට පයිතන් පිටපතක් පැතිකඩ කරන්නේ කෙසේද?

ජුපිටර් නෝට්බුක් භාවිතා කරන දත්ත පුද්ගලයින් සඳහා

සෛලයක, %%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 - කුඩා කේත ස්නිපෙට් ක්‍රියාත්මක කිරීමේ වේලාව මැනීම .

Line_profiler භාවිතා කරන්න .

line_profiler කේතයේ තනි රේඛා ක්‍රියාත්මක කිරීමට ගතවන කාලය විස්තර කරයි. පැතිකඩෙහි ඉහළ කොටස අඩු කිරීම සඳහා පැතිකඩ C හි සයිතන් හරහා ක්‍රියාත්මක වේ .

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

ප්‍රති results ල වනුයේ:

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 හෝ නවතම ඒවා සමඟ ක්‍රියා කරයි.

පසුව පිළිතුරු දෙන්න, නමුත් මම භාවිතා කරන්නේ 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 කේතය පුනරාවර්තනය කළ යුතු වාර ගණන තර්කය මඟින් නියම කරයි.
• නිරූපණය

@Rogeriopvl වෙතින් ලැබුණු ප්‍රතිචාරයට සමානව මම දිගු කාලීන රැකියා සඳහා එකම පුස්තකාලය භාවිතා කරමින් පැය තත්පර තත්පර බවට පරිවර්තනය කිරීම සඳහා සුළු වෙනස් කිරීමක් එක් කළෙමි.

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

මේ පෝල් McGuire පිළිතුර මට වෙනුවෙන් කටයුතු කරන. යමෙකුට එය ක්‍රියාත්මක කිරීමට අපහසුතාවයක් ඇති වුවහොත්.

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()ගොනුව ආයාත කිරීමෙන් පසු ඔබගේ වැඩසටහනෙන් අමතන්න .

ටයිමිට් යනු පයිතන් හි කුඩා පන්තියක ක්‍රියාකාරී කාලය ගණනය කිරීම සඳහා භාවිතා කරන පන්තියකි.

Default_timer යනු මෙම පන්තියේ ක්‍රමයක් වන අතර එය බිත්ති ඔරලෝසු වේලාව මැනීමට භාවිතා කරයි, CPU ක්‍රියාත්මක කිරීමේ වේලාව නොවේ. මේ අනුව වෙනත් ක්‍රියාවලි ක්‍රියාත්මක කිරීම මෙයට බාධා ඇති කළ හැකිය. මේ අනුව එය කුඩා කේත කොටස් සඳහා ප්රයෝජනවත් වේ.

කේතයේ නියැදියක් පහත පරිදි වේ:

from timeit import default_timer as timer

start= timer()

# Some logic

end = timer()

print("Time taken:", end-start)

පයිතන් වැඩසටහනක් ක්‍රියාත්මක කිරීමේ වේලාව පහත පරිදි වෙනස් නොවේ:

• එකම ඇල්ගොරිතම භාවිතා කරමින් එකම වැඩසටහන ඇගයීමට ලක් කළ හැකිය
• ධාවන කාලය ඇල්ගොරිතම අතර වෙනස් වේ
• ක්‍රියාත්මක වන කාලය අතර ධාවන කාලය වෙනස් වේ
• ධාවන කාලය පරිගණක අතර වෙනස් වේ
• කුඩා යෙදවුම් මත පදනම්ව ධාවන කාලය පුරෝකථනය කළ නොහැක

මෙයට හේතුව වඩාත් way ලදායී ක්‍රමය වන්නේ “වර්ධන පිළිවෙල ” භාවිතා කිරීම සහ එය නිසි ලෙස කිරීමට විශාල “ඕ” අංකනය ඉගෙන ගැනීමයි .

කෙසේ වෙතත්, ඔබට මෙම සරල ඇල්ගොරිතම භාවිතා කරමින් තත්පරයට නිශ්චිත යන්ත්‍ර ගණන් කිරීමේ පියවරයන්හි ඕනෑම පයිතන් වැඩසටහනක ක්‍රියාකාරිත්වය ඇගයීමට උත්සාහ කළ හැකිය: මෙය ඔබට ඇගයීමට අවශ්‍ය වැඩසටහනට අනුවර්තනය කරන්න

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)

පළමුව, කමාන්ඩ් ප්‍රොම්ප්ට් (සීඑම්ඩී) පරිපාලක ලෙස විවෘත කිරීමෙන් මානව හිතකාමී පැකේජයක් ස්ථාපනය කර එහි ටයිප් කරන්න - 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))

ප්‍රතිදානය:

මම පහත ස්ක්‍රිප්ට් භාවිතා කර කාල වෙනස සොයා බැලුවෙමි.

import time

start_time = time.perf_counter()
[main code here]
print (time.perf_counter() - start_time, "seconds")

පයිතන් 2.7 සඳහා මෙටාකර්මිට් යාවත්කාලීන කළ පිළිතුර භාවිතා කිරීමට , ඔබට ඒකාකාරී පැකේජය අවශ්‍ය වේ .

එවිට කේතය පහත පරිදි වේ:

from datetime import timedelta
from monotonic import monotonic

start_time = monotonic()
end_time = monotonic()
print(timedelta(seconds=end_time - start_time))

ඔබට මයික්‍රෝ තත්පර වලින් කාලය මැනීමට අවශ්‍ය නම්, ඔබට පෝල් මැක්ගුවර් සහ නිකොජෝගේ පිළිතුරු මත පදනම්ව පහත අනුවාදය භාවිතා කළ හැකිය - එය පයිතන් 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 ==> වැඩසටහනෙන් පිටවන විට ඔබට ඇමතිය හැකි කාර්යයන් ලියාපදිංචි කිරීම සඳහා පයිතන් මොඩියුලය.