கணிதத் தேர்வுகளில் தேர்ச்சி பெறத் தேவையான மதிப்பெண்களை ஈட்ட இன்றும் பலருக்கும் உதவியாக இருப்பது அமைப்புகள்(sets) தலைப்புதான். அப்படிப்பட்ட தியாகிக்கு பைத்தானில் இடமில்லை என்று சொன்னால் தகுமா? தாராள மனசுக்குச் சொந்தக்காரரான பைத்தான் அமைப்புகளுக்கு என ஒரு தரவு கட்டமைப்பையே உருவாக்கி நிரலாளர்களுக்கு தருகிறார். பள்ளிப் பருவங்களில் பாஸ் மதிப்பெண் எடுக்க அமைப்புகளில் எதையெல்லாம் கற்றுக்கொண்டீர்களோ, அந்த மொத்த வித்தையையும் பைத்தானிலும் இறக்கி வைக்கலாம். இந்த அத்தியாயத்தில் அதைத்தான் பார்க்கவிருக்கிறோம்.
தனித்துவமான உறுப்புகளை வரிசைப்படுத்தப்படாத வகையில் அமைப்புகளின் மூலம் பைத்தான் சேமிக்கிறது. அப்படியென்றால் தனித்துவமான உறுப்புகள் மட்டும் தானா? அதன் நகல் இடம்பெறாதா என்றால், பெறாது என்பது தான் பதில். அமைப்புகள் தனித்துவமான உறுப்புகளை மட்டும் தான் சேமிக்கும், மேலும் அவை மாறும் தன்மை கொண்டவையாகவும் இருக்கும். இதுவரை நாம் பார்த்த தரவு கட்டமைப்புகளில் பட்டியல், அகராதி மற்றும் அமைப்புகள் இவை மூன்று மட்டும் தான் மாறும் தன்மைகொண்டவை என்பதை நினைவில் கொள்க.
கணித பாடங்கள் எல்லாம் என் நினைவில் இல்லை, நிரலில் அமைப்புகள் எதற்காகப் பயன்படுகிறது என்று கேட்பவர்களுக்கு ‘மாறும் தன்மைகொண்ட தனித்துவமான உறுப்புகளை வரிசைப்படுத்தப்படாத வகையில் சேமிக்க’ என்று ஒரே வரியில் சொல்லலாம்.
ஓர் அமைப்பை எப்படி உருவாக்குவது?
குறிப்பு: நிரலோடு சேர்த்து அதன் வெளியீடும் ஒரே திரைச்சொட்டாக இணைக்கப்பட்டிருக்கிறது.
நிரல் 1: அமைப்பை உருவாக்குதல்
அமைப்பை உருவாக்க சாத்தியமான 2 வழிகளும் மேற்கண்ட நிரலில் உள்ளன. அகராதியில் பயன்படுத்தப்பட்ட அதே சுருள் அடைப்புக்குறிகளைத் தான் அமைப்புகளுக்கும் பயன்படுத்தி இருக்கிறோம். வேறுபாடு உங்களுக்குப் புரிகிறது தானே? அகராதியிலிருந்த {சாவி:தரவுகள்} இணை இங்கே இல்லை. மாறாகச் சுருள் அடைப்புக்குறிக்குள் காற்புள்ளிகளுக்கு இடையே உறுப்புகளை மட்டும் இணைத்தால் அமைப்பை உருவாக்கிவிடலாம்.
இரண்டாம் வழிமுறை set() என்ற செயல்பாட்டுக்கு, சேமிக்கப்பட இருக்கும் உறுப்புகளைப் பட்டியலாக அனுப்பினால் அமைப்புகள் தயார்.
நிரல் 2: தனித்துவமான உறுப்புகள் எனும் பண்பை உறுதி செய்தல்
அமைப்புகள் தனித்துவமான உறுப்புகளை மட்டும் தான் சேமிக்குமா? ஒருவேளை உறுப்புகளின் நகல் இடம்பெற்றிருந்தால் என்ன நடக்கும்? அவையெல்லாம் நீக்கப்பட்டு தனித்துவமான அமைப்புகள் மட்டுமே அரியணை ஏறும்.
நிரல் 3: அமைப்புகளைப் புதுப்பித்தல்
மாறும் தண்மைகொண்ட த.கட்டமைப்பு என்பதால் ஒன்று அல்லது அதற்கும் மேற்பட்ட உறுப்புகளை அமைப்பில் இணைக்கலாம். ஒரு உறுப்பு மட்டும் போதுமானதாக இருந்தால் add() செயல்பாட்டையும், பல உறுப்புகளைச் சேர்க்கவேண்டிய தேவையிருந்தால் update() செயல்பாட்டையும் பயன்படுத்தலாம், பல உறுப்புகளை இணைக்க முற்படும்போது அவை பட்டியலாக அனுப்பப்படவேண்டும்.
நிரல் 4: உறுப்புகளை நீக்குதல்
மேற்கண்ட நிரலில் 2 மு.வ.செயல்பாட்டைப் பயன்படுத்தியிருக்கிறோம். இரண்டும் ஒரே உறுப்பைத்தான் அளவுருவாக எடுத்துக்கொள்கிறது. எனில் என்ன வேறுபாடு? நீங்கள் அனுப்பும் உறுப்பு அமைப்பிலிருந்தால் மட்டும் remove() அதை நீக்கித்தரும். ஒருவேளை இல்லையென்றால் பிழை வெளியீடாகக் காண்பிக்கப்படும்.
அதெல்லாம் இல்லை. உறுப்பு இருந்தால் நீக்கப்படவேண்டும், இல்லையென்றால் பிழையும் காண்பிக்கக்கூடாது என்பவர்களுக்காகத் தான் discard().
அமைப்பின் பண்புகள்:
சேர்ப்பு(union), வெட்டு(intersection), வித்தியாசம்(difference) போன்ற அமைப்பின் பண்புகளைப் பள்ளிப் பருவங்களில் படித்திருப்போம் தானே? அதற்கு இணையான நிரலை அடுத்துப் பார்ப்போம்.
நிரல் 5: அமைப்பின் பண்புகள்
set 1, set 2 என்ற இரண்டு அமைப்பு அடையாளங்காட்டிகளை உருவாக்கியிருக்கிறோம். அவற்றின் மீது அமைப்பின் பண்புகளை ஏவி விட்டிருக்கிறோம்.
set1 = {1,2,3}
set2 = {4,5,6}
சேர்ப்பு (union()):
set1 | set2.
இரண்டு அமைப்புகளையும் சேர்த்து எழுதுதல், {1,2,3,4,5,6}
வெட்டு (intersection()):
set1 & set2.
இரண்டு அமைப்புகளுக்கும் பொதுவான உறுப்பை எழுதுதல், {3}
வேறுபாடு (difference()):
set1 – set2.
set1ல் மட்டும் இடம்பெற்று, set2வில் இல்லாத உறுப்புகளை எழுதுதல். {1,2}
சமச்சீர் வேறுபாடு (symmetric_difference()):
set1 ^ set2.
இரண்டு அமைப்புகளுக்கும் பொதுவாக உள்ள உறுப்புகள் முதலில் நீக்கப்பட்டு, அவ்வமைப்புகளில் இடம்பெற்றுள்ள தனித்துவமான உறுப்புகளை மட்டும் சேர்த்து எழுதுதல்.
{1,2,4,5}
ஒவ்வொரு பண்பிற்கும் இணையான செயல்பாடுகள் உண்டு, மற்றொரு வழிமுறையாக அதற்கு இணையான சின்னங்களையும்( சேர்ப்பு |, வெட்டு &, வேறுபாடு -, சமச்சீர் வேறுபாடு ^) பயன்படுத்தலாம்.
நிரல் 6: அமைப்பில் உறுப்பின் இருப்பை உறுதி செய்தல்
in இயக்கியைக்கொண்டு ஒரு அமைப்பில் குறிப்பிட்ட ஒரு உறுப்பு இடம்பெற்றிருக்கிறதா என்பதை உறுதி செய்துகொள்கிறோம்.
நிரல் 7: துணை அமைப்பை(subset) உறுதி செய்தல்
set1, set2ன் துணை அமைப்பு என்பதை மேற்கண்ட நிரலைக்கொண்டு உறுதிசெய்கிறோம். துணை அமைப்பு என்பதை, set1றின் அனைத்து உறுப்புகளும் set2லும் இடம்பெற்றிருப்பது என்று புரிந்துகொள்ளலாம். issubset() என்ற செயல்பாடு இதைச் சாத்தியமாக்குகிறது.
இதுவே தலைகீழாக இருந்தால், அதாவது set2வின் அனைத்து உறுப்புகளும் set1றில் இடம்பெற்றிருந்தால் அது superset. அடுத்த நிரல் அதைத்தான் உறுதி செய்கிறது.
நிரல் 8:
நிரல் 9: பொதுவான உறுப்புகள் இல்லாத அமைப்புகளை உறுதி செய்தல்
isdisjoint() என்ற செயல்பாட்டின் மூலம், 2 அமைப்புகளுக்கும் இடையே எந்தவொரு பொதுவான உறுப்பும் இல்லை என்பதை உறுதி செய்கிறோம்.
நிரல் 10: அமைப்பை பயன்படுத்தி பட்டியலில் உள்ள நகல்களை களைதல்
நகல்களைக்கொண்ட பட்டியலை set() செயல்பாட்டிற்கு அனுப்பினால் என்ன நடக்கும்? தெரிந்தது தானே, தனித்துவமான உறுப்புகள் மட்டும் தான் இடம்பெறும். அவை மீண்டும் பட்டியலாக மாற்றப்பட்டு அச்சிடப்பட்டால், தனித்துவமான உறுப்புகளைக்கொண்ட பட்டியல் தயார்.
நிரல் 11: 2 பட்டியல்களில் உள்ள பொதுவான உறுப்புகளைக் கண்டறிதல்
அவ்விரண்டு பட்டியல்களும் அமைப்புகளாக மாற்றப்பட்டு, அவற்றின்மீது வெட்டு பண்பு பயன்படுத்தப்படுகிறது. பொதுவான உறுப்புகள் கிடைத்ததும் அவை மீண்டும் பட்டியலாக மாற்றப்பட்டு அச்சிடபடுகின்றன.
நிரல் 12: பட்டியலிலுள்ள தனித்துவமான உறுப்புகளை மட்டும் எண்ணி அச்சிடுதல்
1) பட்டியலை அமைப்பாக மாற்றுகிறோம்.
2) அதன் உறுப்புகளை len() செயல்பாட்டை பயன்படுத்தி எண்ணி அச்சிடுகிறோம்.
தனித்துவமான உறுப்புகளை மட்டுமே கொண்டிருத்தல் எனும் பண்பின் காரணமாக, பெருமளவில் அட்டவணை போன்ற கட்டமைப்பு எங்கெல்லாம் நிரலில்
தேவைப்படுகிறதோ, அமைப்பு எங்கெல்லாம் பயன்படுகிறது. கணினி அறிவியலின் முக்கிய செயல்பாடான Hash Table உருவாக்கத்திற்கு பைத்தானின் கொடை என்றே அமைப்பை சொல்ல முடியும்.
0
இந்த அத்தியாயத்தோடு Core Python என்று சொல்லகூடிய, பைத்தான் நிரலாக்க மொழியின் முக்கிய பாடங்களை கற்று வந்திருக்கிறோம். வலது கையால் நமது இடது தோள்பட்டையை கொஞ்சம் தட்டிக்கொள்ளலாம்.
அடுத்த அத்தியாயம் முதல் பைத்தான் நிரலாக்க மொழியின் மற்றுமொரு சுழற்சி தொடங்கவிருக்கிறது. Advanced Python என்று வைத்துக்கொள்ளலாம்.
(தொடரும்)
