ਪਾਈਥਨ ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਟਾਈਮਮਿਟ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਤੁਸੀਂ ਆਪਣੇ ਕੋਡ ਵਿੱਚ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਟਾਈਮ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਮਾਪ ਸਕਦੇ ਹੋ। ਇਹ ਇੱਕ ਤੇਜ਼ ਜਾਂਚ ਲਈ ਲਾਭਦਾਇਕ ਹੈ।
ਹੇਠਾਂ ਦਿੱਤੇ ਦੋ ਮਾਮਲਿਆਂ ਬਾਰੇ ਇੱਥੇ ਚਰਚਾ ਕੀਤੀ ਜਾਵੇਗੀ।
- ਪਾਈਥਨ ਫਾਈਲ ਵਿੱਚ ਮਾਪੋ:
timeit.timeit(),timeit.repeat() - ਜੁਪੀਟਰ ਨੋਟਬੁੱਕ ਨਾਲ ਮਾਪ:
%timeit,%%timeit
ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਲੰਘੇ ਸਮੇਂ ਨੂੰ ਮਾਪਣ ਲਈ time.time() ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਇੱਕ ਹੋਰ ਤਰੀਕਾ ਹੈ।
ਪਾਈਥਨ ਫਾਈਲਾਂ ਵਿੱਚ ਮਾਪ: 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
ਜੁਪੀਟਰ ਨੋਟਬੁੱਕ (IPython) ਵਿੱਚ, ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਜਾਦੂਈ ਕਮਾਂਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ; timeit ਮੋਡੀਊਲ ਨੂੰ ਆਯਾਤ ਕਰਨ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ।
%timeit%%timeit
%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 ਲਿਖਣਾ ਹੈ, ਇਸਲਈ ਇਸਨੂੰ ਵਰਤਣਾ ਸਭ ਤੋਂ ਆਸਾਨ ਹੈ।
