தரவுகளை வரிசைப்படுத்தப்பட்ட வழியில் சேமிப்பதற்காக பைதான் எனும் கணினிமொழியானது ஒன்றுக்கு மேற்பட்ட தரவுகளின் கட்டமைப்பு களைக் கொண்டுள்ளது. அவைகளுள் பட்டியல்கள்(Lists), மாறாத பட்டியல்கள்(Tuples) ஆகியஇரண்டு தரவுகளின் கட்டமைப்பு களுக்குமட்டுமான ஒருசில பொதுவான தன்மைகளையும் இவ்விரண்டின் வெவ்வேறான தரவுகளின் கட்டமைப்புகளின் அவசியத்தைப் பற்றிய புரிதலையும் இந்த கட்டுரையில் காணலாம். இந்த இரண்டு வகைதரவுகளின் கட்டமைப்புகளிலும் நினைவகம் எவ்வாறு நிர்வகிக்கப்படுகிறது என்பதையும் இதில் காணலாம். இந்த கட்டுரை CPython செயல்படுத்தலின் அடிப்படையில் எழுதப்பட்டுள்ளது என்ற செய்தியையும் மனதில் கொள்க.
பட்டியல்கள்(Lists),மாறாத பட்டியல்கள்(Tuples) ஆகிய இரண்டிற்கும் இடையிலான பொதுவான தன்மைகள்:
இவ்விரண்டும் வரிசையான தரவு வகைகளை கொண்டுள்ளன. பட்டியல்களில்சேமிக்கப்பட்ட ஒவ்வொரு உறுப்பும் எந்த வொரு தரவு வகையிலும் இருக்கலாம். உறுப்புகளை சுட்டுவரிசைபடுத்துல், நறுக்குதல் ஆகியவற்றின் மூலம் அணுகலாம். இரண்டும் நகல்களை அனுமதிக்கின்றன. எடுத்துக்காட்டு களுடன் இவ்விரண்டும் எவ்வாறு வேறுபடுகின்றன என்பதை இப்போது காண்போம்.
பட்டியல்கள்(Lists)
இவை இயற்கையில் மாறக்கூடியவை, மேலும் அவை வரிசைப்படுத்தக்கூடியவை. எந்தவொரு பொருளையும்( object) சேமிக்க இதனைப் பயன்படுத்தலாம். இதற்கான ஒரு எடுத்துக்காட்டு பின்வருமாறு:
# பட்டியலிற்கான எடுத்துகாட்டு
list1 = [1, 2, “three”, 4, 5]
print(type(list1))
print(list1)
இதனுடைய வெளியீடு பின்வருமாறு:
<class ‘list’>
[1, 2, ‘three’, 4, 5]
நறுக்குதல் (Slicing)
பின்வரும் வழிகளில் ஒரு பட்டியலின் உள்ளடக்கங்களை அணுகலாம்:
# சுட்டுவரிசையைப் பயன்படுத்தி உறுப்புகளை அணுகலாம்; முதல் 2 சுட்டுவரிசைகள்
print(list1[0:2])
# சுட்டுவரிசையைப் பயன்படுத்தி உறுப்புகளை அணுகலாம்; பின்புற 2 சுட்டுவரிசைகள்
print(list1[-2:])
இவைகளின் வெளியீடுகள் பின்வருமாறு:
[1, 2]
[4, 5]
மாற்றக்கூடியது(Mutable)
பட்டியலில் உள்ள மதிப்புகளை நாம் பின்வருமாறு திருத்தலாம்:
#பட்டியல் மாற்றக்கூடியது, அதாவது பட்டியலின் மதிப்பை (உறுப்பை)மாற்றலாம்
ist1[0] = 100
print(type(list1))
print(list1)
இதனுடைய வெளியீடு பின்வருமாறு:
<class ‘list’>
[100, 2, ‘three’, 4, 5]
நினைவக ஒதுக்கீடு (Memory allocation)
இந்த கட்டுரையின் முக்கிய சிக்கலிற்கு இப்போது வந்துள்ளோம் – பட்டியலில் உள்ள பொருட்களை சேமிக்கும் போது நினைவகம் எவ்வாறு நிர்வகிக்கப்படுகிறது. தற்போது எவ்வளவு நினைவகம் ஒதுக்கப்பட்டுள்ளது என்பதை முதலில் காண்போம், பின்னர் ஒவ்வொரு முறையும் புதிய உறுப்புகள் ஒதுக்கப்படும் போது அதனுடைய அளவு எவ்வாறு மாறுகிறது என்பதை காண்போம். முதலில் தற்போது ஒதுக்கப்பட்ட நினைவகத்தை சரிபார்க்கலாம்:
# ஒதுக்கப்பட்ட நினைவகத்தை சரிபார்த்தல்
import sys
print(sys.getsizeof(list1))
இதனுடைய வெளியீடு பின்வருமாறு இருக்கும் :
96
மதிப்புகள் சேர்க்கப்படுவதற்கு முன்பும் பின்பும் எவ்வளவு நினைவகம் ஒதுக்கப்படுகிறது என்பதைக் காண ஒரு பொதுவான செயலி பின்வருமாறு:
# புதிய உறுப்பினைச் சேர்த்தல்
def append_into_list(value):
print(“address: “, id(list1))
print(“before size of list: “, sys.getsizeof(list1))
list1.append(value)
print(“updated list: “, list1)
print(“address remains the same: “, id(list1))
print(“after sizes of list: “, sys.getsizeof(list1))
print(“”)
தயவுசெய்து பட்டியலின் அளவு , நினைவக முகவரியை உன்னிப்பாக கவனித்து புதுப்பிப்பை செய்திடுக. குறிப்பு: கீழே கொடுக்கப்பட்டுள்ள சூழ்நிலையில், நினைவக முகவரி மாறவில்லை, ஆனால் இவ்வாறு எப்போதும் இருக்காது.
# மேலும் இரண்டு மதிப்புகளைச் சேர்த்த பிறகு பட்டியல் அளவை காணுதல்
append_into_list(6)
append_into_list(7)
append_into_list(8)
append_into_list(9)
append_into_list(10)
append_into_list(11)
append_into_list(12)
இதனுடைய வெளியீடு பின்வருமாறு:
address: 140509666477824
before size of list: 96
updated list: [100, 2, ‘three’, 4, 5, 6]
address remains the same: 140509666477824
after size of list: 128
address: 140509666477824
before size of list: 128
updated list: [100, 2, ‘three’, 4, 5, 6, 7]
address remains the same: 140509666477824
after size of list: 128
address: 140509666477824
before size of list: 128
updated list: [100, 2, ‘three’, 4, 5, 6, 7, 8]
address remains the same: 140509666477824
after size of list: 128
address: 140509666477824
before size of list: 128
updated list: [100, 2, ‘three’, 4, 5, 6, 7, 8, 9]
address remains the same: 140509666477824
after size of list: 128
address: 140509666477824
before size of list: 128
updated list: [100, 2, ‘three’, 4, 5, 6, 7, 8, 9, 10]
address remains the same: 140509666477824
after size of list: 192
address: 140509666477824
before size of list: 192
updated list: [100, 2, ‘three’, 4, 5, 6, 7, 8, 9, 10, 11]
address remains the same: 140509666477824
after size of list: 192
address: 140509666477824
before size of list: 192
updated list: [100, 2, ‘three’, 4, 5, 6, 7, 8, 9, 10, 11, 12]
address remains the same: 140509666477824
after size of list: 192
மேலே பார்த்தவைகளில், பட்டியலின் அளவு முதலில் 96 முதல் 128 வரை விரிவடைந்தது, ஆனால் அடுத்த இரண்டு உறுப்புகளுக்கும் இது மாறவில்லை, சிறிது நேரம் அப்படியே இருந்தது. பின்னர் அளவு 192 ஆக விரிவடைந்தது. காரணம், CPython இல் நினைவகமானது துகள்களில் (chunks)முன்பே ஒதுக்கப் பட்டுவிடு கின்றது. அடிக்கடி அதிகஅளவு கணினிஅமைவுகளின் அழைப்புகளை செய்வதைத் தவிர்க்க இவ்வாறு செய்யப்பட்டுள்ளது. இதனை பார்த்தால், ஒதுக்கீடு நிலையானது அன்று, லேசானதும் நேரியலாகவும் இருக்கின்றது என தெரியவருகின்றது. தற்போதைய நினைவகத்தை நீட்டிக்க மறு ஒதுக்கீடு செயல்படுத்தப் படுகிறது. எனவே நம்மிடம் ஒரு பெரிய கோவை(array) தேவைப்படும்போது, மறு ஒதுக்கீட்டிற்கு அதிக இடம் இல்லாதபோது, அது புதிய நினைவகத்தையும் நகலையும் உருவாக்குகின்றது; இது மிகவும் விலையுயர்ந்த(அதிக செலவுபிடிக்கும்) நடவடிக்கையாக இருக்கின்றது. இதனைத் தவிர்க்க, தேவையான நினைவகத்தை முன்கூட்டியே ஒதுக்கீடுசெய்திடலாம். பட்டியலை C இல் செயல்படுத்துவதற்கான குறிமுறிவரிகளின் துணுக்கு பின்வருமாறு.
#### Cpython : github.com/python/cpython/blob/master/Objects/listobject.c
‘’’
/* This over-allocates proportional to the list size, making room
* for additional growth. The over-allocation is mild, but is
* enough to give linear-time amortized behavior over a long
* sequence of appends() in the presence of a poorly-performing
* system realloc().
* Add padding to make the allocated size multiple of 4.
* The growth pattern is: 0, 4, 8, 16, 24, 32, 40, 52, 64, 76, 88, 120, 160 …
* Note: new_allocated won’t overflow because the largest possible value
* is PY_SSIZE_T_MAX * (9 / 8) + 6 which always fits in a size_t.
*/
new_allocated = ((size_t)newsize + (newsize >> 3) + 6) & ~(size_t)3;
/* Do not overallocate if the new size is closer to overalocated size
* than to the old size.
*/
‘’’
### eg: if the current size is 24
### ((size_t)newsize + (newsize >> 3) + 6) == increases the one eighth which is 15 so 24+3 => 24+6 = 30
### ~(size_t)3 = -4
### 30 & -4 = 32
### குறிப்பு: பட்டியலில் பயன்படுத்தப்படும் பொருளின் அளவைப் பொறுத்து கணக்கீடுகள் மாறுபடும்
வெற்று பட்டியல் (Empty list)
வெற்று பட்டியல் உருவாக்கப்படும்போது, அது எப்போதும் வேறு முகவரிக்கு சுட்டிக்காட்டப்படும். இது முன்பே ஒதுக்கப்பட்ட நினைவகத்தையும் வைத்திருக்கின்றது.
# இரண்டு வெற்று பட்டியல்களை உருவாக்கும் போது அவை வேறுபட்ட முகவரி இடங்களாக இருக்கும்
a = []
b = []
if a is not b :
print(“A and B are not mapped to same address”)
print(“address of a: “, id(a))
print(“address of b: “, id(b))
print(“A size of list: “, sys.getsizeof(a))
print(“B size of list: “, sys.getsizeof(b))
இதனுடைய வெளியீடு பின்வருமாறு:
A and B are not mapped to same address
address of a: 140509666702080
address of b: 140509666510912
A size of list: 56
B size of list: 56
அகற்றுதலும் இடைச்செருகுதலும்(Removal and insertion)
பட்டியலின் ஏதேனும் உறுப்புகளை அகற்றிடும்போது, அதற்காக ஒதுக்கப்பட்ட நினைவகமானது மாறியின் முகவரியை மாற்றாமல் சுருங்கும். இடைச்செருகலைச் செய்யும்போது, ஒதுக்கப்பட்ட நினைவகம் விரிவடையும், முகவரியும் மாறக்கூடும்.
# கோவையின் இடையில் இருந்து ஒரு உறுப்பை மேல்மீட்பு செய்தல்
print(“address before change: “, id(list1))
print(“Remove element from list”, list1.pop(2))
print(“Size of list after removal: “, sys.getsizeof(list1))
print(“Remove element from list”, list1.pop(2))
print(“Size of list after removal: “, sys.getsizeof(list1))
print(“Remove element from list”, list1.pop(2))
print(“Size of list after removal: “, sys.getsizeof(list1))
print(“Remove element from list”, list1.pop(2))
print(“Size of list after removal: “, sys.getsizeof(list1))
print(“Remove element from list”, list1.pop(2))
print(“Size of list after removal: “, sys.getsizeof(list1))
print(list1)
print(“address after change: “, id(list1))
இதனுடைய வெளியீடு பின்வருமாறு:
address before change: 140509666477824
Remove element from list three
Size of list after removal: 192
Remove element from list 4
Size of list after removal: 192
Remove element from list 5
Size of list after removal: 192
Remove element from list 6
Size of list after removal: 192
Remove element from list 7
Size of list after removal: 136
[100, 2, 8, 9, 10, 11, 12]
address after change: 140509666477824
# கோவைகளுக்கு இடையில் இருந்து ஒரு உறுப்பை மேல்மீட்பு செய்தல்
print(“address before change: “, id(list1))
list1.insert(3, 30)
print(list1)
print(“address after change: “, id(list1))
இதனுடைய வெளியீடு பின்வருமாறு .
address before change: 140509666477824
[100, 2, 8, 30, 9, 10, 11, 12]
address after change: 140509666477824
வரிசைபடுத்துதல்(Sort)
வரிசையாக்கும் செயல்பாட்டிற்கு முன்பும் பின்பும் பட்டியலின் முகவரி மாற்றப்படாது.
# கோவையை வரிசைப்படுத்துதல்
print(“address before change: “, id(list1))
list1.sort()
print(list1)
print(“address after change: “, id(list1))
இதனுடைய வெளியீடு பின்வருமாறு .
குறிப்பு: வரிசைப்படுத்தப்பட்ட பிறகும், முகவரி அப்படியே உள்ளது.
address before change: 140509666477824
[2, 8, 9, 10, 11, 12, 30, 100]
address after change: 140509666477824
பட்டியல்களின்(Lists)செயல்திறன்(Performance)
• இணைத்தல் – O(1)
• விரிவாக்குதல் – O(k)
• கடைசிஉறுப்பினைமேல்மீட்புசெய்தல் – O(1)
• எங்குவேண்டுமானாலும்மேல்மீட்புசெய்தல் – O(n) worst case
• உள்செருகுதல் – O(n) worst case
• சுட்டுவரிசை – O(1)
• நறுக்குதல் – O(k)
• உள் இயக்குபவர் – O(n)
• வரிசைபடுத்துதல் – O(nlogn) – tim sort is used
இதில், n = உறுப்படிகள் எண்ணிக்கை(number of elements); k = k’th சுட்டுவரிசை; 1 = வரிசைஎண்1 . ஆகும்
மாறாத பட்டியல்கள்(Tuples)
மாறாத பட்டியல்கள்எவ்வாறு வரையறுக்கப்படுகின்றன எனஇப்போது காண்போம் , பட்டியல்களுடன் ஒப்பிடும்போது நினைவக ஒதுக்கீட்டில் அவை எவ்வாறு வேறுபடுகின்றன என்பதையும் காண்போம். மாறாத பட்டியல்களானவை இயற்கையாக மாறாதவைகளாகும் பட்டியல்களுடன் ஒப்பிடும்போது குறைந்த நினைவகங்களையே எடுத்துகொள்கின்றன
வரையறை: ஒரு மாறாத பட்டியல்(Tupl) எவ்வாறு வரையறுக்கப்படுகிறது என்பதற்கான விரைவான எடுத்துக்காட்டு பின்வருமாறு:
#பண்புக்கூறுதொகுதிக்கான(Tuple) எடுத்துகாட்டு
tuple1 = (‘one’, ‘two’, ‘three’)
print(type(tuple1))
print(tuple1)
இதனுடைய வெளியீடு பின்வருமாறு:
<class ‘tuple’>
(‘one’, ‘two’, ‘three’)
ஒற்றை மதிப்பை மாற்றுதல்
மாறாத பட்டியல்கள் இயற்கையில் மாறாதவை என்பதால், அவற்றின் மதிப்பை நாம் மாற்ற முடியாது. மாறாத பட்டியல்களின் மதிப்பை மாற்ற முயற்சிக்கும்போது ஏற்படும் பிழையை பின்வரும் எடுத்துகாட்டில் காணலாம்:
# மாறாத பட்டியல்கள்(Tuples) மாறாதவை
tuple1[0] = “cherry”
print(type(tuple1))
print(tuple1)
இதனுடைய வெளியீடு பின்வருமாறு:
TypeError Traceback (most recent call last)
<ipython-input-13-a780f574006b> in <module>
1 # tuple are immutable
—-> 2 tuple1[0] = “cherry”
3 print(type(tuple1))
4 print(tuple1)
TypeError: ‘tuple’ object does not support item assignment
ஒரு மாறாத பட்டியலை(Tuple) வேறொரு புதிய மாறாத பட்டியல்(Tuple) மூலம் மாற்றுதல்
ஒரு புதிய மாறாத பட்டியலைப்பெறுவதற்கு ஏற்கனவே உள்ள மாறாத பட்டியலின் மேலெழுதலாம்; உடன்அதனுடைய முகவரி மட்டும் மேலெழுதப்படுகின்றது:
# ஆனால் ஒரு மாறாத பட்டியலின்(Tuple1) மாறியை வேறு எந்த மதிப்புக்கும் மற்றொரு # மாறாத பட்டியலிற்கும்(Tuple) ஒதுக்கீடுசெய்திடலாம்.
print(“address before the change: “, id(tuple1))
tuple1 = (1, 2, 3, 4)
print(type(tuple1))
print(tuple1)
print(“address after the change: “, id(tuple1))
இதனுடைய வெளியீடு பின்வருமாறு:
address before the change: 140509666846336
<class ‘tuple’>
(1, 2, 3, 4)
address after the change: 140509667383792
ஒரு மாறாத பட்டியலின்(Tuple)உள்ளே பட்டியலை மாற்றுதல்
ஒரு மாறாத பட்டியல் எந்தவொரு மதிப்பையும் வைத்திருக்க முடியும் என்பதை நாம் அறிவோம். ஒரு மாறாத பட்டியலின் உள்ளே ஒரு பட்டியலைகூடச் சேமிக்க முடியும். தொடர்ந்து அதன் மதிப்பைத் திருத்த முயற்சிப்போம். நம்மால் திருத்த முடியுமா? இது பட்டியலை மாற்றுமா? இப்போது கண்டுபிடிக்கலாம்:
t = (1, 2, [10, 20, 30])
print(id(t), t)
t[2] += [40, 50]
இதனுடைய வெளியீடு பின்வருமாறு:
140509666702784 (1, 2, [10, 20, 30])
TypeError Traceback (most recent call last)
<ipython-input-15-cc42d1fec8cf> in <module>
1 t = (1, 2, [10, 20, 30])
2 print(id(t), t)
—-> 3 t[2] += [40, 50]
TypeError: ‘tuple’ object does not support item assignment
இது ஒரு பிழையை எறிந்துள்ளது என நமக்கு தெளிவாக தெரிகின்றது, எனவே இது மதிப்புகளையும் புதுப்பித்திருக்காது என அறிந்து கொள்க:
print(id(t), t)
இதனுடைய வெளியீடு பின்வருமாறு:
140509666702784 (1, 2, [10, 20, 30, 40, 50])
ஆனால் கவனமாகப் சரிபார்த்தால், மதிப்புகள் சேர்க்கப்படுவது தெரியவருகின்றது. இது பைதான் விசித்திரமாக நடந்து கொள்ளும் ஒரு விளிம்பு வழக்காகும் . எனவே, மாற்றக்கூடிய பொருட்களின்(items ) பட்டியல்களை மாறாத பட்டியல்களின்(Tuples) கட்டமைப்பில் வைப்பது சரியான ஆலோசனைஅன்று.
நினைவக ஒதுக்கீடு(Memory allocation)
ஒதுக்கப்பட்ட நினைவகத்தை சரிபார்த்திடுக – ஒரு மாறாத பட்டியலானது(Tuple) தேவையான நினைவகத்தை மட்டுமே பயன்படுத்துகிறது. மறுஅளவிட முடியாததால் இது ஒதுக்கப்படுவதில்லை.
print(sys.getsizeof(tuple1))
இதனுடைய வெளியீடு பின்வருமாறு இருக்கும்:
72
நினைவகத்தை மீண்டும் பயன்படுத்துதல்(Reuse memory)
நினைவகத்தை துண்டு துண்டாக வெட்டிகுறைக்கவும் ஒதுக்கீடுகளை விரைவுபடுத்தவும் , பைதான்ஆனது பழைய மாறாத பட்டியல்களை மீண்டும் பயன்படுத்திகொள்கிறது. ஒரு மாறாத பட்டியலானது(Tuple) இனி தேவையில்லைஎனும்போதும் 20 க்கும் குறைவான உறுப்புகளைக் கொண்டிருக்கும்போதும், அதை நிரந்தரமாக நீக்குவதற்கு பதிலாக, பைதான் அதை ஒரு இலவச பட்டியலுக்கு நகர்த்தி பின்னர் பயன்படுத்தி கொள்கிறது.
குறிப்பு: ஏதேனும் ஒன்று எப்போதும் உறுதியாக தெரியவில்லை என்றாலும், அதற்கான நினைவகம் மீண்டும் பயன்படுத்தி கொள்ளப்படும்.
a = (1,2)
print(id(a))
del a
b = (1,2)
print(id(b))
இதனுடைய வெளியீடு பின்வருமாறு:
140509665739520
140509665739520
காலியான மாறாத பட்டியல்(Tuple)
இரண்டு காலியான மாறாத பட்டியல்கள் உருவாக்கப்படும் போது, அவை ஒரே முகவரி இடத்தை சுட்டிக்காட்டுகின்றன. மாறாத பட்டியல்கள் ஒற்றையாக செயல்படுகின்றன, அதாவது பூஜ்ஜியத்தின் நீளத்துடன் எப்போதும் ஒரே ஒரு காலியான மாறாத பட்டியல் மட்டுமே இருக்கும்.காலியான மாறாத பட்டியல் ஒன்றை உருவாக்கும் போது, பைதான் ஏற்கனவே (முன்பே )ஒதுக்கப்பட்ட ஒன்றை சுட்டிக்காட்டுகிறது, இது ஏற்கனவேஇருந்த காலியான மாறாத பட்டியலின் நினைவகத்தில் அதே முகவரியைக் கொண்டிருக்கின்றது. இது சாத்தியமானதுதான், ஏனெனில் மாறாத பட்டியல்கள் மாறாதவை, ஒருசில சமயங்களில் இது ஏராளமான (நிறைய) நினைவகங்களை மிச்சப்படுத்துகிறது:
a = ()
b = ()
if a is b :
print(“A and B are not mapped to same address”)
print(“address of a: “, id(a))
print(“address of b: “, id(b))
print(“A size of list: “, sys.getsizeof(a))
print(“B size of list: “, sys.getsizeof(b))
இதனுடைய வெளியீடு பின்வருமாறு:
A and B are not mapped to same address
address of a: 140509600395328
address of b: 140509600395328
A size of list: 40
B size of list: 40
அகற்றுதலும் இடைச்செருகுதலும்(Removal and insertion)
தற்போதுள்ள மாறாத பட்டியலை(Tuple) புதுப்பிக்க முடியாது, ஆனால் அதனுடன் புதிய மாறாத பட்டியலை உருவாக்கலாம்; இது ஒரு புதிய முகவரியில் நகலெடுக்கப்படும்:
tuple1 = (‘one’, ‘two’, ‘three’)
print(id(tuple1), tuple1)
print()
tuple2 = (‘1’, ‘2’, ‘3’)
print(id(tuple2), tuple2)
print()
tuple3 = tuple1 + tuple2
print(id(tuple3), tuple3)
print()
இதனுடைய வெளியீடு பின்வருமாறு:
140509667635968 (‘one’, ‘two’, ‘three’)
140509666902208 (‘1’, ‘2’, ‘3’)
140509666693664 (‘one’, ‘two’, ‘three’, ‘1’, ‘2’, ‘3’)
வரிசைபடுத்துதல்(Sort)
மாறாத பட்டியல்கள்(Tuples)மாறாதவை என்பதால், அவற்றை நாம் மறைமுகமாக வரிசைப்படுத்த முடியாது. ஆயினும் அவ்வாறு செய்ய நாம் வரிசைபடுத்து(Sort)எனும் செயலியைப் பயன்படுத்தலாம்.
குறிப்பு: இது பட்டியலாகத் திருப்பி அனுப்பிவிடும்.
sorted_tuple1 = sorted(tuple1)
print(id(sorted_tuple1), type(sorted_tuple1), sorted_tuple1)
இதனுடைய வெளியீடு பின்வருமாறு:
140509667589312 <class ‘list’> [‘one’, ‘three’, ‘two’]
பெயரிடப்பட்ட மாறாத பட்டியல்கள்(Tuples)
பெயரிடப்பட்ட மாறாத பட்டியலிம் சாதாரண மாறாத பட்டியலும் புலப்பெயர்களின் இனத்தில் சேமிக்கப்படுவதால் ஒரே மாதிரியான நினைவகத்தைப் பயன்படுத்துகின்றன. எனவே நாம் மாறாத பட்டியலை அல்லது பெயரிடப்பட்ட மாறாத பட்டியலை பயன்படுத்தலாம். இருப்பினும், பெயரிடப்பட்ட மாறாத பட்டியலை நிரலின் படித்திடும் தன்மையை அதிகரிக்கின்றது. இது ஒரு ஊக்கபடுத்திடும் செயலாகும்!
from collections import namedtuple
City = namedtuple(“City”, “name country status”)
chennai = City(“Chennai”, “India”, “Red”)
print(chennai)
print(“Size of named tuple: “, sys.getsizeof(chennai))
normaltuple = (“Chennai”, “India”, “Red”)
print(normaltuple)
print(“Size of normaltuple tuple: “, sys.getsizeof(normaltuple))
இதனுடைய வெளியீடு பின்வருமாறு:
1.City(name=’Chennai’, country=’India’, status=’Red’)
2.Size of named tuple: 64
3.(‘Chennai’, ‘India’, ‘Red’)
4.Size of normaltuple tuple: 64
மாறாத பட்டியல்களின்(Tuples)செயல்திறன்(Performance)
• சுட்டுவரிசை – O(1)
• நறுக்குதல் – O(k)
• உள்இயக்குபவர் – O(n)
இதில், n = உறுப்படிகள் எண்ணிக்கை(number of elements); k = k’th சுட்டுவரிசை; 1 = வரிசைஎண்1. ஆகும்
குறிப்பு: மாறாத பட்டியல்கள்(Tuples) மாறாததால் அவை வரையறுக்கப்பட்ட வசதிகளை மட்டுமே கொண்டுள்ளன.
ஒட்டுமொத்தத்தில், நம்முடைய சேகரிப்பை தொடர்ந்து மாற்ற வேண்டியிருக்கும் போது நாம் பட்டியல்களைப் (Lists) பயன்படுத்திகொள்வது நல்லது என பரிந்துரைக்கப்படுகின்றது. பின்வரும் சூழல்களில் மட்டும் மாறாத பட்டியல்களைப்(Tuples) பயன்படுத்திகொள்க என பரிந்துரைக்கப்படுகின்றது:
1.தருமதிப்புகளுடன்(arguments) பணிபுரிதல்
2.ஒரு செயலியிலிருந்து இரண்டு அல்லது அதற்கு மேற்பட்ட உறுப்புகளைத் திருப்புதல்
3.அகராதியின் முக்கிய மதிப்பு ஒரு ஜோடிகளுக்கு மேல் பன்முறைசெயல்படுத்துதல்
4.சரங்களின்(String) வடிவமைப்பைப் பயன்படுத்துதல்
பொதுவாக பட்டியல்கள்(Lists) செயல்படுத்த சிக்கலானவை, அதே சமயம் மாறாத பட்டியல்கள்(Tuples) நினைவகத்தையும் நேரத்தையும் மிச்சப்படுத்துகின்றன (C எனும் கணினிமொழியின் குறிமுறைவரிகளில் ஒரு பட்டியல் ஆனது 3000+ குறிமுறைவரிகளைப் பயன்படுத்துகிறது, அதே சமயம் மாறாத பட்டியல்களுக்கு 1000+ வரிகள் மட்டுமே தேவையாகும்).