Skip to content
Home » மலைப்பாம்பு மொழி 20 – பட்டியலோடு விளையாடு

மலைப்பாம்பு மொழி 20 – பட்டியலோடு விளையாடு

python

தரவுகளைக் குறிப்பிட்ட ஒரு கட்டமைப்பிற்குள் (Data Structures) சேமிப்பதற்கு மட்டுமல்லாமல், அதை முழுவதுமாக நிரலில் பயன்படுத்துவதற்கும் பைத்தான் உதவுகிறது. உதாரணமாக, கடந்த 2 அத்தியாயங்களில் பட்டியல்(list) தரவு கட்டமைப்பு குறித்துப் பார்த்து வருகிறோம். பட்டியலின் உறுப்புகளோடு விருப்பப்படி விளையாட 12 முன் வரையறுக்கப்பட்ட செயல்பாடுகளையும்(Pre defined functions) இணைத்தே தருகிறது பைத்தான்.

எதற்காக 12 மு.வ.செயல்பாடுகள்?

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

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

முன்பு போலச் சமையலுக்கு உண்டான எல்லா மசாலாக்களையும் நாமே கைகளால் அரைத்துக் கொண்டிருப்பதில்லை தானே? அதை இங்கே நாம் பொருத்திப் பார்த்துக் கொள்ளலாம்.

இனி பட்டியலின் 12 மு.வ.செயல்பாடுகள்…

குறிப்பு: நிரலும் அதன் வெளியீடும் ஒரே திரை சொட்டில்(screenshot) கொடுக்கப்பட்டுள்ளன.

1) len()

ஒரு பட்டியலில் மொத்தம் எத்தனை உறுப்புகள் உள்ளன என்பதன் எண்ணிக்கையைச் சொல்லும் மிக எளிமையான ஒரு செயல்பாடு.

நிரல் 1ஐ கவனியுங்கள், fruits[] என்ற பட்டியலில் மொத்தம் 4 உறுப்புகள் உள்ளதை len() கணக்கிட்டு அச்சிடுகிறது.

குறிப்பு: பைத்தானை பொருத்தமட்டும் அடைப்புக்குறிகளின் பயன்பாடு தனித்துவமானது.
– [] என்றால் பட்டியல்(list)
– () என்றால் செயல்பாடு(function). இது ஒருவேளை மாற்றி பயன்படுத்தப்பட்டால், நிரல் குழம்பித்தான் இயங்குவதையே நிறுத்திக்கொள்ளும்.


நிரல் 2ல் ஒரு காலி பட்டியலை len()ன்னிடம் தந்து, அதன் உறுப்புகளின் எண்ணிக்கையைக் கேட்கிறோம். அதுவும் சமர்த்தாக “ஒன்றுமில்லை போடா” என்பதை 0வை அச்சிடுவதன் மூலம் சொல்லாமல் சொல்கிறது.

2.append()

பட்டியலின் இறுதியில் ஒரு உறுப்பை இணைத்தல்.

நிரல் 3ல் numbers[] என்ற பட்டியல் ஏற்கனவே 3 உறுப்புகளைக் கொண்டிருக்கிறது, இப்போது append() செயல்பாட்டின் மூலம் மேலும் ஒரு உறுப்பைப் பட்டியலின் இறுதியில் இணைக்கிறோம்.

நிரல் 4, append() செயல்பாட்டைப் பயன்படுத்தி ஒரு பட்டியலின் இறுதியில் இன்னொரு பட்டியலை இணைக்கிறது.

நிரல் 4கின் வெளியீட்டை ஒருகணம் பாருங்கள், அதன் len() என்னவாக இருக்கும் என்பதைக் கணித்து, அதை நிரல்கொண்ட ஒப்பிட்டு உங்கள் கணிப்பு சரிதானா என்பதைப் பரிசோதித்துக் கொள்ளுங்கள்.

இந்த செயல்பாட்டின் வரம்புகள் என்று இரண்டை சொல்ல முடியும்.

– ஒரு உறுப்பை மட்டுமே பட்டியலில் இணைக்க முடிகிறது(என்னதான் மற்றுமொரு பட்டியலை இணைத்தாலும், ஒரே உறுப்பாகவே தன்னை புதிதாகச் சேர்ந்த இடத்தில் காண்பித்துக் கொள்கிறது)
– ஒரு பட்டியலின் இறுதியில் மட்டுமே உறுப்புகளை இணைக்க முடிகிறது.

இதையெல்லாம் தட்டிக்கேட்க யாருமே இல்லையா?

3.extend()

இவர்தான் append()ன் ஒரு அநியாயத்தைத் தட்டிக்கேட்க வந்தவர். extend()ன் மூலம் ஒன்றுக்கும் மேற்பட்ட உறுப்புகளை ஒரு பட்டியலில் இணைக்க முடியும்.

அதைத்தான் நிரல் 5ம், 6ம் செய்து காட்டுகின்றன.

இந்நிரல்களின் வெளியீட்டை நிரல் நான்கோடு ஒப்பிட்டுப் பார்த்தீர்களேயானால், append() மற்றும் extend()ன் ஒற்றுமை, வேறுபாடு என்னவென்பது துல்லியமாகத் தெரியவரும். பைத்தான் சம்பந்தப்பட்ட நேர்காணல்களில் தவறாமல் இடம்பெறும் ஒரு கேள்வி இது.

வேற்றுமை:

append(), பட்டியலின் இறுதியில் ஒரு உறுப்பை மட்டுமே இணைக்க வல்லது.
extend(), பட்டியலின் இறுதியில் பல்வேறு உறுப்புகளை இணைக்க வல்லது.

ஒற்றுமை:

இவ்விரண்டு செயல்பாடுகளையும் பயன்படுத்தி, ஒரு பட்டியலின் இறுதியில் மட்டுமே ஒன்று அல்லது அதற்கும் மேற்பட்ட உறுப்புகளை இணைக்க முடியும்.

“இந்த அநியாயத்தைத் தட்டிக்கேட்க ஒருத்தன் வருவான்.”

4. insert()

பட்டியலில் குறிப்பிட்ட எந்த இடத்தில் வேண்டுமென்றாலும் உறுப்புகளை இணைத்துக் கொள்வது.

எப்படி?

list.insert(index,element)

பட்டியலின் குறிப்பிட்ட உறுப்பை அணுக அதன் குறியீட்டு எண் பயன்படுவது குறித்துக் கடந்த அத்தியாயத்தில் பார்த்தோம், அணுக மட்டுமல்ல இணைக்கவும் அதே குறியீட்டு எண்ணைப் பயன்படுத்தலாம்.

நிரல் 7ல், fruits = [‘apple’, ‘banana’, ‘orange’] என்கிற பட்டியலைப் பயன்படுத்தியிருக்கிறோம். இதில்
‘apple’ன் குறியீட்டு எண் 0
‘banana’வின் குறியீட்டு எண் 1

இப்போது fruits.insert(1, ‘mango’) என்கிற நிரல் வரி, ‘mango’வை 1 என்கிற குறியீட்டு எண்ணுக்கு நிகராக இணைத்துவிடுகிறது. இப்போது கேள்வி என்னவென்றால், ஏற்கனவே 1க்கு நிகராக இருந்த ‘banana’வின் கதி? அது அடுத்த குறியீட்டு எண்ணான 2ஐ நோக்கி நகர்ந்துவிடும்.

நிரல் 8, குறிப்பிட்ட ஒரு குறியீட்டு எண்ணில் புதிதாக ஒரு பட்டியலை இணைத்து அச்சிடுகிறது.

சதா பட்டியலில் இணைப்பது குறித்து மட்டுமே பேசிக்கொண்டிருக்கிறோமே, பட்டியலிலிருந்து நீக்க முடியாதா என்பவர்களுக்காக…

5. remove()

பட்டியலில் இடம்பெற்றிருக்கும் குறிப்பிட்ட உறுப்பைச் சொல்லி அதை நீக்கக் கோருவது இந்த செயல்பாட்டின் அடிப்படை நோக்கமாகும்.

fruits[] பட்டியலிலிருந்து ‘orange’ஐ நீக்கச்சொல்லிக் கேட்கிறது நிரல் 9.

இல்லாத ஒரு உறுப்பை நீக்கச்சொல்லிக் கேட்டால் என்ன நடக்குமென்பதை நிரல் 10 அச்சிட்டுக் காட்டுகிறது.

சதா சர்வகாலமும் ஒரு பட்டியலில் என்ன இருக்கிறது என்பதை நினைவில் வைத்துக்கொண்டே இருக்க முடியுமா? குறியீட்டு எண்ணைக் கொடுத்து ஒரு உறுப்பைப் பட்டியலிலிருந்து நீக்க முடியாதா?

ஏன் முடியாது?

6. pop()

பட்டியலின் குறியீட்டு எண்ணைத் தந்து, குறிப்பிட்ட அந்த உறுப்பை நீக்குவது.

குறியீட்டு எண் 1ஐ pop()ற்கு கொடுத்து, அதற்கு நிகரான உறுப்பைப் பட்டியலிலிருந்து நீக்கும் பணியைச் செய்கிறது நிரல் 11.

removed_fruit = fruits.pop(1)

pop() செயல்பாட்டின் இன்னொரு குறிப்பிடத்தகுந்த அம்சம், எதை நீக்குகிறதோ அதை நிரலுக்குத் திரும்ப அனுப்பிவைக்கும். மேலிருக்கும் நிரல் வரியைக் கவனியுங்கள், பட்டியலில் 1 என்ற குறியீட்டு எண்ணுக்கு நிகராக இருக்கும் ‘banana’வை நீக்கியது மட்டுமன்றி, அதை removed_fruit என்னும் அடையாளங்காட்டியில் சேமிக்கும் வகையில் நீக்கியதை அனுப்பி வைத்திருக்கிறது.

நிரல் 11, 2 வெளியீட்டு வரிகளை அச்சிட்டு இருக்கிறது. முதல் வரி, ‘banana’ நீக்கப்பட்டபிறகு பட்டியல் அச்சிடப்படுகிறது. இரண்டாவது வரி, நீக்கப்பட்ட உறுப்பு அச்சிடப்படுகிறது.

ஒருவேளை இதுபோல pop()ற்குள் எந்தவொரு குறியீட்டு எண்ணையும் அனுப்பாமல் காலியாக விட்டால் என்ன நடக்கும்?

நிரல் 12 அதைத்தான் நமக்குச் சொல்கிறது. pop() செயல்பாடு காலியாக இருக்கும் பட்சத்தில், பட்டியலின் கடைசி உறுப்பு நீக்கப்பட்டு அச்சிடப்படும். நிரல் 12 இரண்டு வெளியீட்டு வரிகளை அச்சிடுகிறது. முதல் வரி, கடைசி உறுப்பு நீக்கப்பட்ட பிறகு பட்டியலின் தோற்றம். இரண்டாவது வரி, நீக்கப்பட்ட கடைசி உறுப்பு.

7. index()

பட்டியலின் உறுப்பை அனுப்பி அதன் குறியீட்டு எண்ணைக் கோருவது.

index = fruits.index(‘banana’)

நிரல் 13 ‘banana’வை அனுப்பி, பட்டியலின் குறியீட்டு எண்ணான 1ஐ நிரல் அச்சிடுகிறது.

ஒருவேளை பட்டியலில் இல்லாத உறுப்பை அனுப்பி அதன் குறியீட்டு எண்ணைக் கோரினால் என்ன நடக்கும்?

“நா என்ன வெச்சுகிட்டா வஞ்சகம் பண்றேன்?” என்பதுபோல ஒரு பிழையை வெளியீடாக அச்சிட்டிருக்கிறது நிரல் 14.

8. count()

ஒரு பட்டியலில் குறிப்பிட்ட ஒரு உறுப்பு எத்தனை முறை இடம்பெறுகிறது என்பதன் எண்ணிக்கையைப் பெறுவது.

நிரல் 15ல், numbers[] பட்டியலில் 2 என்கிற எண் எத்தனை முறை இடம்பெறுகிறது என்பதை எண்ணி அச்சிடுகிறது. இதேவேலையைக் கொஞ்சம் மாற்றி, பட்டியலில் எத்தனை ‘banana’ உள்ளது என்பதைச் சொல்கிறது நிரல் 16.

9. sort()

ஒரு பட்டியலை ஏறு வரிசையிலோ அல்லது இறங்கு வரிசையிலோ வரிசைப்படுத்துவது.

நிரல் 17ல் இடம்பெற்றுள்ள numbers.sort() என்ற நிரல் வரி, numbers[] பட்டியலை ஏறு வரிசையில் வரிசைப்படுத்துகிறது.

இதே வரியைக் கொஞ்சம் மாற்றி, numbers.sort(reverse=True) என்று எழுதி என்ன அதிசயம் நிகழ்கிறது பாருங்கள்.

எண்களை மட்டுமல்ல எழுத்துக்களையும் இப்படி வரிசைப்படுத்த முடியும் என்பதைச் சொல்கிறது நிரல் 18.

10. reverse()

பட்டியலின் உறுப்புகளை தலைகீழாக மாற்றுவது.

numbers.reverse() நிரல் 19ன் இவ்வரி பட்டியலை அப்படியே தலைகீழ் ஆக்குகிறது.

பட்டியலை மட்டுமல்லாமல் ஒரு வார்த்தையையும் கூட எடுத்துக்கொண்டு, அதைத் தலைகீழாக்கி ஒரு பட்டியலாக மாற்ற முடியும். அவ்வேலையைத்தான் நிரல் 20 பார்க்கிறது.

11. copy()

ஒரு பட்டியலை அப்படியே நகலெடுப்பது.

fruits_copy = fruits.copy()

நிரல் 21ன் இவ்வரி, fruits[] என்ற பட்டியலை நகலெடுத்து அதை fruits_copy என்ற மற்றொரு அடையாளங்காட்டியில் சேமிக்கிறோம். இந்நிரல் அசல் மட்டும் நகல் பட்டியல்களை அச்சிடுகிறது.

சரி, இப்போது அசலில் ஒரு மாற்றம் செய்தால் அது நகலிலும் பிரதிபலிக்குமா?

நிரல் 22 அதற்குண்டான பதில்களைத் தருகிறது. அசலில் ஒரு உறுப்பை இணைத்து, அது நகலிலும் இணைகிறதா என்று பார்த்திருக்கிறோம்.

12. clear()

பட்டியலில் இடம்பெற்றிருக்கும் உறுப்புகள் அனைத்தையும் அழிப்பது.

numbers.clear(), நிரல் 23ன் இவ்வரி பட்டியலின் அனைத்து உறுப்புகளையும் அழித்து அதை காலியானதாக ஆக்குகிறது.

ஏற்கனவே காலியாக இருக்கும் ஒரு பட்டியலை clear()க்கு அனுப்பினால் என்ன நடக்குமென்பதை நிரல் 24 காட்டுகிறது.

0

Google Colab குறித்துக் கேள்விப்பட்டு இருக்கிறீர்களா?

கூகுளின் மற்றொரு தயாரிப்பு இது. நேரடியாகவே இணைய உலாவிகளில் இந்த https://colab.research.google.com/ முகவரியைத் தந்து, பைத்தான் நிரல்களை எழுதி, இயக்கி அதன் வெளியீட்டை அங்கேயே பார்த்துக் கொள்ளலாம். இதுவரை நாம் பயன்படுத்தி வந்த, Python IDLEல் இருந்த காலவிரயம் இதில் இல்லை.

Google Colabன் ஒரு பக்கத்தில் எத்தனை நிரல்கள் வேண்டுமானாலும் எழுதிக்கொள்ளலாம். அதை பிடிஎப் ஆகவோ, அல்லது டிரைவிலோ நேரடியாகச் சேமித்துக்கொள்ள முடியும். மற்றவர்களுக்குப் பகிர்வதும் எளிது, .ipynb என்ற கோப்பு நீட்டிப்பில் இது கணினியில் சேமிக்கப்படும்.

இங்கே நாம் பார்த்த 24 நிரல்களும் Colabல் எழுதியதுதான். அதை நீங்கள் இந்த சுட்டியிலிருந்து https://colab.research.google.com/drive/1Hf_APkRzkTrd_tQcswTQA2e6nCF1rh5q?usp=sharing தரவிறக்கிக் கொள்ளலாம். ஏதாவதொரு உலாவிக்குச் சென்று, Colabன் இணைய முகவரியைத் தந்து இந்த கோப்பைத் திறந்தால், 24 நிரல்களும் அப்படியே இருக்கும். உங்கள் விருப்பத்திற்கு ஏற்ப மாற்றி, புதிய நிரல் வரிகளைச் சேர்த்து விளையாடலாம். உங்களுக்கு என ஒரு புதிய பக்கத்தையும் உருவாக்கி எத்தனை நிரல்களை வேண்டுமானாலும் எழுதிப் பார்த்துக் கொள்ளலாம், முயன்று பாருங்கள். ஐயம் இருந்தால் தெரியப்படுத்துங்கள். வாட்ஸ்அப் : 9789855667

0

இந்த 24 நிரல்களும் குறிப்பிட்ட ஒரு தரவு கட்டமைப்பின் மு.வ.செயல்பாடுகள் குறித்து அறிமுகத்தை மட்டுமே வழங்குகின்றன. ஒரு சிக்கலுக்குத் தீர்வைக் கண்டறியும்போது மட்டுமே
இவற்றைக் கற்றதற்கு உண்டான நியாயத்தைச் செய்ய முடியும்.

அடுத்த அத்தியாயத்தில் அதைச் செய்வோம்.

(தொடரும்)

பகிர:
ரிஷிகேஷ் ராகவேந்திரன்

ரிஷிகேஷ் ராகவேந்திரன்

நாமக்கல் மாவட்டம் இராசிபுரத்தை அடுத்த புதுப்பாளையம் என்னும் கிராமத்தைச் சேர்ந்தவர். தொழில்நுட்பத் துறை சார்ந்து தொடர்ந்து எழுதிவருபவர். இவர் எழுதிய ‘தமிழ் ராக்கர்ஸ் தோற்றமும் மறைவும்‘ என்னும் மின்னூல் பரவலான கவனத்தைப் பெற்றது. ரூபியா ரிஷி என்ற பெயரில் புனைவுகள் எழுதி வருகிறார்.View Author posts

பின்னூட்டம்

Your email address will not be published. Required fields are marked *