Python ના timeit મોડ્યુલ વડે પ્રોસેસિંગ સમયને માપો.

પાયથોન સ્ટાન્ડર્ડ લાઇબ્રેરીના ટાઇમઇટ મોડ્યુલનો ઉપયોગ કરીને, તમે તમારા કોડમાં પ્રક્રિયાના અમલના સમયને સરળતાથી માપી શકો છો. આ ઝડપી તપાસ માટે ઉપયોગી છે.

• timeit — Measure execution time of small code snippets — Python 3.10.0 Documentation

નીચેના બે કેસની અહીં ચર્ચા કરવામાં આવશે.

• પાયથોન ફાઇલમાં માપો:timeit.timeit(),timeit.repeat()
• જ્યુપીટર નોટબુક સાથે માપન:%timeit,%%timeit

પ્રોગ્રામમાં વીતેલા સમયને માપવા માટે time.time() નો ઉપયોગ કરવાની બીજી રીત છે.

Python ફાઇલોમાં માપન: timeit.timeit(), timeit.repeat()

ઉદાહરણ તરીકે, અમે એક સરળ ફંક્શન, ટેસ્ટ(n) ના પ્રોસેસિંગ સમયને માપીશું, જે n સળંગ સંખ્યાઓના સરવાળાની ગણતરી કરે છે.

import timeit

def test(n):
    return sum(range(n))

n = 10000
loop = 1000

result = timeit.timeit('test(n)', globals=globals(), number=loop)
print(result / loop)
# 0.0002666301020071842

જો તમે timeit.timeit() ફંક્શનમાં સ્ટ્રિંગ તરીકે માપવા માંગતા કોડને પાસ કરો છો, તો તે NUMBER વખત એક્ઝિક્યુટ થશે અને તેમાં લાગેલો સમય પરત કરવામાં આવશે.
નંબર માટે ડિફોલ્ટ મૂલ્ય 1,000,000 છે. નોંધ કરો કે જો તમે સમય લેતી પ્રક્રિયા માટે ડિફૉલ્ટ મૂલ્યનો ઉપયોગ કરો છો, તો તે ઘણો સમય લેશે.

વૈશ્વિક() ને દલીલ વૈશ્વિક તરીકે પસાર કરીને, કોડ વૈશ્વિક નેમસ્પેસમાં ચલાવવામાં આવશે.
આ વિના, ફંક્શન ટેસ્ટ અને ચલ n ઉપરના ઉદાહરણમાં ઓળખાતા નથી.

ઉલ્લેખિત કરવા માટેનો કોડ શબ્દમાળાને બદલે કૉલેબલ ઑબ્જેક્ટ હોઈ શકે છે, તેથી તેને કોઈ દલીલો વિના લેમ્બડા એક્સપ્રેશન તરીકે સ્પષ્ટ કરી શકાય છે; આ કિસ્સામાં, દલીલ વૈશ્વિક સ્પષ્ટ કરવાની જરૂર નથી.

result = timeit.timeit(lambda: test(n), number=loop)
print(result / loop)
# 0.00027574066299712287

પરિણામનું એકમ સેકન્ડ છે. અહીં, આઉટપુટ એ એક્ઝેક્યુશનની સંખ્યા દ્વારા વિભાજિત એક્ઝેક્યુશન દીઠ પ્રક્રિયા સમય છે.

જો તમે વિભાજન નહીં કરો, તો પરિણામની કિંમત ફક્ત મોટી થઈ જશે કારણ કે તમે ફાંસીની સંખ્યામાં વધારો કરશો.

print(timeit.timeit(lambda: test(n), number=1))
print(timeit.timeit(lambda: test(n), number=10))
print(timeit.timeit(lambda: test(n), number=100))
# 0.0003999490290880203
# 0.0038685189792886376
# 0.03517670702422038

timeit.repeat() ફંક્શનનો ઉપયોગ કરીને, timeit() ને વારંવાર એક્ઝિક્યુટ કરી શકાય છે. પરિણામ યાદી તરીકે મેળવવામાં આવશે.

repeat = 5
print(timeit.repeat(lambda: test(n), repeat=repeat, number=100))
# [0.044914519996382296, 0.039663890027441084, 0.02868645201670006, 0.022745631984435022, 0.023260265996214002]

જ્યુપીટર નોટબુક સાથે માપન:%timeit, %%timeit

Jupyter Notebook (IPython) માં, તમે નીચેના જાદુઈ આદેશોનો ઉપયોગ કરી શકો છો; timeit મોડ્યુલ આયાત કરવાની જરૂર નથી.

• %timeit
• %%timeit

• Built-in magic commands: %timeit — IPython 7.30.0 documentation

% timeit

%timeit માં, આદેશ વાક્ય દલીલો જેવી જગ્યા દ્વારા અલગ કરેલ લક્ષ્ય કોડનો ઉલ્લેખ કરો.

મૂળભૂત રીતે, નંબર અને timeit.timeit() માં પુનરાવર્તન આપોઆપ નક્કી થાય છે. તમે તેમને -n અને -r વિકલ્પો સાથે પણ સ્પષ્ટ કરી શકો છો.

પરિણામો સરેરાશ અને પ્રમાણભૂત વિચલન તરીકે ગણવામાં આવે છે.

%timeit test(n)
# 259 µs ± 4.87 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit -r 3 -n 10000 test(n)
# 237 µs ± 6.44 µs per loop (mean ± std. dev. of 3 runs, 10000 loops each)

%% સમય

જાદુઈ આદેશ %%timeit નો ઉપયોગ સમગ્ર કોષના પ્રોસેસિંગ સમયને માપવા માટે થઈ શકે છે.

ઉદાહરણ તરીકે, ચાલો NumPy નો ઉપયોગ કરીને સમાન પ્રક્રિયા ચલાવીએ. -n અને -r વિકલ્પો અવગણી શકાય છે.

અમે સમગ્ર સેલના પ્રોસેસિંગ સમયને માપતા હોવાથી, નીચેના ઉદાહરણમાં NumPy આયાત કરવાનો સમય શામેલ છે.

%%timeit -r 3 -n 10000
import numpy as np
a = np.arange(n)
np.sum(a)
# 19.7 µs ± 9.57 µs per loop (mean ± std. dev. of 3 runs, 10000 loops each)

%%timeit માટે દલીલ તરીકે લક્ષ્ય કોડનો ઉલ્લેખ કરવાની કોઈ જરૂર નથી. તમારે ફક્ત સેલની શરૂઆતમાં %%timeit લખવાનું છે, તેથી તેનો ઉપયોગ કરવો સૌથી સરળ છે.