Python ၏ timeit module ဖြင့် လုပ်ဆောင်ချိန်ကို တိုင်းတာပါ။

Python စံစာကြည့်တိုက်၏ timeit module ကိုအသုံးပြုခြင်းဖြင့်၊ သင်သည် သင့်ကုဒ်ရှိ လုပ်ငန်းစဉ်တစ်ခု၏ လုပ်ဆောင်ချိန်ကို အလွယ်တကူ တိုင်းတာနိုင်ပါသည်။ ၎င်းသည် အမြန်စစ်ဆေးရန်အတွက် အသုံးဝင်သည်။

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

ဤနေရာတွင် အောက်ပါကိစ္စရပ်နှစ်ခုကို ဆွေးနွေးပါမည်။

• Python ဖိုင်တွင် တိုင်းတာခြင်း-timeit.timeit()၊timeit.repeat()
• Jupyter Notebook ဖြင့် တိုင်းတာခြင်း-%timeit၊%%timeit

အခြားနည်းလမ်းမှာ ပရိုဂရမ်ရှိ ကြာမြင့်ချိန်ကို တိုင်းတာရန် time.time() ကို အသုံးပြုရန်ဖြစ်သည်။

Python ဖိုင်များတွင် တိုင်းတာမှုများ- timeit.timeit(), timeit.repeat()

ဥပမာအနေဖြင့်၊ n ဆက်တိုက်ကိန်းများကို တွက်ချက်ပေးသည့် ရိုးရှင်းသောလုပ်ဆောင်ချက်၊ test(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 ဖြစ်သည်။ အချိန်ကုန်သော လုပ်ငန်းစဉ်တစ်ခုအတွက် ပုံသေတန်ဖိုးကို သင်အသုံးပြုပါက၊ ၎င်းသည် အချိန်များစွာယူမည်ကို သတိပြုပါ။

globals() ကို argument globals အဖြစ်ဖြတ်သန်းခြင်းဖြင့်၊ code ကို global namespace တွင် လုပ်ဆောင်မည်ဖြစ်ပါသည်။
၎င်းမပါဘဲ၊ အထက်ဖော်ပြပါဥပမာတွင် function test နှင့် variable n ကို အသိအမှတ်မပြုပါ။

သတ်မှတ်ရမည့်ကုဒ်သည် string တစ်ခုအစား ခေါ်ဆိုနိုင်သော အရာတစ်ခု ဖြစ်နိုင်သည်၊ ထို့ကြောင့် ၎င်းအား အကြောင်းပြချက်မရှိဘဲ lambda စကားရပ်အဖြစ် သတ်မှတ်နိုင်သည်။ ဤကိစ္စတွင်၊ argument globals ကိုသတ်မှတ်ရန်မလိုအပ်ပါ။

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

ရလဒ်၏ယူနစ်သည် စက္ကန့်ဖြစ်သည်။ ဤတွင်၊ output သည် execution တစ်ခုလျှင် processing time ကို executions အရေအတွက်ဖြင့် ပိုင်းခြားသည်။

သင်မခွဲပါက၊ ကွပ်မျက်မှုအရေအတွက်ကိုတိုးလာသည်နှင့်အမျှ ရလဒ်တန်ဖိုးသည် ပိုမိုကြီးမားလာမည်ဖြစ်သည်။

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]

Jupyter Notebook ဖြင့် တိုင်းတာခြင်း-%timeit, %%timeit

Jupyter Notebook (IPython) တွင်၊ သင်သည် အောက်ပါ မှော်ကွန်မန်းများကို အသုံးပြုနိုင်သည်။ timeit module ကိုတင်သွင်းရန်မလိုအပ်ပါ။

• %timeit
• %%timeit

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

% အချိန်ကိုက်

%timeit တွင်၊ command line arguments ကဲ့သို့ space ခြားထားသော ပစ်မှတ်ကုဒ်ကို သတ်မှတ်ပါ။

မူရင်းအားဖြင့်၊ 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)

အချိန် %%

ဆဲလ်တစ်ခုလုံး၏ လုပ်ဆောင်ချိန်ကို တိုင်းတာရန် magic command %%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 ကိုရေးပါ၊ ဒါကြောင့် အသုံးပြုရတာ အလွယ်ဆုံးပါပဲ။