பைத்தானின் அடுத்த தரவு கட்டமைப்பு (Data Structures) Tuples. இதைச் சுருக்கமாக மாறாத தன்மைகொண்ட பட்டியல் என்று கூறலாம், நமது வசதிக்காக மா.பட்டியல். அதாவது ஒருமுறை இதன் உறுப்புகள் நிரலில் உருவாக்கப்பட்டுவிட்டால், அதன் தலையெழுத்து அவ்வளவுதான். தலைகீழாக நின்றாலும் கூட பட்டியலில்(List) செய்ததைப் போல உறுப்புகளின் மதிப்பை நமது விருப்பத்திற்கு மாற்ற இயலாது.
மாறும், மாறாத என இரு தரவு கட்டமைப்புகள்(த.க) எதற்காக? ஒரு நிரலாக்க மொழி தனது நிரலாளர்களுக்கு அனைத்து வாய்ப்புகளையும் வழங்குகிறது. அதைப் பயன்படுத்தி ஒரு சிக்கலுக்கு தீர்வுகாணத் தேவையான நுட்பங்களைக் குறைவின்றி தருகிறது, அதைப் பயின்று நிரலாளர் தனது தேவைக்கேற்ப அடித்து ஆட வேண்டியதுதான்.
நேரடியாக நிரலுக்குச் செல்வதற்கு முன்பு, சில உதாரணங்களைப் பார்த்துவிடுவோம்.
நீங்கள் ஷாப்பிங் செய்யும் பொருட்களுக்காக ஒரு தரவு கட்டமைப்பை உருவாக்க வேண்டும், அதேபோல வாரநாட்களைச் சேமிக்கவும் ஒரு த.க தேவைப்படுகிறது. என்ன செய்யலாம்?
வார நாட்கள் என்ன ஆனாலும் மாறப் போவதில்லை, கூடவோ குறையவோ வாய்ப்பில்லை. ஆனால் ஷாப்பிங் செய்யும் பொருட்கள் மாற வாய்ப்பிருக்கிறது தானே? (பணம் செலுத்தும் வரை). ஆகவே மாறாத தன்மை கொண்டிருப்பதால் வார நாட்களுக்கு மா.பட்டியல் (Tuples), மாறும் தன்மை கொண்டிருப்பதால் ஷாப்பிங் பொருட்களுக்குப் பட்டியல்(List). இதேபோல ஒரு நிரல் கையாளவிருக்கும் தரவுகளை அடிப்படையாகக் கொண்டு சரியான த.கட்டமைப்பைத் தேர்ந்தெடுப்பது அவசியம்.
மா.பட்டியலை எப்படி உருவாக்குவது?
குறிப்பு: நிரலின் வெளியீடுகள் #ஐ தொடர்ந்து பச்சை நிறத்தில் கொடுக்கப்பட்டுள்ளன.
நிரல் 1:
() என்ற அடைப்புக்குறிக்குள் உறுப்புகளை வேறுபடுத்திக்காட்டக் காற்புள்ளிகள் பயன்படுத்தப்பட்டால், மா.பட்டியல் உருவாக்கப்பட்டுவிட்டது என்று பொருள்.
நிரல் 2: மா.பட்டியலின் உறுப்புகளை அணுகுதல்
பட்டியலைப் போலவே நேர்மறை அல்லது எதிர்மறை எண்களைப் பயன்படுத்தி மா.பட்டியலின் உறுப்புகளைத் தனியாகப் பிரித்தெடுக்கலாம்.
தனியாகப் பிரித்தெடுக்கலாம் சரி, ஒருவேளை அதன் உறுப்புகளின் மதிப்பை வேறு ஒன்றைக்கொண்டு மாற்ற முயன்றால் என்ன நடக்கும்?
இதுதான் நடக்கும். பட்டியலிலிருந்து மா.பட்டியல் எவ்வாறு மாறுபடுகிறது என்பதற்கான முதன்மை வேறுபாட்டை மேற்கண்ட நிரலில் காணலாம்.
நிரல் 3: எதிர்மறை எண்களைப் பயன்படுத்தி மா.பட்டியலின் உறுப்புகளை அணுகுதல்
மேற்கண்ட அதே my_tupleல் எதிர்மறை எண்களைப் பயன்படுத்தி உறுப்புகளை எடுக்கிறோம்.
நிரல் 4: ஒன்றுக்கும் மேற்பட்ட உறுப்புகளை எடுத்தல்
குறியீட்டு எண்களை மட்டும் இங்கே எழுதுகிறேன். அதைப் பயன்படுத்தி உறுப்புகளை எடுத்து, வெளியீட்டோடு ஒப்பிட்டுப் பாருங்கள்.
my_tuple([1:4]) -> 1,2,3. ஏன் நான்கு வராது என்பதற்கான காரணத்தை ஏற்கனவே பேசியிருக்கிறோம், n-1 என்பதை நினைவில் கொள்ளுங்கள்.
my_tuple([:3]) -> :க்கு முன்பு இருக்கவேண்டிய தொடக்கம் குறிப்பிடப்படவில்லை, அதனால் 0வை வைத்து ஈடுசெய்து, my_tuple([0:3]) என்று திருத்தி எழுதிக்கொள்ளலாம். எனவே அதன் உறுப்புகள் 0,1,2 என்ற குறியீட்டு எண்களால் அடையாளப்படுத்தப்பட்டு இருக்கும்.
my_tuple[3:] -> :ஐ பின்தொடர்ந்து வரவேண்டிய குறியீட்டு எண் இல்லாத காரணத்தால், my_tupleன் மொத்த உறுப்புகளைக் கணக்கிட்டு அதன் மதிப்பை இட்டு நிரப்பிக்கொள்ளலாம். 3,4,5 என்பதே my_tuple[3:6]ன் குறியீட்டு எண்.
my_tuple[:] -> ஆதியும் இல்லை அந்தமும் இல்லை, புள்ளி மட்டுமே இருக்கிறது. இதுவரை பார்த்த தர்க்கத்தின் அடிப்படையில் இந்நிரல் வரியை my_tuple[0:len(my_tuple)] என்று திருத்தி எழுதி அதன் உறுப்புகளை 0,1,2,3,4,5 என்ற குறியீட்டு எண்களின் மூலம் பெறலாம்.
0
செயல்பாடுகள்
பட்டியலில் பார்த்ததைப் போலவே எண்கணித செயல்பாடுகளில் +, * ஆகிய இரண்டு இயக்கிகளை மட்டும் மா.பட்டியலில் பயன்படுத்தலாம்.
நிரல் 5: ஒன்றுக்கும் மேற்பட்ட மா.பட்டியல்களை இணைத்தல்
tuple1, tuple2 ஆகிய இரண்டையும் இணைத்து ஒரே மா.பட்டியலாக concatenated_tupleல் இணைத்திருக்கிறோம்.
நிரல் 6: ஒன்றுக்கும் மேற்பட்ட மா.பட்டியல்களை பிரதி செய்தல்
tuple1ஐ 3 முறை பிரதி செய்து repeated_tupleல் சேமிக்கிறோம்.
நிரல் 7: மா.பட்டியலைக் கட்டவிழ்த்தல்
மா.பட்டியலின் உறுப்புகளை அதன் குறியீட்டு எண்களைப் பயன்படுத்தி மட்டுமே எடுக்கவேண்டும் என்று எந்தவொரு நிர்ப்பந்தமும் இல்லை. உறுப்புகளின் எண்ணிக்கைக்கு ஏற்ப அடையாளங்காட்டிகளை உருவாக்கி அதிலும் கூட அதன் மதிப்புகளைச் சேமிக்கலாம்.
மேற்கண்ட நிரலில் my_tupleல் உள்ள 3 உறுப்புகளையும் முறையே name, age, country என்ற அடையாளங்காட்டிகளில் சேமித்திருக்கிறோம். இதனால் என்ன பலன்?
ஒருமுறை உருவாக்கப்பட்டுவிட்டால் மாற்றவே முடியாது என்பதை இந்த நுட்பத்தைப் பயன்படுத்தி கொஞ்சம் அசைத்துப் பார்க்கலாம்.
எப்படி?
நேரடியாகக் குறியீட்டு எண்களைப் பயன்படுத்தி மா.பட்டியலின் உறுப்புகளை மாற்ற இயலாது. அதற்குப் பதிலாக, உறுப்புகளுக்கு இணையான அடையாளங்காட்டி களை உருவாக்கி, அதன் மதிப்புகளை மாற்றிய பிறகு அவற்றை மா.பட்டியலுக்கு ஒதுக்கீடு செய்யலாம். இதன்மூலம் மறைமுகமாக அவற்றின் மதிப்புகளைத் தேவைக்கேற்ப மாற்றிக்கொள்கிறோம். இதனை Tuples Unpacking என்கிறோம்.
நிரல் 8: உறுப்புகளை எண்ணுதல்
பட்டியலுக்கும், மா.பட்டியலுக்கும் உள்ள மற்றுமொரு ஒற்றுமை என்று len() செயல்பாட்டைச் சொல்லலாம். மேற்கண்ட நிரலில் my_tupleல் எத்தனை உறுப்புகள் உள்ளன என்பதை எண்ணி அச்சிடுகிறது.
நிரல் 9: Nested Tuplesன் உறுப்புகளை எண்ணுதல்
ஒரு மா.பட்டியலுக்குள் இன்னொன்று என்பது நிரலில் சாத்தியம் தெரியும், ஆனால் அதன் உறுப்புகளை எப்படி எண்ணுவது? மிகச் சுலபம், தனியான உறுப்புகளை முதலில் எண்ணிக்கொள்ளுங்கள். பிறகு அடைப்புக்குறிக்குள் எத்தனை உறுப்புகள் இருந்தாலும் சரி, அதன் எண்ணிக்கை ‘1’தான். இப்போது நான் சொல்வது சரி தானா என்பதை நிரலின் வெளியீட்டை ஒருமுறை பார்த்து உறுதி செய்யுங்கள்.
சரி, இப்போது இதன் len()ன் மதிப்பு என்ன?
my_tuple=(1,(2,3,(4,(5,6),7),8,(9,10,11,(12,(13)),14)))
0
இனி மா.பட்டியல் என்ற தரவு கட்டமைப்புக்கு என ஒதுக்கப்பட்டுள்ள மு.வ.செயல்பாடுகளை ஒவ்வொன்றாகப் பார்ப்போம், ஒரு செயல்பாட்டுக்கு 2 நிரல்கள் என்கிற அடிப்படையில் தொடர்வோம்.
1) tuple()
நிரல் 10: பட்டியலை மா.பட்டியலாக மாற்றுதல்
my_list என்ற பட்டியலை tuple() என்ற முன் வரையறுக்கப்பட்ட செயல்பாட்டுக்குள் அனுப்புவதன் மூலம், பட்டியலை மா.பட்டியலாக மாற்றுகிறோம்.
நிரல் 11: ஒரு வார்த்தையின் எழுத்துக்களை மா.பட்டியலின் உறுப்புகளாக மாற்றுதல்
‘Hello, World’ என்ற சொல்லின் ஒவ்வொரு எழுத்தாக எடுத்து அதை மா.பட்டியலின் ஒரு உறுப்பாக மாற்றும் வேலையைச் செய்கிறது tuple().
2) count()
நிரல் 12: மா.பட்டியலில் உள்ள குறிப்பிட்ட ஒரு எண்ணின் இருப்பை கணக்கிடுதல்
my_tupleல் எத்தனை முறை 1 இடம்பெற்றிருக்கிறது என்பதை எண்ணிச் சொல்கிறது count() மு.வ.செ.
நிரல் 13: மா.பட்டியலில் உள்ள குறிப்பிட்ட ஒரு எழுத்தின் இருப்பை கணக்கிடுதல்
எண்களோடு மட்டுமல்லாமல் எழுத்தோடும் விளையாடலாம். my_tupleல் எத்தனை முறை ‘c’ இடம்பெற்றிருக்கிறது என்பதை எண்ணிச் சொல்கிறது count() மு.வ.செ.
மா.பட்டியலில் இல்லாத ஒரு உறுப்பைக் கொடுத்தால் என்ன வெளியீடு வருகிறது என்று பாருங்கள்.
3) index()
நிரல் 14: குறிப்பிட்ட ஒரு உறுப்பின் குறியீட்டு எண்ணை அறிதல்.
‘banana’ என்பதன் குறியீட்டு எண்ணை அச்சிடுகிறது index().
நிரல் 15: ‘d’ என்பதன் குறியீட்டு எண் 3, index()ன் மூலம் நீங்கள் அதை உறுதி செய்துகொள்ளலாம்.
4) max()
நீங்கள் நினைப்பது சரிதான். மா.பட்டியலின் உறுப்புகளில் பெரியதை max() தெரியப்படுத்தும். கீழ்க்கண்ட நிரலில் அது 30ஆக இருக்கிறது.
நிரல் 16:
அது என்ன எப்போது பார்த்தாலும் எண்களிலேயே பெரியதை கண்டுபிடித்துக்கொண்டிருப்பது? எழுத்துக்கள் மட்டும் என்ன தக்காளி தொக்கா?
அதற்காக வார்த்தைகளில் எப்படி பெரியதை அறிவது? நிரலில் எல்லாவற்றுக்கும் பதில் உண்டு.
“இஸ்க் இஸ்க் என்றா கேட்கிறது? எனக்கு ASCII என்று கேட்கிறது”. American Standard Code for Information Interchange என்பதன் சுருக்கமே ASCII. ஒவ்வொரு எழுத்துக்கும், இன்னும் சொல்லப்போனால் கணினி விசைப்பலகையில் ஒவ்வொரு பட்டனுக்குமே கூட ASCII உண்டு.
அப்படியென்றால்?
1960 வாக்கில் ஒவ்வொரு எழுத்துக்கும் (பெரிய எழுத்துக்குத் தனி, சிறிய எழுத்துக்குத் தனி), நிறுத்தற்குறிக்கும், சின்னத்திற்கும் என 7 இலக்க பைனரி எண்ணை ஒதுக்கீடு செய்து தந்துவிட்டது ASCII. அதன் அடிப்படையில் பார்த்தால் A-Z, a-z, ENTER, SHIFT, TAB என அனைத்திற்கும் இணையான 7 இலக்க பைனரி எண்கள் உண்டு.
நம் புரிதலுக்காகச் சிலவற்றைப் பார்ப்போம்.
‘A’வின் ASCII மதிப்பு 65. அதாவது கணினி அதை 1000001 என்று புரிந்துகொள்ளும். அப்படியென்றால் ‘B’க்கு 66, ‘C’க்கு 67 என ‘Z’ வரை செல்லும். ‘a’வின் மதிப்பு 97.
இதற்கும் நாம் பார்த்துக்கொண்டிருக்கும் நிரலுக்கும் என்ன சம்பந்தம்?
max() வார்த்தைகளில் பெரியதைக் கண்டறியும் என்று ஏற்கனவே பார்த்திருந்தோம் அல்லவா? எப்படி என்பதற்கான பதில்தான் ASCII.
நிரல் 17:
my_tupleல் மூன்று உறுப்புகள் உள்ளன இல்லையா? அவற்றின் முதல் எழுத்துக்களை மட்டும் எடுத்துக்கொள்ளுங்கள். ‘a’,’b’,’o’ என்று வருகிறது, இப்போது அதற்கு இணையான ASCII மதிப்பைக் கணக்கிடுங்கள். அனைத்து எழுத்துக்கள், சின்னங்களின் மதிப்பையும் நீங்கள் நினைவில் வைத்திருப்பது சாத்தியமில்லாத ஒன்று. ‘A’க்கு எவ்வளவு? ‘B’ எவ்வளவு என்பது மட்டும் தெரிந்திருந்தால் போதும்.
இப்போது ஒரு விஷயம் தெளிவாகிறது, ‘o’வின் ASCII மதிப்பு எவ்வளவோ தெரியாது. ஆனால் கட்டாயம் அது ‘a’ மற்றும் ‘b’யின் மதிப்புகளைக் காட்டிலும் பெரியதாகத்தான் இருக்கும். எனவே ‘orange’ என்பதே பெரியது என்று முடிவெடுக்கிறது நிரல்.
min()
வாழ்க்கையில் எல்லாமே இரண்டுதான் என்று சொன்னவர் என்னமோவானந்தா. அவர் கூற்றுப்படி max() என்ற ஒன்றிருந்தால், min() என்பதும் இருந்தாக வேண்டும் இல்லையா? இனி min()ஐ அடிப்படையாக வைத்து 2 நிரல்கள். max()ஐ போதுமான அளவுக்கு வெளுத்துவிட்டதால், min() உங்களுக்கு எளிதாக இருக்கும், ஆகவே கீழ்க்காணும் இரண்டு நிரல்களுக்கும் விளக்கம் தேவையில்லை.
நிரல் 18:
நிரல் 19:
sum()
மா.பட்டியலின் அனைத்து உறுப்புகளையும் கூட்டி அதன் மதிப்பை sum() தருவார்.
நிரல் 20:
நிரல் 21:
sorted()
இவரைப் பயன்படுத்தி ஒரு மா.பட்டியலின் உறுப்புகளை(எழுத்தானாலும், எண் ஆனாலும்)அகர வரிசையில் அடுக்கிக்கொள்ள முடியும்.
நிரல் 22:
நிரல் 23:
0
இதுவரை பார்த்தவை நமக்கு ஒரு அறிமுகத்தைத் தருகின்றன அவ்வளவே. இவற்றை வைத்து, சிக்கல்களுக்கு நிரலின் மூலம் தீர்வை காணும்பொழுதுதான் இவற்றின் முழுமையான பலனை அடைய முடியும். அதற்காகப் பின்வரும் 3 நிரல்கள்.
நிரல் 24: பட்டியலுக்குள் மா.பட்டியல்
students என்ற பட்டியலுக்கு உள்ளே மூன்று மா.பட்டியல் உறுப்புகள். ஒவ்வொரு மா.பட்டியலுக்கு உள்ளேயும் ஒரு மாணவரின் பெயர், வயது, படிப்பு ஆகிய விபரங்கள், ஆக 3 மாணவர்களைக் கொண்டிருக்கிறது பட்டியல்.
இப்போது தனித்தனியாக ஒவ்வொரு மா.பட்டியலாக எடுத்து, அவற்றின் உறுப்புகளைப் பின்வருமாறு அச்சிடுகிறோம்.
பெயர்:
வயது:
படிப்பு:
மாணவரின் எண்ணிக்கையைக் குறிப்பதற்காக வழக்கம்போல count என்கிற அடையாளங்காட்டியை பயன்படுத்தியிருக்கிறோம். for loop 3 முறை இயங்கும்.
முதல் செய்கையில்,
iயின் மதிப்பு -> (“Ram”, 18, “Engineering”)
i[0]: Ram
i[1]: 18
i[2]: Engineering
இரண்டாம் செய்கையில்,
iயின் மதிப்பு -> (“Raheem”, 19, “Mathematics”)
i[0]: Raheem
i[1]: 19
i[2]: Mathematics
மூன்றாம் செய்கையில்,
iயின் மதிப்பு -> (“John”, 20, “Computer Science”)
i[0]: John
i[1]: 20
i[2]: Computer Science
ஒரு மாணவரின் விபரங்களை அச்சிட்டபிறகு ஒரு வரி இடைவெளி விடுவதற்காக ஒரு காலி print()ஐ பயன்படுத்தி இருக்கிறோம்.
வெளியீடு:
நிரல் 25: சராசரி மதிப்பெண்ணில் முதலில் வரும் மாணவரைக் கண்டறிதல்
ஒரு பட்டியலில் நான்கு உறுப்புகள்(மாணவர்கள்). ஒவ்வொரு உறுப்பும் மாணவரின் பெயர் மற்றும் அவர்தம் பெற்ற மதிப்பெண்கள் என 2 துணை உறுப்புகளாக மா.பட்டியலில் சேமிக்கப்பட்டு இருக்கின்றன.
இப்போது for loopஐ பயன்படுத்தி பட்டியலின் ஒவ்வொரு உறுப்பாக எடுத்து மாணவர்களின் சராசரியைக் கண்டுபிடித்து, ஒப்பிட்டு யார் முன்னிலையில் இருக்கிறார் என்பதை அச்சிடவிருக்கிறோம்.
for loopன் நான்கு செய்கைகளில் ஒன்றை மட்டும் எடுத்துக்கொண்டு சராசரியை கண்டுபிடிப்போம். மற்ற மூன்றும் “Dry Run”.
முதல் செய்கை,
name=student[0]-> Ram
scores=student[1]-> [85, 90, 92]
total=sum(scores)-> 267. அது ஒன்றுமில்லை, sum() என்ற மு.வ.செயல்பாட்டைப் பயன்படுத்தி 3 மதிப்பெண்களின் கூட்டுத்தொகையைக் கணக்கிட்டு இருக்கிறோம்.
average=total/len(scores)-> 267/3->89
கணக்கிடப்பட்டுள்ள சராசரியை, highest_score என்னும் அடையாளங்காட்டியின் மதிப்போடு ஒப்பிட்டுப் பார்க்கிறோம்.
267>0, சரி தானே? இதேபோல ரஹீம், ஜான், சித்தார்த் ஆகியவர்களுக்கும் ஒவ்வொருவராகக் கணக்கிட்டுப்பார்த்து, யார் சராசரியில் முந்துகிறார் என்பதை இறுதியாக நிரல் அச்சிடுகிறது.
மற்ற மூன்று செய்கைகளுக்கும் இதேபோல மதிப்பிட்டுப் பார்ப்பதற்குத் தவறாதீர்கள்.
வெளியீடு:
நிரல் 26: பணியாளர்களுக்கான தரவுக்கிடங்கை உருவாக்குதல்
ஏடிஎம் இயந்திரத்தில் பயனர் தேர்வு செய்யும் விருப்பத்திற்கு ஏற்றவாறு செயல்பாடுகள் நடக்கும் தானே? கிட்டத்தட்ட அதேபோலத்தான் பின்வரும் நிரலும் இயங்குகிறது. இப்படித் தேர்வு செய்யச்சொல்லிக் கேட்கும் நிரல்களை “Menu Driven Program” என்று அழைக்கிறோம்.
1ஐ அழுத்தி, students_database என்ற பட்டியலில் எத்தனை பணியாளர்களின் விபரங்களை(பெயர்,வயது) வேண்டுமானாலும் இணைத்துக்கொண்டே போகலாம்.
பல பணியாளர்களின் விபரங்கள் பட்டியலில் இணைக்கப்பட்டு விட்டது. இப்போது குறிப்பிட்ட ஒருவர் பட்டியலில் இருக்கிறாரா என்று தேடிக்கண்டறிய வேண்டும்.
பணியாளரைத் தேடுவதற்கு எண் 2ஐ அழுத்தவும்.
“போதும்யா சாமி, கெளம்பணும் ஆளை விடுங்க” என்பவர்கள் 3ஐ அழுத்தவும். உண்மையிலேயே இந்நிரல் இப்படித்தான் செயல்படுகிறது.
பணியாளரின் பெயர், வயது ஆகியவற்றை மா.பட்டியலில் சேமித்து, அதைக் குறிக்க employee என்ற அடையாளங்காட்டியை பயன்படுத்தியிருக்கிறோம். பிறகு append() செயல்பாட்டின் மூலம் employeeயை, employee_database பட்டியலோடு இணைத்திருக்கிறோம்.
பயனர் தரும் பெயர் பட்டியலில் இருக்கிறதா என்பதைப் பரிசோதிக்க == இயக்கியைப் பயன்படுத்தி உறுதி செய்துகொள்கிறோம்.
நிறைவாக வெளியேற விரும்புகிறவர்களுக்காக break.
இப்போதைக்கு நமக்குத் தேவைப்படுவதும் அதேதான்.
வெளியீடு:
(தொடரும்)
