# பைதான் செயல்திறன்: நேட்டிவ் NumPy சுழல்கள், கால்பேக்குகள் மற்றும் மாற்றுச் செலவுகள்

Published: 2026-10-17

ஒரு கட்டுப்படுத்தப்பட்ட CPU-மட்டுமே கொண்ட எண் சோதனை, CPython சுழல்கள், NumPy எண்கணிதம், ஒரு பைதான் கால்பேக் ரேப்பர் மற்றும் தொகுக்கப்பட்ட Numba சுழல் வழியாக ஒத்த மதிப்புகளைப் பின்தொடர்கிறது. தயாரான உள்ளீட்டு NumPy ஒரு பெரிய முன்னிலை பெற்றது, அதேசமயம் பைதான் பட்டியல்களிலிருந்து மற்றும் அதிலிருந்து மாற்றுவது அந்த நன்மையை ஒரு நெருக்கமான சமநிலைக்குக் குறைத்தது. இந்த அத்தியாயம் செயலாக்க எல்லை மற்றும் ஒரு பயன்பாடு தேவைப்படும் முடிவை எவ்வாறு அளவிடுவது என்பதை விளக்குகிறது.

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

## இந்த வீடியோ எதைப் பற்றி விவாதிக்கிறது

- CPython மூலத்தை பைட்கோடாக தொகுக்கிறது. மீண்டும் மீண்டும் வரும் இன்டர்பிரெட்டர்/ஆப்ஜெக்ட் வேலை மற்றும் ஒரு டைப் செய்யப்பட்ட நேட்டிவ் எண் சுழல் ஆகியவை வெவ்வேறு செயலாக்க ஏற்பாடுகள்.
- எண் NumPy எண்கணிதம் தொகுக்கப்பட்ட செயல்பாடுகளுக்கு டைப் செய்யப்பட்ட தொகுப்புகளை வழங்க முடியும்; எண்கணித சுழல் இன்னும் உள்ளது, மற்றும் காட்சிகள் ஒன்றோடொன்று இணங்காத தளவமைப்புகளைக் கொண்டிருக்கலாம்.
- மாற்று மற்றும் தேவையான வெளியீட்டு பிரதிநிதித்துவத்தை அளவிடவும். இந்த ஓட்டத்தில், பைதான் பட்டியல்களை வரிசைகளாக மாற்றுவதும், மீண்டும் மாற்றுவதும் பெரிய தயாரான-வரிசை முன்னிலையை அழித்தது.
- சிறு பணிச்சுமைகளுக்கு சாதாரண பைதான் சாதகமாக இருக்கலாம், ஏனெனில் நிலையான வரிசை-அழைப்பு செலவுகள் முக்கியம். இந்த அளவிடப்பட்ட ஒப்பீட்டில் எட்டு-மதிப்பு புரிதல் வெற்றி பெற்றது.
- np.vectorize என்பது அடுத்தடுத்த கூறுகளுக்கு பைதான் ஐ அழைக்கும் ஒரு வசதியான ரேப்பர் ஆகும்; ஒரு தொகுப்பு இடைமுகம் மட்டும் நேட்டிவ் எண் செயலாக்கத்தை நிறுவாது.
- தொகுக்கப்பட்ட பைதான்-சிண்டாக்ஸ் சுழல்களும் வேகமாக இருக்கலாம். அழைப்பாளருக்கு அவை முக்கியமாக இருக்கும்போது குளிர் தொகுப்பு/அமைப்பு செலவுகளைச் சேர்க்கவும்.
- நேட்டிவ் செயலாக்கம், CPU SIMD, மல்டித்ரெடிங் மற்றும் GPU பேக்கெண்ட்கள் தனித்தனி யோசனைகள். கிடைக்கக்கூடிய CPU அம்சங்கள் ஒரு குறிப்பிட்ட ஓட்டத்தில் பயன்படுத்தப்படும் வழிமுறைகளைக் கண்டறியாது.

## அத்தியாயங்கள்

- 0:00 ஒரே CPU ஏன் விரைவாக முடிக்கும்?
- 0:52 ஒரு பைதான் சுழல் என்ன வேலையை மீண்டும் செய்கிறது?
- 1:38 NumPy சுழலை எங்கே நகர்த்துகிறது?
- 2:13 வேகம் என்பது GPU அல்லது பல CPU கோர்களைக் குறிக்குமா?
- 2:49 ஈர்க்கக்கூடிய வேக உயர்வு எப்போது மறைந்துவிடும்?
- 3:28 எந்த எல்லைகள் பெஞ்ச்மார்க்கில் இருக்க வேண்டும்?
- 4:00 தொகுக்கப்பட்ட பைதான் சுழலும் வேகமாக இருக்க முடியுமா?
- 4:56 np.vectorize உண்மையில் எதை செயல்படுத்துகிறது?
- 5:41 உங்கள் குறியீட்டில் நீங்கள் என்ன மாற்ற வேண்டும்?

## மொழிபெயர்க்கப்பட்ட டிரான்ஸ்கிரிப்ட்

அசல் ஆங்கில விளக்கத்திலிருந்து மொழிபெயர்க்கப்பட்டது. கிடைக்கும் ஆடியோ மற்றும் தலைப்புகள் YouTube ஆல் கட்டுப்படுத்தப்படுகின்றன.

### ஒரே CPU ஏன் விரைவாக முடிக்கும்?

0:00 பைதான் வேகமாக இருக்க ஒரு புதிய மொழி தேவை என்று நீங்கள் நினைக்கிறீர்கள். சுழல் நகர்ந்த பிறகு, அதே CPU எங்கள் தொகுதியை வேகமாக இயக்கியது. வேலை எங்கே போனது? வேக அதிகரிப்பு எப்போது மறைந்துவிடும்? எந்த குறுக்குவழி பைதான் ஐ மீண்டும் கொண்டுவருகிறது? இது The Daily Diff, உள்ளே இருந்து. அந்த குறுக்குவழியில் ஒரு கண் வைத்திருங்கள். CPython என்பது நிலையான பைதான் செயலாக்கம்.

0:17 இது உங்கள் மூலத்தை பைட்கோடாக தொகுக்கிறது, பின்னர் அந்த வழிமுறைகளை ஒரு இன்டர்பிரெட்டரில் இயக்குகிறது. NumPy என்பது ஒரு எண் நூலகம், அதன் வரிசைகள் அறிவிக்கப்பட்ட தரவு வகையுடன் மதிப்புகளைக் கொண்டுள்ளன. அதன் உள்ளமைக்கப்பட்ட எண்கணிதம் ஒரு முழு தொகுதியையும் தொகுக்கப்பட்ட செயல்பாடுகளுக்கு வழங்க முடியும். ஒரு மில்லியன் மிதக்கும் புள்ளி மதிப்புகளை எடுத்துக் கொள்ளுங்கள், ஒவ்வொன்றையும் வர்க்கமாக்குங்கள், பின்னர் அசல் மதிப்பைச் சேர்க்கவும். ஒவ்வொரு பதிப்பும் ஒத்த மதிப்புகளைப் பெறுகிறது மற்றும் பொருந்தக்கூடிய பதில்களை உருவாக்குகிறது. வட்டமிடுதல் வேறுபாடுகளைப் பந்தயத்திலிருந்து விலக்கி வைக்க மதிப்புகள் போதுமான அளவு சிறியவை. இந்த இயந்திரத்தில், புரிதல் சுமார் முப்பத்து மூன்று மில்லி விநாடிகள் எடுத்தது.

0:40 NumPy ஒரு மில்லி விநாடிக்கும் குறைவாக எடுத்தது. இரண்டும் CPU இல் இயங்கின. இது இந்த பணிச்சுமைக்கு பயனுள்ள ஆதாரம், மற்றும் ஒரு புரோகிராமிங் மொழிக்கு ஒரு பயங்கரமான மரண அறிவிப்பு. சாதாரண சுழலுடன் தொடங்குவோம். பைதான் அடுத்த மதிப்பை எடுத்துக்கொள்கிறது, எண்கணிதத்தை செய்கிறது, மற்றும் பதிலைச் சேர்க்கிறது.

### ஒரு பைதான் சுழல் என்ன வேலையை மீண்டும் செய்கிறது?

0:53 பின்னர் அதை மீண்டும் செய்கிறது. பெருக்கல் மலிவானது. அடுத்த பெருக்கலை ஏற்பாடு செய்வது, மற்றும் அதைச் சுற்றியுள்ள பைதான் பொருட்களைக் கையாள்வது, ஒவ்வொரு முறையும் வேலையைச் சேர்க்கிறது. இது சோதிக்கப்பட்ட செயல்பாட்டின் உண்மையான டிஸ்சம்பளி. மீண்டும் மீண்டும் செய்தல், பெருக்கல் மற்றும் கூட்டுதல் ஆகியவை பைட்கோடு வழிமுறைகளாகத் தோன்றுகின்றன. பைதான் பதிப்புகள் மற்றும் இன்டர்பிரெட்டர்கள் வெவ்வேறு தேர்வுகளைச் செய்கின்றன. இந்த நேரங்கள் திரையில் உள்ள பதிப்புக்கு உரியவை, அது பைதான் மூன்று புள்ளி பத்து ஆகும்.

1:14 ஒரு பைதான் பட்டியல் பொருள்களுக்கான குறிப்புகளை சேமிக்கிறது, எனவே வெவ்வேறு வகையான விஷயங்கள் ஒரு பட்டியலை பகிர்ந்து கொள்ளலாம். எங்கள் எண்கணித வேலை முழுவதும் எண்களைப் பயன்படுத்துகிறது. இது ஒரு மீண்டும் மீண்டும் வரும் சேவையைக் கோரும்போது ஒரு பொதுவான ஏற்பாட்டிற்கு பணம் செலுத்துகிறது. ஒரே காபியை ஒரு மில்லியன் முறை ஆர்டர் செய்து, ஒவ்வொரு கோப்பைக்கும் ஒரு புதிய படிவத்தை நிரப்புவதை கற்பனை செய்து பாருங்கள். காபி இயந்திரம் நன்றாக உள்ளது. காகித வேலைக்கு அதன் சொந்த தொழில் உருவாகியுள்ளது. NumPy ஒப்பந்தத்தை மாற்றுகிறது.

1:36 இந்த வரிசை ஒரு அறிவிக்கப்பட்ட வகையுடன் நிலையான அளவு மிதக்கும் புள்ளி மதிப்புகளைக் கொண்டுள்ளது.

### NumPy சுழலை எங்கே நகர்த்துகிறது?

1:38 எங்கள் வரிசை தொடர்ச்சியானது, எனவே அதன் மதிப்புகள் நினைவகத்தில் ஒன்றாக அமர்ந்திருக்கின்றன. காட்சிகள் மற்ற தளவமைப்புகளைக் கொண்டிருக்கலாம். எண்கணித செயல்பாடு அது பெறும் தரவு வகையை அறிந்திருக்கிறது. அழைப்பு தொகுதியை ஒரு நேட்டிவ் செயல்பாட்டிற்கு வழங்குகிறது. தொகுக்கப்பட்ட குறியீட்டிற்குள் ஒரு சுழல் மதிப்புகளை இன்னும் பார்வையிடுகிறது. அந்த வேலை முழுவதும் வகையைப் பற்றிய அறிவை மீண்டும் பயன்படுத்தலாம். பைதான் வேலையை ஒப்படைக்கும் நபராகவே உள்ளது. இடமார் டர்னர் ட்ராவுரிங் பைதான் ஸ்பீடில் இந்த வேறுபாட்டை விளக்குகிறார்.

2:00 தொகுப்பு இடைமுகங்கள், நேட்டிவ் செயலாக்கங்கள் மற்றும் செயலி வெக்டார் அறிவுறுத்தல்கள் ஆகியவை தனித்தனி விஷயங்கள். செயல்பாட்டின் பெயர் மிகக் குறைவான ஆதாரங்களை வழங்குகிறது. இந்த முடிவு CPU இல் NumPy ஐப் பயன்படுத்தியது. CuPy போன்ற ஒரு GPU பேக்கெண்ட் வரிசைகள் மற்றும் செயல்பாடுகளுக்கு வேறு இடத்தைத் தேர்ந்தெடுக்கிறது.

### வேகம் என்பது GPU அல்லது பல CPU கோர்களைக் குறிக்குமா?

2:13 ஒரு GPU ஐ வாங்குவது இந்த சாதாரண பைதான் சுழலை அது ஏற்கனவே இயங்கிய இடத்திலேயே இயங்க விடுகிறது. CPU வெக்டார் அறிவுறுத்தல்கள் பல மதிப்புகளை ஒரே நேரத்தில் செயலாக்க முடியும். NumPy ஆதரவு பெற்ற கர்னல்களைத் தேர்ந்தெடுப்பதற்கான இயந்திரங்களைக் கொண்டுள்ளது. எங்கள் ரன்டைம் கிடைக்கக்கூடிய அம்சங்களைப் புகாரளிக்கிறது, ஆனால் இந்த வெளிப்பாட்டின் வழிமுறைகளைக் கண்டறியவில்லை. வெக்டார் அறிவுறுத்தல்களுக்கு அளவிடப்பட்ட முழு ஆதாயத்தையும் கொடுப்பது ஆதாரங்களை மிகைப்படுத்திவிடும். GPU ஷாப்பிங் கார்ட் மூடப்பட்டிருக்கலாம். ஒரு செயல்திறன் சரிசெய்வது ஒரு

2:40 வாங்குதலையும் ரத்து செய்வது ஆழமான திருப்தியைத் தருகிறது. துரதிர்ஷ்டவசமாக, பெஞ்ச்மார்க் தொடர்கிறது. எட்டு மதிப்புகளுடன், புரிதல் வெற்றி பெற்றது. வரிசை இயந்திரங்களை அழைப்பது சிறிய வேலைக்கு செலவழித்ததை விட அதிகமாக செலவழித்தது.

### ஈர்க்கக்கூடிய வேக உயர்வு எப்போது மறைந்துவிடும்?

2:49 பெரிய தயாரான வரிசைகள் முன்னேறின. நாங்கள் மீண்டும் மீண்டும் சோதனைகள் மற்றும் ஒரு வெப்பமான செயல்முறையைப் பயன்படுத்தினோம். புதிய பைதான் உருவாக்கங்கள் குறுக்குவெட்டை மாற்றலாம். பின்னர் பயன்பாட்டிற்கு என்ன தேவை என்பதை மாற்றவும். ஒரு பைதான் பட்டியலுடன் தொடங்கி ஒரு புதிய பைதான் பட்டியலுடன் முடிக்கவும். NumPy உள்ளீட்டை ஒரு வரிசையாக மாற்ற வேண்டும் மற்றும் பதிலைப் பைதான் பொருட்களாக மாற்ற வேண்டும். உங்கள் பயன்பாட்டிற்கு அவை தேவைப்பட்டால் அந்த படிகள் கணக்கில் சேர்க்கப்பட வேண்டும். ஒரு மில்லியன் மதிப்புகளில், அந்த முழுமையான பாதை சுமார் இருபத்தி எட்டு மில்லி விநாடிகள் எடுத்தது.

3:11 புரிதலும் சுமார் இருபத்தி எட்டு எடுத்தது. எங்கள் வியத்தகு முன்னிலை ஒரு நெருக்கமான சமநிலையாக மாறியது. வேகமான பகுதி உண்மையானது. தரவை அதன் எண் வடிவத்தில் வைத்திருக்க அனுமதிப்பது நன்மையைச் சார்ந்தது. தரவைப் பின்தொடரவும். அடுத்த செயல்பாடு ஒரு வரிசையை ஏற்றுக்கொண்டால், வரிசையை வைத்திருங்கள்.

### எந்த எல்லைகள் பெஞ்ச்மார்க்கில் இருக்க வேண்டும்?

3:28 நீங்கள் பட்டியல்களுக்கும் வரிசைகளுக்கும் இடையில் மீண்டும் மீண்டும் மாற்றினால், அந்த குறுக்கீடுகளை அளவிடவும். ஒரு விலையுயர்ந்த மாற்றத்திற்கு முன் நிறுத்துவது தவறான கேள்விக்கு துல்லியமான எண்களைத் தருகிறது. இந்த வரிசையைப் பெருக்குவது ஒரு தற்காலிக முடிவை உருவாக்குகிறது. அசல் மதிப்புகளைச் சேர்ப்பது வெளியீட்டை உருவாக்குகிறது. நேட்டிவ் செயலாக்கத்திற்கு இன்னும் நினைவகம் மற்றும் தரவு நகர்வு தேவை. உங்கள் குறியீடு பாதுகாப்பாக மீண்டும் பயன்படுத்த முடிந்தால், சில செயல்பாடுகள் ஒரு வெளியீட்டு இடையகத்தை ஏற்றுக்கொள்கின்றன, ஒதுக்கீடுகளைக் குறைக்கின்றன. ஒரு அழகான வரி பல பெரிய இடையகங்களை ஆர்டர் செய்யலாம்.

3:47 பைதான் ஸ்பீட் இந்த பிரச்சனையையும் சுட்டிக்காட்டுகிறது. ஒதுக்கீடு செய்பவர் உங்கள் அழகியலை அசாதாரணமாக அலட்சியப்படுத்துகிறார். நீங்கள் சுழல் சிண்டாக்ஸ் ஐ வைத்து அதன் செயலாக்கத்தை மாற்றலாம். Numba ஆதரவு பெற்ற எண் பைதான் செயல்பாடுகளை நேட்டிவ் குறியீடாக தொகுக்க முடியும். இதோ எங்கள் சோதனையிலிருந்து சுழல், அதன் கம்பைலர் டெக்கரேட்டருடன்.

### தொகுக்கப்பட்ட பைதான் சுழலும் வேகமாக இருக்க முடியுமா?

4:00 அது இன்னும் 'for' என்று கூறுகிறது. விலையுயர்ந்த இன்டர்பிரெட்டர் பாதை மாறியுள்ளது. தொகுக்கப்பட்ட பிறகு, இந்த சுழல் தயாரான வரிசைகளுடன் அரை மில்லி விநாடிக்கும் குறைவாக எடுத்தது. தொகுப்பு செயல்பாடு இந்த ஓட்டத்தில் சுமார் ஒரு விநாடி எடுத்தது. அந்த அமைப்பு செலவு மீண்டும் மீண்டும் வரும் நேரங்களிலிருந்து விலக்கப்பட்டது, எனவே ஒரு சிறிய ஒரு முறை வேலைக்கு ஒரு வேறுபட்ட ஒப்பீடு தேவை. Numba இன் சொந்த வழிகாட்டி வெளிப்படையான சுழல்களைக் காட்ட மகிழ்ச்சியாக உள்ளது. ஹாட் பாத் ஐ கண்டுபிடிப்பதற்கு முன் ஒரு மொழி இடம்பெயர்வைத் தொடங்குவது ஒரு நுட்பமான வழி

4:22 ஒரு சுயவிவரக்கருவியை திறப்பதைத் தவிர்க்க. முதலில் நேரத்தை என்ன பயன்படுத்துகிறது என்பதைக் கண்டறியவும். நெட்வொர்க் காத்திருப்பு, பொருள் பாக்சிங் மற்றும் மொத்த எண்கணிதம் ஆகியவை வெவ்வேறு திருத்தங்களைக் கோருகின்றன. கணக்கீடு மற்றும் தரவு பொருத்தமாக இருக்கும்போது நேட்டிவ் வரிசை செயல்பாடுகள் உதவுகின்றன. உங்கள் அழைப்பவர் உண்மையில் தேவைப்படும் முடிவை அளவிடவும். இப்போது அந்த குறுக்குவழிக்கு. உங்களுக்கு ஒரு பைதான் செயல்பாடு உள்ளது, அது ஒரு வரிசையை ஏற்க வேண்டும் என்று நீங்கள் விரும்புகிறீர்கள். வெக்டரைஸ் என்ற ஒரு ரேப்பர் விடுபட்ட செயல்திறன் பொத்தான் போல ஒலிக்கிறது.

4:43 அதன் ஆவணத்தில் ஒரு முக்கியமான வாக்கியம் காத்திருக்கிறது. NumPy அதன் வெக்டரைஸ் ரேப்பர் முக்கியமாக வசதிக்காக வழங்கப்படுகிறது என்று கூறுகிறது. அதன் செயலாக்கம் அடிப்படையில் ஒரு for சுழல் ஆகும். ரேப்பர் தொகுதிகளை ஏற்றுக்கொள்கிறது, ஆனால் அடுத்தடுத்த கூறுகளுக்கு உங்கள் பைதான் செயல்பாட்டை அழைத்துக்கொண்டே இருக்கும். இடைமுகம் சிறியதாகிவிட்டது.

### np.vectorize உண்மையில் எதை செயல்படுத்துகிறது?

4:56 செயலாக்க எல்லை பிஸியாகவே இருந்தது. பைதான் கால்பேக் வழியாக அதே மதிப்புகள் மீண்டும் வருவதைப் பாருங்கள். தயாரான வரிசைகளுடன், இந்த பதிப்பு சுமார் எண்பத்தி ஏழு மில்லி விநாடிகள் எடுத்தது. இது எங்கள் புரிதலை விட மெதுவாக இருந்தது. ஒரு பயனுள்ள ஒலிபரப்பு ரேப்பர் நீங்கள் அகற்ற முயற்சிக்கும் துல்லியமான ஒரு உறுப்பு வேலையைப் பாதுகாக்க முடியும். ஒரு தொகுப்பு இடைமுகத்தின் பின்னணியில் உள்ள செயலாக்கத்தைச் சரிபார்க்கவும், இணக்கமான தரவை அதன் பயனுள்ள வடிவத்தில் வைத்திருக்கவும், மற்றும் ஒப்பீட்டில் மாற்றத்தையும் சேர்க்கவும். நேட்டிவ், கால்பேக் மற்றும் தொகுக்கப்பட்ட சுழல்கள் அழைப்பாளரின் இருக்கையிலிருந்து ஒரே மாதிரியாகத் தோன்றலாம்.

5:18 வெக்டரைஸ் என்ற பெயர் உங்கள் ஸ்டாப்வாட்ச் ஒருபோதும் கையெழுத்திடாத ஒரு வாக்குறுதியை அளித்தது. வசதிதான் உங்களுக்குத் தேவை என்றால் அதை வைத்துக்கொள்ளுங்கள். செயல்திறனுக்காக, இயங்கும் சுழலைச் சரிபார்க்கவும். ஒரு அளவிடப்பட்ட எண் ஹாட் பாத் ஐ தொகுப்பதற்கு எனது தீர்ப்பு SHIP IT. சாதாரண சுழல்கள் ஏற்கனவே நன்றாக வேலை செய்யும் போது அவற்றை வைத்திருங்கள். வேலை எங்கே நடக்கிறது மற்றும் அடுத்த அழைப்பாளருக்கு என்ன தேவை என்பதைச் சரிபார்க்கவும். நீங்கள் வேறுவிதமாக முத்திரையிட்டிருப்பீர்களா என்று சப்ஸ்கிரைப் செய்யவும், பெல் ஐ அழுத்தவும், கருத்துகளில் எனக்குத் தெரிவிக்கவும். இன்றைய வேறுபாடு இதுதான்.

### உங்கள் குறியீட்டில் நீங்கள் என்ன மாற்ற வேண்டும்?

5:41 நான் Axrisi இலிருந்து நிகோ. பொறுப்புடன் ஒன்றிணைக்கவும். அனைவரும் நல்ல புரோகிராமிங்கை எழுதுங்கள். வேறு என்ன? REVERT. NEEDS REVIEW. சப்ஸ்கிரைப் செய்யவும்.

## ஆதாரங்கள்

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