# પાયથોન પરફોર્મન્સ: નેટિવ નમ્પી લૂપ્સ, કૉલબૅક્સ અને કન્વર્ઝન કિંમતો

Published: 2026-10-17

એક નિયંત્રિત CPU-માત્ર સંખ્યાત્મક પરીક્ષણ CPython લૂપ્સ, નમ્પી અંકગણિત, એક પાયથોન કૉલબૅક રેપર અને કમ્પાઇલ કરેલા નમ્બા લૂપ દ્વારા સમાન મૂલ્યોને અનુસરે છે. તૈયાર-ઇનપુટ નમ્પીને મોટી લીડ મળી હતી, જ્યારે પાયથોન સૂચિઓમાંથી અને પાછા રૂપાંતર કરવાથી તે લાભ લગભગ ટાઈ સુધી ઘટાડવામાં આવ્યો હતો. આ એપિસોડ એક્ઝેક્યુશન સીમા અને એપ્લિકેશનને જરૂરી પરિણામ કેવી રીતે માપવું તે સમજાવે છે.

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

## આ વીડિયોમાં શું આવરી લેવામાં આવ્યું છે

- CPython સ્રોતને બાઇટકોડમાં કમ્પાઇલ કરે છે. વારંવાર અર્થઘટન કરનાર/ઑબ્જેક્ટ કાર્ય અને ટાઈપ કરેલો નેટિવ ન્યુમેરિક લૂપ અલગ એક્ઝેક્યુશન વ્યવસ્થા છે.
- ન્યુમેરિક નમ્પી અંકગણિત કમ્પાઇલ કરેલી કામગીરીને ટાઈપ કરેલા બૅચ આપી શકે છે; અંકગણિત લૂપ હજુ પણ અસ્તિત્વમાં છે, અને વ્યૂમાં બિનસતત લેઆઉટ હોઈ શકે છે.
- રૂપાંતરણ અને જરૂરી આઉટપુટ રજૂઆતને માપો. આ રનમાં, પાયથોન સૂચિઓને એરેમાં રૂપાંતરિત કરવા અને પાછા રૂપાંતરિત કરવાથી મોટા તૈયાર-એરેની લીડ ભૂંસી નાખી.
- નાના વર્કલોડ સામાન્ય પાયથોનને પસંદ કરી શકે છે કારણ કે નિશ્ચિત એરે-કોલ ખર્ચ મહત્વપૂર્ણ છે. આ માપેલા સરખામણીમાં આઠ-મૂલ્ય કોમ્પ્રિહેન્શન જીત્યું.
- np.vectorize એ એક સુવિધા રેપર છે જે અનુગામી ઘટકો માટે પાયથોનને કૉલ કરે છે; એક બૅચ ઇન્ટરફેસ એકલા નેટિવ સંખ્યાત્મક એક્ઝેક્યુશન સ્થાપિત કરતું નથી.
- કમ્પાઇલ કરેલા પાયથોન-સિન્ટેક્સ લૂપ્સ પણ ઝડપી હોઈ શકે છે. જ્યારે કોલર માટે મહત્વપૂર્ણ હોય ત્યારે ઠંડા કમ્પાઇલેશન/સેટઅપ ખર્ચનો સમાવેશ કરો.
- નેટિવ એક્ઝેક્યુશન, CPU SIMD, મલ્ટિથ્રેડિંગ અને GPU બેકએન્ડ અલગ વિચારો છે. ઉપલબ્ધ CPU સુવિધાઓ ચોક્કસ રનમાં ઉપયોગમાં લેવાયેલી સૂચનાઓને ટ્રેસ કરતી નથી.

## પ્રકરણો

- 0:00 શા માટે સમાન CPU વહેલો સમાપ્ત થઈ શકે છે?
- 0:52 પાયથોન લૂપ કયું કામ પુનરાવર્તિત કરે છે?
- 1:38 નમ્પી લૂપને ક્યાં ખસેડે છે?
- 2:13 શું ઝડપીનો અર્થ GPU કે ઘણા CPU કોર થાય છે?
- 2:49 પ્રભાવશાળી ગતિ ક્યારે અદૃશ્ય થઈ જાય છે?
- 3:28 બેન્ચમાર્કમાં કઈ સીમાઓનો સમાવેશ થાય છે?
- 4:00 શું કમ્પાઇલ કરેલો પાયથોન લૂપ પણ ઝડપી હોઈ શકે છે?
- 4:56 np.vectorize ખરેખર શું ચલાવે છે?
- 5:41 તમારે તમારા કોડમાં શું બદલવું જોઈએ?

## અનુવાદિત ટ્રાન્સક્રિપ્ટ

મૂળ અંગ્રેજી કથામાંથી અનુવાદિત. ઉપલબ્ધ ઑડિઓ અને કૅપ્શન્સ YouTube દ્વારા નિયંત્રિત થાય છે.

### શા માટે સમાન CPU વહેલો સમાપ્ત થઈ શકે છે?

0:00 તમે વિચારો છો કે પાયથોનને ઝડપી થવા માટે નવી ભાષાની જરૂર છે. લૂપ ખસેડ્યા પછી સમાન CPU એ અમારી બેચ ઝડપી ચલાવી. કામ ક્યાં ગયું? ઝડપ ક્યારે અદૃશ્ય થઈ જાય છે? કયો શોર્ટકટ પાયથોનને પાછો લાવે છે? આ ધ ડેઇલી ડિફ છે, પડદા પાછળ. તે શોર્ટકટ પર નજર રાખો. CPython એ સ્ટાન્ડર્ડ પાયથોન અમલીકરણ છે.

0:17 તે તમારા સ્રોતને બાઇટકોડમાં કમ્પાઇલ કરે છે, પછી તે સૂચનાઓને ઇન્ટરપ્રીટરમાં ચલાવે છે. NumPy એ એક સંખ્યાત્મક લાઇબ્રેરી છે જેના એરેમાં જાહેર કરેલા ડેટા પ્રકાર સાથેના મૂલ્યો હોય છે. તેના બિલ્ટ-ઇન અંકગણિત કમ્પાઇલ કરેલી કામગીરીને આખી બેચ આપી શકે છે. એક મિલિયન ફ્લોટિંગ પોઈન્ટ મૂલ્યો લો, દરેકને સ્ક્વેર કરો, પછી મૂળ મૂલ્ય ઉમેરો. દરેક સંસ્કરણ સમાન મૂલ્યો મેળવે છે અને સુસંગત જવાબો આપે છે. રાઉન્ડિંગ તફાવતોને રેસમાંથી બહાર રાખવા માટે મૂલ્યો પૂરતા નાના હોય છે. આ મશીન પર, કોમ્પ્રિહેન્સન લગભગ ત્રીસ મિલિસેકન્ડ લીધું.

0:40 NumPy એ એક કરતા ઓછું લીધું. બંને CPU પર ચાલ્યા. આ કાર્યભાર માટે તે ઉપયોગી પુરાવો છે, અને એક પ્રોગ્રામિંગ ભાષા માટે ભયંકર શોકગાથા છે. સામાન્ય લૂપથી શરૂ કરો. પાયથોન આગલું મૂલ્ય મેળવે છે, અંકગણિત કરે છે, અને જવાબ ઉમેરે છે.

### પાયથોન લૂપ કયું કામ પુનરાવર્તિત કરે છે?

0:53 પછી તે ફરીથી તે કરે છે. ગુણાકાર સસ્તો છે. આગલા ગુણાકારની વ્યવસ્થા કરવી, અને તેની આસપાસના પાયથોન ઑબ્જેક્ટ્સને હેન્ડલ કરવું, દરેક વખતે કામ ઉમેરે છે. આ પરીક્ષણ કરેલા કાર્યનું વાસ્તવિક ડિસએસેમ્બલી છે. પુનરાવર્તન, ગુણાકાર અને ઉમેરણ બાઇટકોડ સૂચનાઓ તરીકે દેખાય છે. પાયથોન સંસ્કરણો અને ઇન્ટરપ્રીટર્સ જુદી જુદી પસંદગીઓ કરે છે. આ સમય સ્ક્રીન પરના સંસ્કરણના છે, જે પાયથોન ત્રણ પોઇન્ટ દસ છે.

1:14 પાયથોન સૂચિ ઑબ્જેક્ટના સંદર્ભો સંગ્રહિત કરે છે, તેથી જુદી જુદી પ્રકારની વસ્તુઓ એક સૂચિ શેર કરી શકે છે. અમારી અંકગણિત કાર્યમાં સમગ્રપણે સંખ્યાઓનો ઉપયોગ થાય છે. તે પુનરાવર્તિત સેવા વિનંતી કરતી વખતે સામાન્ય વ્યવસ્થા માટે ચૂકવણી કરે છે. એક મિલિયન વખત સમાન કોફી ઓર્ડર કરવાની અને દરેક કપ માટે તાજું ફોર્મ ભરવાની કલ્પના કરો. કોફી મશીન બરાબર છે. કાગળકામે પોતાની કારકિર્દી વિકસાવી છે. NumPy કરાર બદલે છે. આ એરે એક જાહેર કરેલા પ્રકાર સાથે નિશ્ચિત કદના ફ્લોટિંગ પોઇન્ટ મૂલ્યો ધરાવે છે.

1:36 અમારો એરે સલંગ છે, તેથી તેના મૂલ્યો મેમરીમાં એકસાથે બેસે છે.

### નમ્પી લૂપને ક્યાં ખસેડે છે?

1:38 વ્યૂમાં અન્ય લેઆઉટ હોઈ શકે છે. અંકગણિત કામગીરી જાણે છે કે તે કયા પ્રકારનો ડેટા મેળવી રહી છે. કોલ બેચને નેટિવ કામગીરીને સોંપે છે. કમ્પાઇલ કરેલા કોડની અંદર લૂપ હજુ પણ મૂલ્યોની મુલાકાત લે છે. તે તે કાર્ય દરમિયાન પ્રકારના જ્ઞાનનો ફરીથી ઉપયોગ કરી શકે છે. પાયથોન હજુ પણ નોકરી સોંપનાર વ્યક્તિ રહે છે. ઇટામર ટર્નર ટ્રોરીંગ પાયથોન સ્પીડમાં તફાવત સમજાવે છે. બેચ ઇન્ટરફેસ, નેટિવ અમલીકરણો અને પ્રોસેસર વેક્ટર સૂચનાઓ અલગ વસ્તુઓ છે.

2:00 કાર્યનું નામ બહુ ઓછા પુરાવા પૂરા પાડે છે. આ પરિણામ CPU પર NumPy નો ઉપયોગ કરતું હતું. CuPy જેવું GPU બેકએન્ડ એરે અને કામગીરી માટે અલગ સ્થાન પસંદ કરે છે. GPU ખરીદવાથી આ સામાન્ય પાયથોન લૂપ જ્યાં પહેલેથી જ ચાલી રહ્યું હતું ત્યાં ચાલુ રહે છે.

### શું ઝડપીનો અર્થ GPU કે ઘણા CPU કોર થાય છે?

2:13 CPU વેક્ટર સૂચનાઓ ઘણા મૂલ્યોને એકસાથે પ્રક્રિયા કરી શકે છે. NumPy પાસે સપોર્ટેડ કર્નલો પસંદ કરવા માટે મશીનરી છે. અમારો રનટાઇમ ઉપલબ્ધ સુવિધાઓની જાણ કરે છે, પરંતુ આ અભિવ્યક્તિની સૂચનાઓને ટ્રેસ કરતું નથી. વેક્ટર સૂચનાઓને સમગ્ર માપેલ લાભ આપવાથી પુરાવાને વધુ પડતો વેચી દેવામાં આવશે. GPU શોપિંગ કાર્ટ બંધ રાખી શકાય છે. પ્રદર્શન સુધારણા વિશે કંઈક ઊંડાણપૂર્વક સંતોષકારક છે જે ખરીદીને પણ રદ કરે છે. કમનસીબે, બેન્ચમાર્ક ચાલુ રહે છે. આઠ મૂલ્યો સાથે, કોમ્પ્રિહેન્સન જીત્યું.

2:40 એરે મશીનરીને કૉલ કરવાનો ખર્ચ નાના કાર્ય કરતા વધુ હતો. મોટા તૈયાર એરે આગળ વધ્યા. અમે વારંવાર ટ્રાયલ્સ અને વોર્મ્ડ પ્રક્રિયાનો ઉપયોગ કર્યો.

### પ્રભાવશાળી ગતિ ક્યારે અદૃશ્ય થઈ જાય છે?

2:49 નવા પાયથોન બિલ્ડ ક્રોસઓવર બદલી શકે છે. પછી એપ્લિકેશનને શું જોઈએ છે તે બદલો. પાયથોન સૂચિથી શરૂ કરો અને તાજી પાયથોન સૂચિ સાથે સમાપ્ત કરો. NumPy એ ઇનપુટને એરેમાં રૂપાંતરિત કરવું જોઈએ અને જવાબને પાછા પાયથોન ઑબ્જેક્ટ્સમાં ફેરવવો જોઈએ. જો તમારી એપ્લિકેશનને આ પગલાંની જરૂર હોય તો તે બિલમાં શામેલ હોવા જોઈએ. એક મિલિયન મૂલ્યો પર, તે સંપૂર્ણ પાથ લગભગ અઠ્ઠાવીસ મિલિસેકન્ડ લીધો. કોમ્પ્રિહેન્સન પણ લગભગ અઠ્ઠાવીસ લીધું. અમારી નાટકીય લીડ લગભગ ટાઈ બની ગઈ.

3:11 ઝડપી ભાગ વાસ્તવિક હતો. લાભ ડેટાને તેના સંખ્યાત્મક સ્વરૂપમાં રહેવા દેવા પર આધાર રાખતો હતો. ડેટાને અનુસરો. જો આગલી કામગીરી એરે સ્વીકારે છે, તો એરે રાખો. જો તમે વારંવાર સૂચિઓ અને એરે વચ્ચે રૂપાંતરિત કરો છો, તે ક્રોસિંગને માપો.

### બેન્ચમાર્કમાં કઈ સીમાઓનો સમાવેશ થાય છે?

3:28 મોંઘા હેન્ડઓફ પહેલાં અટકવાથી ખોટા પ્રશ્ન માટે સચોટ સંખ્યાઓ મળે છે. આ એરેનો ગુણાકાર એક અસ્થાયી પરિણામ બનાવે છે. મૂળ મૂલ્યો ઉમેરવાથી આઉટપુટ બને છે. નેટિવ એક્ઝેક્યુશનને હજુ પણ મેમરી અને ડેટાની ગતિની જરૂર છે. કેટલીક કામગીરી આઉટપુટ બફર સ્વીકારે છે, જ્યારે તમારો કોડ તેને સુરક્ષિત રીતે ફરીથી ઉપયોગ કરી શકે ત્યારે ફાળવણી ઘટાડે છે. એક સુંદર લાઇન કેટલાક મોટા બફરનો ઓર્ડર આપી શકે છે. પાયથોન સ્પીડ પણ આ સમસ્યાને બહાર કાઢે છે. ફાળવણી કરનાર તમારા સૌંદર્યશાસ્ત્ર પ્રત્યે નોંધપાત્ર રીતે ઉદાસીન છે.

3:47 તમે લૂપ સિન્ટેક્સ પણ રાખી શકો છો અને તેનું એક્ઝેક્યુશન બદલી શકો છો. Numba સપોર્ટેડ ન્યુમેરિકલ પાયથોન કાર્યોને નેટિવ કોડમાં કમ્પાઇલ કરી શકે છે. અહીં અમારા પરીક્ષણમાંથી લૂપ તેના કમ્પાઇલર ડેકોરેટર સાથે છે. તે હજુ પણ "for" કહે છે. મોંઘો ઇન્ટરપ્રીટર પાથ બદલાઈ ગયો છે.

### શું કમ્પાઇલ કરેલો પાયથોન લૂપ પણ ઝડપી હોઈ શકે છે?

4:00 કમ્પાઇલેશન પછી, તૈયાર એરે સાથે આ લૂપ અડધા મિલિસેકન્ડ કરતા ઓછો સમય લીધો. આ રનમાં કમ્પાઇલેશન પોતે લગભગ એક સેકન્ડ લીધું. તે સેટઅપ ખર્ચ વારંવારના સમયમાંથી બાકાત રાખવામાં આવ્યો હતો, તેથી નાના એક-ઓફ કાર્ય માટે અલગ સરખામણી યોગ્ય છે. Numba નો પોતાનો માર્ગદર્શિકા સ્પષ્ટ લૂપ્સ બતાવવા માટે ખુશ છે. હોટ પાથ શોધ્યા વિના ભાષા સ્થળાંતર શરૂ કરવું એ એક વિસ્તૃત રીત છે પ્રોફાઇલર ખોલવાનું ટાળવા માટે. પહેલા શોધો કે શું સમયનો વપરાશ કરે છે.

4:22 નેટવર્ક પ્રતીક્ષા, ઑબ્જેક્ટ પાર્સિંગ અને બલ્ક અંકગણિત જુદા જુદા સુધારાઓ માટે કહે છે. નેટિવ એરે કામગીરી ત્યારે મદદ કરે છે જ્યારે ગણતરી અને ડેટા યોગ્ય હોય. તમારા કોલરને ખરેખર કયું પરિણામ જોઈએ છે તે માપો. હવે તે શોર્ટકટ માટે. તમારી પાસે પાયથોન ફંક્શન છે અને તમે તેને એરે સ્વીકારવા માંગો છો. વેક્ટરાઇઝ નામનો રેપર ગુમ થયેલ પ્રદર્શન બટન જેવો લાગે છે. તેના દસ્તાવેજીકરણમાં એક મહત્વપૂર્ણ વાક્ય રાહ જોઈ રહ્યું છે. NumPy કહે છે કે તેનું વેક્ટરાઇઝ રેપર મુખ્યત્વે સુવિધા માટે પ્રદાન કરવામાં આવ્યું છે.

4:43 તેનું અમલીકરણ અનિવાર્યપણે એક ફોર લૂપ છે. રેપર બૅચ સ્વીકારે છે, પરંતુ અનુગામી ઘટકો માટે તમારા પાયથોન ફંક્શનને કૉલ કરવાનું ચાલુ રાખે છે. ઇન્ટરફેસ ટૂંકો થયો. એક્ઝેક્યુશન સીમા વ્યસ્ત રહી. એ જ મૂલ્યોને પાયથોન કૉલબૅક દ્વારા પાછા આવતા જુઓ.

### np.vectorize ખરેખર શું ચલાવે છે?

4:56 તૈયાર એરે સાથે, આ સંસ્કરણને લગભગ સિત્તેર મિલિસેકન્ડ લાગ્યા. તે અમારા કોમ્પ્રિહેન્સન કરતાં ધીમું હતું. એક ઉપયોગી બ્રોડકાસ્ટિંગ રેપર તમે દૂર કરવાનો પ્રયાસ કરી રહ્યા હતા તે ચોક્કસ પ્રતિ-એલિમેન્ટ કાર્યને જાળવી રાખી શકે છે. એક બૅચ ઇન્ટરફેસ પાછળના અમલીકરણને તપાસો, સુસંગત ડેટાને તેના ઉપયોગી સ્વરૂપમાં રાખો, અને સરખામણીમાં રૂપાંતરણનો સમાવેશ કરો. નેટિવ, કૉલબૅક અને કમ્પાઇલ કરેલા લૂપ્સ કોલરની ખુરશીમાંથી સમાન દેખાઈ શકે છે. વેક્ટરાઇઝ નામે એક વચન આપ્યું હતું જે તમારી સ્ટોપવોચે ક્યારેય સહી ન કરી. જ્યારે તમને સુવિધાની જરૂર હોય ત્યારે તેને રાખો. પ્રદર્શન માટે, ચાલતા લૂપને તપાસો.

5:18 મારો ચુકાદો છે કે માપેલ સંખ્યાત્મક હોટ પાથને બેચ કરવા માટે તેને SHIP IT કરો. જ્યારે તેઓ પહેલેથી જ સારી રીતે કામ કરે ત્યારે સામાન્ય લૂપ્સ રાખો. કામ ક્યાં થાય છે અને આગલા કોલરને શું જોઈએ છે તે તપાસો. સબ્સ્ક્રાઇબ કરો, બેલ દબાવો, અને ટિપ્પણીઓમાં મને કહો કે શું તમે તેને અલગ રીતે સ્ટેમ્પ કર્યું હોત. અને આજ માટે આ જ ડિફ છે. હું Axrisi થી Niko છું. જવાબદારીપૂર્વક મર્જ કરો. સબ્સ્ક્રાઇબ કરો, બેલ દબાવો, અને ટિપ્પણીઓમાં મને કહો કે શું તમે તેને અલગ રીતે સ્ટેમ્પ કર્યું હોત.

### તમારે તમારા કોડમાં શું બદલવું જોઈએ?

5:41 અને આજ માટે આ જ ડિફ છે. હું Axrisi થી Niko છું. જવાબદારીપૂર્વક મર્જ કરો. સબ્સ્ક્રાઇબ કરો, બેલ દબાવો, અને ટિપ્પણીઓમાં મને કહો કે શું તમે તેને અલગ રીતે સ્ટેમ્પ કર્યું હોત. અને આજ માટે આ જ ડિફ છે. હું Axrisi થી Niko છું. જવાબદારીપૂર્વક મર્જ કરો.

## સ્ત્રોતો

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