ஒரு பட்டியலின் கூறுகளை அணுக பைத்தான் நிறைய வழிகளை வழங்குகிறது. for loopஐ வைத்து பட்டியலின் ஒவ்வொரு உறுப்பாக வரிசையாக எப்படி எடுப்பது என்பதைக் கடந்த வாரம் பார்த்தோம். மேலும் சில சுவாரசியமான வழிகளும் உள்ளன, அதை இந்த அத்தியாயத்தில் காண்போம்.
பட்டியலில் இடம்பெற்றுள்ள ஒவ்வொரு உறுப்புக்கும் முன்னோக்கிய, பின்னோக்கிய குறியீட்டு எண்ணை பைத்தான் வழங்குகிறது. இந்த எண்களைப் பயன்படுத்தி நிரலாளர் தனது வசதிக்கு ஏற்ப எப்படி வேண்டுமானாலும் பட்டியலை அணுக முடியும். உதாரணத்துக்குக் கீழே தரப்பட்டுள்ள படத்தைக் கவனியுங்கள்.
1லிருந்து 10 வரைக்கும் ஒரு பட்டியல் உருவாக்கப்பட்டு இருக்கிறது. பட்டியலுக்கு மேலே சிவப்பு நிறத்தில் உள்ளவை முன்னோக்கிய குறியீட்டு எண்கள், நீல நிறத்தில் உள்ளவை பின்னோக்கிய குறியீட்டு எண்கள். சூழலுக்கு ஏற்றவாறு ஒன்று மு.கு.எண்களையோ, அல்லது பி.கு.எண்களையோ எடுத்துப் பயன்படுத்தலாம்.
எதற்காக இதெல்லாம்?
பட்டியலின் குறிப்பிட்ட உறுப்புகளை அணுகுவதற்காக மட்டும். இனி உதாரணங்கள்.
குறிப்பு: இந்த அத்தியாயத்தில் உள்ள நிரல்களோடு சேர்த்து அதன் வெளியீட்டையும் இணைத்து ஒரே திரை சொட்டாகக் (Screenshot) கொடுத்திருக்கிறேன். #ஐ தொடர்ந்து வருவது எதையும் நிரல் கண்டுகொள்ளாது. நிரலாளர் தனது குறிப்புகளைப் புரிதலுக்காக அங்கங்கே நிரலில் #ஐ பயன்படுத்தி எழுதிக்கொள்ளலாம், அவை நிரலின் பகுதிகளாகக் கணக்கில் எடுத்துக்கொள்ளப்பட மாட்டாது. நமது வசதிக்காக, நிரலின் வெளியீட்டை #ஐ பயன்படுத்தி நிரலோடு சேர்த்துத் தந்திருக்கிறேன்.
நிரல் 1:
விளக்கம்:
நிரலின் இரண்டாவது வரியை மட்டும் கவனியுங்கள், my_list[2:6] என்று இருக்கிறது. அதாவது my_list என்ற அடையாளங்காட்டியில் சேமிக்கப்பட்டிருக்கும் பட்டியலிலிருந்து, மு.கு.எண்கள் 2 தொடங்கி 6 வரை சுட்டும் உறுப்புகளை மட்டும் தனியாகப் பிரித்து எடுக்கிறோம்.
2:6 என்றால் மொத்தம் 5 உறுப்புகள் அல்லவா வருகிறது? ஆனால், நிரலின் வெளியீட்டில் 4 தானே அச்சிடப்பட்டிருக்கிறது?
நல்ல கேள்விதான். for loopன் range() செயல்பாடு உங்களுக்கு நினைவிலிருந்தால் இக்கேள்வி எழாது. எப்போதுமே முடிவில் குறிப்பிடப்பட்டிருக்கும் எண் n-1 என்கிற அடிப்படையில்தான் இயங்கும், அதாவது இந்நிரலை பொருத்தமட்டில் 6-1.
ஆக, 2:6 என்பதை 2,3,4,5 என்றே புரிந்துகொள்ள வேண்டும். இன்னொன்றையும் கவனியுங்கள், ஒரு பட்டியலிலிருந்து உறுப்புகளைப் பிரித்து எடுத்தால், அதன் வெளியீடும் மற்றொரு பட்டியலாகவே இருக்கும்.
நிரல் 2:
விளக்கம்:
அதே உறுப்புகளைக் கொண்ட பட்டியல், இம்முறை [1:8:2].
நிரலுக்குச் செல்வதற்கு முன்பு சில அடிப்படை கேள்விகள்.
இவை மு.கு.எண்கள் என்பதை எப்படிக் கண்டறிந்தோம்? கண்ணால் பார்த்துத் தான். இவை நேர்ம எண்கள், ஆகவே மு.கு.எண்கள். ஒருவேளை எதிர்ம எண்களாக இருக்கும் பட்சத்தில், பி.கு.எண்கள்.
சரி, இப்போது [1:8:2] என்பதை எப்படிப் பிரித்து எழுதுவது?
1:8:2 -> 1,3,5,7
மு.கு.எண்கள் இரண்டு இரண்டாகத் தாவுவதற்கான காரணம், நிலையின் மதிப்பை(மூன்றாவதாகக் குறிப்பிடப்பட்டு இருப்பது) 2 என்று கொடுத்திருக்கிறோம். உங்களுக்கு இன்னும் இது சரியாக விளங்கவில்லை என்றால், for loop மற்றும் range() செயல்பாடு குறித்த அத்தியாயத்தை ஒருமுறை படித்து வாருங்கள்.
நிரல் 3:
விளக்கம்:
[::-1} என்று எழுதியிருக்கிறோம்.
முதலில் புரிந்துகொள்ளப்பட வேண்டியது இந்நிரலில் நாம் எதிர்ம எண்களோடு வேலை செய்யவிருக்கிறோம், அதாவது பட்டியலைப் பின்னோக்கி அணுகவிருக்கிறோம்.
சரி [::-1] என்றால்?
குழப்பம் நேர்கையில் எல்லாம் அடிப்படையை நோக்கி ஓடவேண்டியதுதான்.
தொடக்கம் இல்லாமல் இருந்தால், 0வை இட்டு நிரப்புக.
முடிவு இல்லாமல் இருந்தால், பட்டியலின் நீளத்தை (எத்தனை உறுப்புகள் உள்ளன என்பதே அதன் நீளம்) இட்டு நிரப்புக.
நிலை இல்லாமல் இருந்தால், 1ஐ கொண்டு நிரப்புக.
இது நேர்ம எண்களுக்குப் பொருந்தும், இதுவே எதிர்ம எண்களாக இருந்தால்,
தொடக்கத்திற்கு: -1
முடிவிற்கு: -len(my_list)-1
நிலைக்கு: -1
இங்கே நமக்குத் தொடக்கமும், முடிவும் இல்லை. ஆகவே -1ஐயும், பட்டியலின் நீளத்தையும் கூப்பிடுங்கள்.
[::-1] என்பதை [-1:-11:-1] என்று புரிந்துகொள்ளலாம்.
[-1:-11:-1] என்பதை
-1-1 = -2
-2-1 = -3
-3-1 = -4
.
.-9-1=-10 என்று பிரித்துப் புரிதலுக்காக எழுதலாம்.
ஆகப் பட்டியலின் கடைசியிலிருந்து தொடங்கி முதல் உறுப்பு வரை அச்சிடப்படும். சுருக்கமாகச் சொன்னால், ஒரு பட்டியல் தனது உறுப்புகளை தலைகீழாக அச்சிடுகிறது.
நிரல் 4:
விளக்கம்:
இம்முறை my_list[-5:-2], நிலை இல்லாமல் இருக்கிறது ஆகவே 1ஐ இட்டு நிரப்பி
[-5:-2:1] என்று விரித்து எழுதுகிறோம்.
நிரல் 5:
விளக்கம்:
இது மற்றுமொரு வேடிக்கையான நிரல். “என்னடா இது அநியாயம்? ஒரு புள்ளியை மட்டும் வெச்சிட்டு ஏமாத்துறீங்க?” என்பவர்கள் முகத்தைத் துடைத்துவிட்டுத் தொடரவும்.
[:] என்பது [0:len(sliced_list):1] என்று புரிந்து கொள்ளப்படலாம்.
நிரல் 6:
விளக்கம்:
ஒரு பட்டியலின் உறுப்புகளில் பெரிய எண் எது என்பதைக் கண்டறிய இருக்கிறோம். for loopஐ பயன்படுத்தி ஒவ்வொரு எண்ணாக வரிசையாக எடுத்துக்கொண்டு, அதை மற்ற எண்ணோடு(அடுத்து வரும்) ஒப்பிட்டு ஒவ்வொரு செய்கையின் முடிவிலும் எது பெரிய எண் என்பதைத் தற்காலிகமாகக் கண்டறிகிறோம்.
இவ்வாறாகப் பட்டியலின் அனைத்து உறுப்புகளும் for loopஆல் அணுகப்பட்ட பிறகு, பெரிய எண் தெரியவரும். நிரலின் தொடக்கத்தில், நமது வசதிக்காக தோராயமாகப் பட்டியலின் முதல் உறுப்பைப் பெரிய எண்ணாக வைத்துக்கொள்கிறோம்.
நிரல் 7:
விளக்கம்:
இந்நிரலை மூன்றே வரிகளில் புரிந்துகொள்ள முயல்வோமா?
1) ஒரு பட்டியல், அதன் உறுப்புகளை ஒவ்வொன்றாக அணுக ஒரு for loop
2) அப்படி அணுகப்படும் உறுப்புகள், இரட்டைப்படை எண் தானா என்பதைக் கண்டறிய ஒரு நிபந்தனை
3) நிபந்தனை பலிக்கும் பட்சத்தில், பட்டியலில் இரட்டைப்படை எண்களின் எண்ணிக்கையைக் குறிக்கும் count அடையாளங்காட்டியின் மதிப்பில் 1ஐ கூட்டுகிறோம்.
அவ்வளவுதான். சியர்ஸ்.
நிரல் 8:
விளக்கம்:
ஒரு பட்டியலின் உறுப்புகளின் கூட்டுத்தொகையைக் கண்டறிந்து, பிறகு அதன் சராசரியைக் கண்டறிகிறோம்.
(தொடரும்)
