Python-இல் List Comprehensions vs Traditional Loops
Python குறைந்த குறியீடுகளுடன் (code) அதிக வேலைகளைச் செய்ய அனுமதிக்கிறது.
இதைச் செய்வதற்கான ஒரு வழி list comprehensions ஆகும்.
பல டெவலப்பர்கள் யோசிக்கிறார்கள்: குறியீடு சுருக்கமாக இருப்பது எப்போதும் சிறந்ததா? ஒவ்வொரு loop-ஐயும் comprehension-ஆல் மாற்ற வேண்டுமா?
எதைத் தேர்ந்தெடுப்பது என்பதை இங்கே காணலாம்.
Traditional Loops
Traditional loops படிப்படியாகச் செயல்படுகின்றன.
- ஒரு காலியான பட்டியலை (list) உருவாக்குதல்
- தரவுகளை ஒவ்வொன்றாகச் சரிபார்த்தல் (iterate)
- ஒரு கணக்கீட்டைச் செய்தல்
- முடிவைச் சேர்த்தல் (append)
எப்போது loops-ஐப் பயன்படுத்த வேண்டும்:
- உங்கள் தர்க்கம் (logic) சிக்கலானதாக இருக்கும்போது
- பல படிநிலைகளைத் திருத்த (debug) வேண்டியிருக்கும் போது
- பிரிண்ட் (printing) அல்லது லாகிங் (logging) போன்ற கூடுதல் செயல்பாடுகளைச் செய்ய வேண்டியிருக்கும் போது
- பல அடுக்கு நிபந்தனைகள் (nested conditions) இருக்கும்போது
Loops உங்கள் நோக்கத்தைத் தெளிவாகக் காட்டுகின்றன. மற்ற டெவலப்பர்கள் உங்கள் குறியீட்டை குழப்பமின்றிப் படிக்க அவை உதவுகின்றன.
List Comprehensions
ஒரு list comprehension அதே வேலையை ஒரே வரியில் செய்துவிடும்.
- இது iteration மற்றும் transformation ஆகிய இரண்டையும் இணைக்கிறது
- இது உடனடியாக ஒரு புதிய தொகுப்பை (collection) உருவாக்குகிறது
- இது பொதுவாக ஒரு loop-ஐ விட வேகமானது
எப்போது comprehensions-ஐப் பயன்படுத்த வேண்டும்:
- பணி ஒரு எளிய மாற்றமாக (simple transformation) இருக்கும்போது
- ஒரு நிபந்தனையின் அடிப்படையில் பட்டியலை வடிகட்டும்போது (filtering)
- எளிய பணிகளுக்குத் தூய்மையான மற்றும் சுருக்கமான குறியீட்டை எழுத விரும்பும்போது
தரவு சுத்திகரிப்பு (data cleaning) மற்றும் அடிப்படை கணிதத்திற்கு comprehensions மிகவும் திறமையானவை.
வேறுபாடுகள்
• குறியீட்டின் நீளம்: Comprehensions சுருக்கமானவை. Loops நீளமானவை. • செயல்திறன்: உள்நிலை மேம்படுத்தல் (internal optimization) காரணமாக Comprehensions பெரும்பாலும் வேகமானவை. • வாசிப்புத்திறன்: எளிய பணிகளுக்கு Comprehensions சிறந்தது. சிக்கலான தர்க்கத்திற்கு Loops சிறந்தது. • நெகிழ்வுத்தன்மை: பல படிநிலை செயல்முறைகளுக்கு Loops அதிக நெகிழ்வுத்தன்மையை வழங்குகின்றன.
ஒரு சமநிலையான அணுகுமுறை
ஒரு comprehension குறியீட்டைப் படிக்கக் கடினமாக மாற்றினால், அதைத் திணிக்க வேண்டாம்.
மூன்று அல்லது அதற்கு மேற்பட்ட நிபந்தனைகளுடன் ஒரு comprehension-ஐ நீங்கள் எழுதத் தொடங்கினால், அங்கேயே நிறுத்திவிடுங்கள். அதற்குப் பதிலாக ஒரு traditional loop-ஐப் பயன்படுத்துங்கள்.
முதலில் மனிதர்களுக்காகக் குறியீட்டை எழுதுங்கள். செயல்திறனுக்காக (performance) இரண்டாவதாக எழுதுங்கள்.
ஆதாரம்: https://dev.to/shalinivemuri/list-comprehensions-vs-traditional-loops-in-python-4f6n
விருப்பமான கற்றல் சமூகம்: https://t.me/GyaanSetuAi