# Python စွမ်းဆောင်ရည်- မူရင်း NumPy loops, callbacks နှင့် ပြောင်းလဲခြင်း ကုန်ကျစရိတ်များ

Published: 2026-10-17

CPU-သီးသန့် ဂဏန်းဆိုင်ရာ စမ်းသပ်မှုတစ်ခုသည် CPython loops, NumPy ဂဏန်းသင်္ချာ, Python callback wrapper နှင့် compiled Numba loop တို့မှတဆင့် တူညီသော တန်ဖိုးများကို စစ်ဆေးသည်။ Ready-input NumPy သည် အစတွင် အသာစီးရခဲ့သော်လည်း Python list များမှ ပြောင်းလဲခြင်းနှင့် ပြန်လည်ပြောင်းလဲခြင်းတို့ကြောင့် အသာစီးမှာ သရေနီးပါးအထိ လျော့ကျသွားသည်။ ဤအပိုင်းသည် execution boundary နှင့် အပလီကေးရှင်းတစ်ခု လိုအပ်သောရလဒ်ကို မည်သို့တိုင်းတာရမည်ကို ရှင်းပြထားသည်။

Canonical: https://thedailydiff.dev/my/video/2026-10-17-python-native-loops/

## ဤဗီဒီယိုတွင် ဖော်ပြထားသောအရာများ

- CPython သည် source code ကို bytecode အဖြစ် compile လုပ်သည်။ ထပ်ခါတလဲလဲ interpreter/object အလုပ်နှင့် typed native numeric loop တို့သည် မတူညီသော execution ပုံစံများဖြစ်သည်။
- Numeric NumPy ဂဏန်းသင်္ချာသည် typed batches များကို compiled operations များသို့ ပေးပို့နိုင်သည်။ ဂဏန်းသင်္ချာ loop သည် ရှိနေဆဲဖြစ်ပြီး views များသည် noncontiguous layout များ ရှိနိုင်သည်။
- ပြောင်းလဲခြင်းနှင့် လိုအပ်သော output representation ကို တိုင်းတာပါ။ ဤ run တွင် Python list များကို array များအဖြစ် ပြောင်းလဲခြင်းနှင့် ပြန်လည်ပြောင်းလဲခြင်းတို့သည် ကြီးမားသော ready-array lead ကို ဖျက်ပစ်ခဲ့သည်။
- သေးငယ်သော workloads များသည် သာမန် Python ကို နှစ်သက်နိုင်သည်။ အဘယ်ကြောင့်ဆိုသော် array-call ကုန်ကျစရိတ်များက အရေးကြီးသောကြောင့်ဖြစ်သည်။ ရှစ်ခုသော comprehension သည် ဤတိုင်းတာထားသော နှိုင်းယှဉ်မှုတွင် အနိုင်ရခဲ့သည်။
- np.vectorize သည် successive elements များအတွက် Python ကို ခေါ်ဆိုသည့် convenience wrapper တစ်ခုဖြစ်သည်။ batch interface တစ်ခုတည်းက native numerical execution ကို မဖော်ဆောင်နိုင်ပါ။
- Compiled Python-syntax loops များသည်လည်း မြန်နိုင်သည်။ caller အတွက် အရေးကြီးသည့်အခါ cold compilation/setup ကုန်ကျစရိတ်များကို ထည့်သွင်းပါ။
- Native execution, CPU SIMD, multithreading နှင့် GPU backends တို့သည် သီးခြားအယူအဆများဖြစ်သည်။ ရရှိနိုင်သော CPU features များသည် သီးခြား run တစ်ခုတွင် အသုံးပြုသည့် instructions များကို ခြေရာခံခြင်းမရှိပါ။

## အခန်းများ

- 0:00 အဘယ်ကြောင့် တူညီသော CPU သည် ပိုမိုမြန်ဆန်စွာ ပြီးစီးနိုင်သနည်း။
- 0:52 Python loop တစ်ခုသည် မည်သည့်အလုပ်များကို ထပ်ခါတလဲလဲ လုပ်ဆောင်သနည်း။
- 1:38 NumPy သည် loop ကို မည်သည့်နေရာသို့ ရွှေ့သနည်း။
- 2:13 မြန်ဆန်သည်ဆိုသည်မှာ GPU သို့မဟုတ် CPU cores အများအပြားကို ဆိုလိုပါသလား။
- 2:49 အထင်ကြီးစရာကောင်းသော speedup သည် မည်သည့်အချိန်တွင် ပျောက်ကွယ်သွားသနည်း။
- 3:28 မည်သည့် boundaries များသည် benchmark တွင် ပါဝင်သင့်သနည်း။
- 4:00 compiled Python loop တစ်ခုသည်လည်း မြန်ဆန်နိုင်ပါသလား။
- 4:56 np.vectorize သည် အမှန်တကယ် မည်သည့်အရာကို လုပ်ဆောင်သနည်း။
- 5:41 သင့် code တွင် မည်သည့်အရာကို ပြောင်းလဲသင့်သနည်း။

## ဘာသာပြန်ထားသော စာသားမှတ်တမ်း

မူရင်း အင်္ဂလိပ်စကားပြောမှ ဘာသာပြန်ထားသည်။ ရရှိနိုင်သော အသံနှင့် စာတန်းထိုးများကို YouTube မှ ထိန်းချုပ်ထားသည်။

### အဘယ်ကြောင့် တူညီသော CPU သည် ပိုမိုမြန်ဆန်စွာ ပြီးစီးနိုင်သနည်း။

0:00 Python က မြန်ဆန်ဖို့အတွက် ဘာသာစကားအသစ်တစ်ခု လိုအပ်တယ်လို့ သင်ထင်တယ်။ loop ရွှေ့ပြီးနောက် ကျွန်တော်တို့ရဲ့ batch ကို အဲဒီ CPU အတူတူက ပိုမြန်အောင် လုပ်ဆောင်ခဲ့တယ်။ အလုပ်တွေ ဘယ်ရောက်သွားလဲ။ မြန်နှုန်း ဘယ်တော့ ပျောက်သွားတာလဲ။ ဘယ် shortcut က Python ကို ပြန်ခေါ်လာလဲ။ ဒါက The Daily Diff ပါ၊ အတွင်းပိုင်းကို ကြည့်ရအောင်။ အဲဒီ shortcut ကို သတိထားပါ။ CPython က standard Python implementation ပါ။

0:17 သင့် source ကို bytecode အဖြစ် compile လုပ်ပြီး အဲဒီ instructions တွေကို interpreter မှာ run ပါတယ်။ NumPy က numerical library တစ်ခုဖြစ်ပြီး array တွေက ကြေညာထားတဲ့ data type နဲ့ တန်ဖိုးတွေကို ထိန်းသိမ်းထားပါတယ်။ သူ့ရဲ့ built in arithmetic က batch တစ်ခုလုံးကို compiled operations တွေဆီ ပေးပို့နိုင်ပါတယ်။ floating point တန်ဖိုးတစ်သန်း ယူပါ၊ တစ်ခုချင်းစီကို မြှောက်ပါ၊ ပြီးရင် မူရင်းတန်ဖိုးကို ပေါင်းပါ။ version တိုင်းက တူညီတဲ့တန်ဖိုးတွေရပြီး တူညီတဲ့အဖြေတွေ ထွက်လာပါတယ်။ တန်ဖိုးတွေက round လုပ်ရာမှာ ကွာခြားမှု မရှိအောင် သေးငယ်ပါတယ်။

0:40 ဒီစက်မှာ comprehension က milliseconds သုံးဆယ်ကျော် ကြာခဲ့တယ်။ NumPy က တစ်ခုတောင် မပြည့်ခဲ့ဘူး။ နှစ်ခုလုံးက CPU ပေါ်မှာပဲ run ခဲ့တာ။ ဒါက ဒီ workload အတွက် အသုံးဝင်တဲ့ အထောက်အထားပါ၊ ဒါပေမယ့် programming language တစ်ခုအတွက်တော့ ဆိုးရွားတဲ့ အထိမ်းအမှတ်ပါ။ ရိုးရှင်းတဲ့ loop နဲ့ စကြည့်ရအောင်။

### Python loop တစ်ခုသည် မည်သည့်အလုပ်များကို ထပ်ခါတလဲလဲ လုပ်ဆောင်သနည်း။

0:53 Python က နောက်ထပ်တန်ဖိုးကို ရယူတယ်၊ ဂဏန်းသင်္ချာလုပ်ပြီး အဖြေကို ထပ်ပေါင်းတယ်။ ပြီးရင် ဒါကို ထပ်လုပ်တယ်။ မြှောက်တာက ကုန်ကျစရိတ် နည်းတယ်။ နောက်ထပ် မြှောက်ဖို့ စီစဉ်တာ၊ ပြီးတော့ သူ့ပတ်ဝန်းကျင်က Python object တွေကို ကိုင်တွယ်တာက အကြိမ်တိုင်း အလုပ်တိုးစေတယ်။ ဒါက စမ်းသပ်ထားတဲ့ function ရဲ့ တကယ့် disassembly ပါ။ Iteration, multiplication နဲ့ addition တွေက bytecode instructions အဖြစ် ပေါ်လာပါတယ်။ Python versions နဲ့ interpreters တွေက မတူညီတဲ့ ရွေးချယ်မှုတွေ လုပ်ကြပါတယ်။

1:14 ဒီအချိန်တွေက ဖန်သားပြင်ပေါ်က Python 3.10 version နဲ့ သက်ဆိုင်ပါတယ်။ Python list တစ်ခုက objects တွေကို ကိုးကားထားတာကြောင့် မတူညီတဲ့ အရာတွေက list တစ်ခုကို မျှဝေသုံးစွဲနိုင်ပါတယ်။ ကျွန်တော်တို့ရဲ့ arithmetic အလုပ်က တစ်လျှောက်လုံး နံပါတ်တွေကိုပဲ သုံးတယ်။ အထပ်ထပ်အခါခါ ဝန်ဆောင်မှု တောင်းခံနေချိန်မှာ အထွေထွေ စီစဉ်မှုအတွက် ပေးချေနေရပါတယ်။ ကော်ဖီတစ်မျိုးတည်းကို အကြိမ်တစ်သန်း မှာယူပြီး ခွက်တိုင်းအတွက် form အသစ်ဖြည့်နေရသလိုမျိုး မြင်ယောင်ကြည့်ပါ။ ကော်ဖီစက်က အဆင်ပြေပါတယ်။

1:36 စာရွက်စာတမ်းက ကိုယ်ပိုင်အသက်မွေးဝမ်းကျောင်း ဖြစ်လာပါပြီ။

### NumPy သည် loop ကို မည်သည့်နေရာသို့ ရွှေ့သနည်း။

1:38 NumPy က သဘောတူညီချက်ကို ပြောင်းလဲလိုက်ပါတယ်။ ဒီ array က ကြေညာထားတဲ့ type တစ်ခုနဲ့ fixed size floating point တန်ဖိုးတွေကို ထိန်းသိမ်းထားပါတယ်။ ကျွန်တော်တို့ရဲ့ array က contiguous ဖြစ်တာကြောင့် သူ့ရဲ့တန်ဖိုးတွေက memory မှာ အတူတကွ ရှိနေပါတယ်။ Views တွေက တခြား layouts တွေ ရှိနိုင်ပါတယ်။ ဂဏန်းသင်္ချာ operation က သူလက်ခံရရှိမယ့် data အမျိုးအစားကို သိပါတယ်။ ခေါ်ဆိုမှုက batch ကို native operation တစ်ခုဆီ ပေးပို့ပါတယ်။ loop က compiled code ထဲမှာရှိတဲ့ တန်ဖိုးတွေကို ဆက်လက် သွားရောက်စစ်ဆေးနေပါတယ်။ အဲဒီအလုပ်တစ်လျှောက်လုံး type အကြောင်းကို ပြန်လည်အသုံးပြုနိုင်ပါတယ်။

2:00 Python က အလုပ်ကို လွှဲပြောင်းပေးတဲ့သူအဖြစ် ရှိနေဆဲပါ။ Itamar Turner Trauring က Python Speed မှာ ခြားနားချက်ကို ရှင်းပြထားပါတယ်။ Batch interfaces, native implementations နဲ့ processor vector instructions တွေက သီးခြားအရာတွေပါ။ function name က သက်သေအထောက်အထား အနည်းငယ်သာ ပေးပါတယ်။

### မြန်ဆန်သည်ဆိုသည်မှာ GPU သို့မဟုတ် CPU cores အများအပြားကို ဆိုလိုပါသလား။

2:13 ဒီရလဒ်က CPU ပေါ်မှာ NumPy ကို အသုံးပြုခဲ့တာပါ။ CuPy လို GPU backend တစ်ခုက array တွေနဲ့ operations တွေအတွက် မတူညီတဲ့ နေရာကို ရွေးချယ်ပါတယ်။ GPU ဝယ်တာက ဒီရိုးရိုးရှင်းရှင်း Python loop ကို အရင် run ခဲ့တဲ့နေရာမှာပဲ ဆက် run နေစေပါတယ်။ CPU vector instructions တွေက တန်ဖိုးအတော်များများကို တစ်ပြိုင်နက်တည်း လုပ်ဆောင်နိုင်ပါတယ်။ NumPy မှာ ထောက်ပံ့ထားတဲ့ kernels တွေကို ရွေးချယ်ဖို့ ယန္တရားတွေ ရှိပါတယ်။ ကျွန်တော်တို့ရဲ့ runtime က ရရှိနိုင်တဲ့ features တွေကို အစီရင်ခံပေမယ့် ဒီ expression ရဲ့ instructions တွေကို ခြေရာခံခြင်းမရှိပါဘူး။ တိုင်းတာထားတဲ့ gain အားလုံးကို vector instructions တွေကို ပေးတာက သက်သေအထောက်အထားကို လွန်ကဲစွာ ရောင်းစားတာ ဖြစ်ပါလိမ့်မယ်။

2:40 GPU shopping cart က ပိတ်ထားနိုင်ပါတယ်။ ဝယ်ယူမှုကိုပါ ဖျက်သိမ်းပေးတဲ့ performance fix တစ်ခုက တကယ်ကို ကျေနပ်စရာကောင်းပါတယ်။ ကံမကောင်းစွာဖြင့် benchmark က ဆက်လက်ရှိနေပါတယ်။

### အထင်ကြီးစရာကောင်းသော speedup သည် မည်သည့်အချိန်တွင် ပျောက်ကွယ်သွားသနည်း။

2:49 တန်ဖိုး ရှစ်ခုနဲ့ဆိုရင် comprehension က အနိုင်ရခဲ့ပါတယ်။ array machinery ကို ခေါ်ဆိုတဲ့ကုန်ကျစရိတ်က သေးငယ်တဲ့အလုပ်ထက် ပိုများခဲ့ပါတယ်။ ပိုကြီးတဲ့ ready arrays တွေက အသာစီးရသွားတယ်။ ကျွန်တော်တို့က ထပ်ခါတလဲလဲ စမ်းသပ်မှုတွေနဲ့ warmed process ကို သုံးခဲ့ပါတယ်။ ပိုသစ်တဲ့ Python builds တွေက crossover ကို ပြောင်းလဲနိုင်ပါတယ်။ ပြီးရင် application လိုအပ်တာကို ပြောင်းလဲပါ။ Python list တစ်ခုနဲ့ စပြီး Python list အသစ်တစ်ခုနဲ့ အဆုံးသတ်ပါ။ NumPy က input ကို array အဖြစ် ပြောင်းပြီး အဖြေကို Python

3:11 objects တွေအဖြစ် ပြန်ပြောင်းရမယ်။ အဲဒီအဆင့်တွေက သင့် application က လိုအပ်တယ်ဆိုရင် ဘောင်ဝင်ပါတယ်။ တန်ဖိုးတစ်သန်းမှာ အဲဒီ complete path က milliseconds နှစ်ဆယ်ကျော် ကြာခဲ့တယ်။ comprehension ကလည်း နှစ်ဆယ်ကျော်လောက် ကြာခဲ့ပါတယ်။ ကျွန်တော်တို့ရဲ့ သိသာထင်ရှားတဲ့ ဦးဆောင်မှုက သရေနီးပါး ဖြစ်သွားတယ်။ မြန်တဲ့အပိုင်းက တကယ်ပါ။ အားသာချက်က data ကို သူ့ရဲ့ numerical form မှာ ရှိနေခွင့်ပြုတာပေါ်မှာ မူတည်ပါတယ်။

### မည်သည့် boundaries များသည် benchmark တွင် ပါဝင်သင့်သနည်း။

3:28 data ကို လိုက်နာပါ။ နောက်ထပ် operation က array ကို လက်ခံတယ်ဆိုရင် array ကိုပဲ ထားပါ။ list တွေနဲ့ array တွေကြား ထပ်ခါတလဲလဲ ပြောင်းလဲနေရင် အဲဒီ crossing တွေကို တိုင်းတာပါ။ ဈေးကြီးတဲ့ handoff မတိုင်ခင် ရပ်တန့်တာက မှားယွင်းတဲ့ မေးခွန်းအတွက် မှန်ကန်တဲ့ နံပါတ်တွေကို ပေးပါတယ်။ ဒီ array ကို မြှောက်တာက temporary result တစ်ခု ဖန်တီးပါတယ်။ မူရင်းတန်ဖိုးတွေကို ပေါင်းထည့်တာက output ကို ဖန်တီးပါတယ်။ Native execution က memory လိုအပ်ပြီး data ကို ရွှေ့ပြောင်းပါတယ်။

3:47 တချို့ operations တွေက output buffer ကို လက်ခံတာကြောင့် သင့် code က ဘေးကင်းစွာ ပြန်လည်အသုံးပြုနိုင်တဲ့အခါ allocations တွေကို လျှော့ချပေးပါတယ်။ လှပတဲ့ line တစ်ခုက ကြီးမားတဲ့ buffers အများအပြားကို မှာယူနိုင်ပါတယ်။ Python Speed က ဒီပြဿနာကိုလည်း ထောက်ပြထားပါတယ်။ allocator က သင့်ရဲ့ အလှအပကို ထူးထူးခြားခြား ဂရုမစိုက်ပါဘူး။

### compiled Python loop တစ်ခုသည်လည်း မြန်ဆန်နိုင်ပါသလား။

4:00 loop syntax ကိုလည်း ထိန်းသိမ်းပြီး သူ့ရဲ့ execution ကို ပြောင်းလဲနိုင်ပါတယ်။ Numba က ထောက်ပံ့ထားတဲ့ numerical Python functions တွေကို native code အဖြစ် compile လုပ်နိုင်ပါတယ်။ ဒါက ကျွန်တော်တို့ရဲ့ test က loop ပါ၊ သူ့ရဲ့ compiler decorator နဲ့ပါ။ သူက for လို့ ဆက်ပြောနေတုန်းပါပဲ။ ဈေးကြီးတဲ့ interpreter path က ပြောင်းလဲသွားပါပြီ။ compile လုပ်ပြီးနောက် ဒီ loop က ready arrays တွေနဲ့ဆိုရင် half a millisecond ထက် နည်းပါးစွာ ကြာခဲ့ပါတယ်။ compile လုပ်တာကိုယ်တိုင်က ဒီ run မှာ တစ်စက္ကန့်လောက် ကြာခဲ့ပါတယ်။ အဲဒီ setup ကုန်ကျစရိတ်ကို ထပ်ခါတလဲလဲ တိုင်းတာမှုတွေကနေ ဖယ်ထုတ်ခဲ့ပါတယ်။

4:22 ဒါကြောင့် သေးငယ်တဲ့ one off အလုပ်တစ်ခုက မတူညီတဲ့ နှိုင်းယှဉ်မှုကို ခံထိုက်ပါတယ်။ Numba ရဲ့ ကိုယ်ပိုင်လမ်းညွှန်က explicit loops တွေကို ပျော်ပျော်ရွှင်ရွှင် ပြသထားပါတယ်။ hot path ကို မတွေ့ရှိသေးခင်မှာ language migration စတင်တာက profiler ကို ဖွင့်ခြင်းကို ရှောင်ရှားဖို့အတွက် ရှုပ်ထွေးတဲ့ နည်းလမ်းတစ်ခုပါပဲ။ ပထမဆုံး ဘာက အချိန်ကုန်ဆုံးလဲဆိုတာ ရှာပါ။ Network waits, object parsing နဲ့ bulk arithmetic တွေက မတူညီတဲ့ fixes တွေ လိုအပ်ပါတယ်။ Native array operations တွေက calculation နဲ့ data က ကိုက်ညီတဲ့အခါ ကူညီပေးပါတယ်။

4:43 သင့် caller က အမှန်တကယ် လိုအပ်တဲ့ ရလဒ်ကို တိုင်းတာပါ။ ကဲ အဲဒီ shortcut အတွက်ပါပဲ။ သင့်မှာ Python function တစ်ခုရှိပြီး array တစ်ခုကို လက်ခံစေချင်တယ်။ vectorize လို့ ခေါ်တဲ့ wrapper က ပျောက်ဆုံးနေတဲ့ performance ခလုတ်လိုပဲ။ သူ့ရဲ့ documentation မှာ အရေးကြီးတဲ့ ဝါကျတစ်ကြောင်း စောင့်နေပါတယ်။

### np.vectorize သည် အမှန်တကယ် မည်သည့်အရာကို လုပ်ဆောင်သနည်း။

4:56 NumPy က သူ့ရဲ့ vectorize wrapper ကို အဓိကအားဖြင့် အဆင်ပြေစေရန်အတွက် ပေးထားတယ်လို့ ပြောပါတယ်။ သူ့ရဲ့ implementation က အခြေခံအားဖြင့် for loop တစ်ခုပါပဲ။ wrapper က batches တွေကို လက်ခံပေမယ့် successive elements တွေအတွက် သင့် Python function ကို ဆက်ခေါ်နေပါတယ်။ interface က ပိုတိုသွားတယ်။ execution boundary က အလုပ်များနေတုန်းပဲ။ Python callback ကနေတဆင့် တူညီတဲ့တန်ဖိုးတွေ ပြန်ဝင်လာတာကို ကြည့်ပါ။ ready arrays တွေနဲ့ဆိုရင် ဒီ version က milliseconds ရှစ်ဆယ်ကျော် ကြာခဲ့ပါတယ်။ ဒါက ကျွန်တော်တို့ရဲ့ comprehension ထက် ပိုနှေးတယ်။

5:18 အသုံးဝင်တဲ့ broadcasting wrapper က သင်ဖယ်ရှားဖို့ ကြိုးစားနေတဲ့ exact per element အလုပ်ကို ထိန်းသိမ်းထားနိုင်ပါတယ်။ batch interface နောက်ကွယ်က implementation ကို စစ်ဆေးပါ၊ ကိုက်ညီတဲ့ data ကို သူ့ရဲ့ အသုံးဝင်တဲ့ ပုံစံမှာ ထိန်းသိမ်းပါ၊ ပြီးတော့ ပြောင်းလဲခြင်းကို နှိုင်းယှဉ်မှုမှာ ထည့်သွင်းပါ။ Native, callback နဲ့ compiled loops တွေက caller ရဲ့ နေရာကနေ ကြည့်ရင် ဆင်တူနိုင်ပါတယ်။ vectorize ဆိုတဲ့ နာမည်က သင့်နာရီက ဘယ်တော့မှ လက်မှတ်မထိုးခဲ့တဲ့ ကတိတစ်ခု ပေးခဲ့တာပါ။ အဆင်ပြေမှုက သင်လိုအပ်တာဆိုရင် သူ့ကို ထိန်းသိမ်းထားပါ။ performance အတွက် run နေတဲ့ loop ကို စစ်ဆေးပါ။

### သင့် code တွင် မည်သည့်အရာကို ပြောင်းလဲသင့်သနည်း။

5:41 ကျွန်ုပ်၏ စီရင်ချက်မှာ တိုင်းတာထားသော numerical hot path ကို batch လုပ်ရန် SHIP IT ဖြစ်သည်။ သာမန် loops များသည် ကောင်းမွန်စွာ အလုပ်လုပ်နေပါက ၎င်းတို့ကို ထိန်းသိမ်းထားပါ။ အလုပ် ဘယ်မှာ ဖြစ်ပျက်နေလဲ၊ နောက်ထပ် caller ဘာလိုအပ်လဲဆိုတာ စစ်ဆေးပါ။ Subscribe လုပ်ပါ၊ ခေါင်းလောင်းကို နှိပ်ပါ၊ ပြီးတော့ သင်သာဆိုရင် မတူညီစွာ တံဆိပ်တပ်မလားဆိုတာ comments မှာ ပြောပြပါ ကျွန်တော် Niko ပါ Axrisi ကပါ။ တာဝန်ယူမှုဖြင့် ပေါင်းစပ်ပါ။ တာဝန်ယူမှုဖြင့် ပေါင်းစပ်ပါ။

## ရင်းမြစ်များ

- [Universal functions (ufunc) basics — NumPy 2.2](https://numpy.org/doc/2.2/user/basics.ufuncs.html) — NumPy
- [The N-dimensional array — NumPy 2.2](https://numpy.org/doc/2.2/reference/arrays.ndarray.html) — NumPy
- [numpy.vectorize — convenience and performance notes](https://numpy.org/doc/2.2/reference/generated/numpy.vectorize.html) — NumPy
- [CPU/SIMD optimizations — NumPy 2.2](https://numpy.org/doc/2.2/reference/simd/index.html) — NumPy
- [dis — Disassembler for Python bytecode](https://docs.python.org/3.10/library/dis.html) — Python Software Foundation
- [CPython 3.10.12 list representation](https://github.com/python/cpython/blob/v3.10.12/Include/cpython/listobject.h) — CPython contributors
- [The limits of Python vectorization as a performance technique](https://pythonspeed.com/articles/vectorization-python-alternatives/) — Itamar Turner-Trauring / Python⇒Speed
- [Performance Tips](https://numba.readthedocs.io/en/stable/user/performance-tips.html) — Numba
- [Basics of CuPy](https://docs.cupy.dev/en/stable/user_guide/basic.html) — CuPy