a. List
b. Tuple
c. Class
d. Tuple
e. List
f. Class

(i) list -ன் உறுப்புகளை இரு வழியில் அணுகலாம். முதல் வழி, அதிகம் பயன்படுத்தப்படும் பன்மடங்கு மதிப்பிருத்தல். இம்முறையில், list-ன் உறுப்புகள் பிரிக்கப்பட்டு, அனைத்து உறுப்புகளும் வேறு பெயர்களுடன் இணைக்கப்படுகிறது.
1st := [10, 20]
x,y := 1st
(ii) மேலே காணும் எடுத்துக்காட்டில், xயின் மதிப்பு 10 என்றும், Yயின் மதிப்பு 20 என மதிப்பிருத்தப்படும்.
(iii) இரண்டாம் முறையில் லிஸ்டின் உறுப்புகள், உறுப்புகள் தேர்வு செயற்குறிகள் மூலம் அணுகப்படுகிறது.
(iv) லிஸ்ட் லிட்டரல்ஸ் போல் அல்லாது கோவையில் ஒரு சதுர அடைப்புக்குறியை தொடர்ந்து வரும் மற்றொரு சதுர அடைப்புக்குறி லிஸ்டின் மதிப்புகளாக எடுத்துக்கொள்ளப்படுவதில்லை. ஆனால் முந்தைய கோவையின் உறுப்பை மதிப்பாக தேர்வு செய்யும்.
1st [0]
10
1st[1]
20

a. Constructors
b. Selectors
c. Selectors
d. Selectors
e. Constructors
f. Selectors

(i) விருப்பார்வ எண்ணம் என்ற சக்தி வாய்ந்த செயல் யுக்தியை பயன்படுத்தி நிரல் வடிவமைக்கப்படுகின்றது.
(ii) விருப்பார்வ எண்ணம் என்பது யதார்த்தத்திற்கு பதிலாக நம்பிக்கையின் அடிப்படையில் விருப்பத்திற்கு ஏற்ப முடிவெடுப்பதாகும்.

Tuple:
(i) Pairs என்பது இரு தரவு பகுதிகளை சேமிக்கும் கலவை தரவு என்பதை நினைவில் கொள்ள வேண்டும்.
(ii) இதுவரை இருவேறு முறைகளில் pairs தரவு வகை உருவமைப்பை முதல் வழி, List கொண்டு உருவமைத்தல் மற்றும் இரண்டாம் வழி Tuple கொண்டு வடிவமைத்தல் ஆகும்.
(iii) tuple என்பது அடைப்புக்குறிக்குள் கொடுக்கப்பட்டுள்ள தொடர் மதிப்புகளை காற்புள்ளியில் பிரிக்கப்பட்டிருக்கும். tuple என்பது List போன்றதாகும்.
(iv) இவை இரண்டிற்கும் உள்ள வேறுபாடு என்னவென்றால் tuple -ல் கொடுக்கப்பட்ட உறுப்புகளை மாற்ற முடியாது, ஆனால் List -ல் இடம்பெற்றுள்ள உறுப்புகளை மாற்றலாம். எடுத்துக்காட்டு:
 colour = ('red', 'blue', 'Green')
Tuple-சை Pair உருவமைத்தல்:
 nums: = (1, 2)
 nums[0]
 1
 nums[1]
 2
(v) சதுர அடைப்புக்குறி குறியீடு, பேர்ஸில் சேமிக்கப்பட்டுள்ள தரவுகளை அணுகுவதற்கு பயன்படுகிறது என்பதை கவனிக்கவும். தரவுகள் பூஜ்யம் சுட்டு வரிசைப்பட்டுள்ளதால், முதல் உறுப்பு nums[0] என்றும் இரண்டாம் உறுப்பு nums[1] என்றும் அணுகப்படும்.

(i) தரவு அருவமாக்கத்தின் அடிப்படை நோக்கம், நிரலினை அருவமாக்க தரவில் இயக்கும்படி கட்டமைப்பதாகும். அதாவது, நிரலில் தரவுகளை பயன்படுத்திக் கொள்ளும் போது அதைப்பற்றி சில ஊகங்களை செய்து கொள்ள வாய்ப்புள்ளது. அதே வேளையில் கான்கீரிட் தரவு உருவமைக்கும் போது நிரலின் தனிப்பகுதியாக வரையறை செய்ய வேண்டும்.
(ii) அனைத்து நிரல்களும் இரு பகுதிகளை கொண்டிருக்கும். அருவமாக்க தரவின் மீது செயல்படும் பகுதி மற்றும் அருவமாக்க தரவு வகையை செயல்படுத்தும் சில செயற்கூறுகளின் தொகுப்பை கொண்டு கான்கீரிட் உருவமைப்பை வரையறுக்கும் என இரு பிரிவுகளை கொண்டிருக்கும்.
(iii) எடுத்துக்காட்டு: விகிதமுறு எண்கள் முழு எண்களின் விகிதமாகும். அவை மெய் எண்களின் முக்கிய துணை வர்க்கமாக அமைகிறது. 8/3 அல்லது 19/23 போன்ற விகிதமுறு எண்களை பின்வருமாறு எழுதலாம்.
 < தொகுதி > / < பகுதி >
(iv) தொகுதி மற்றும் பகுதி ஆகிய இரண்டும் முழு எண்ணின் இடம் மதிப்புகளாகும். இந்த இரண்டு பகுதிகளும் விகிதமுறு எண்களை சரியாக கணிப்பதற்கு பயன்படுகிறது. முழு எண்களை வகுக்கும் போது முழு எண்ணின் துல்லியம் இழந்து தோராயமான மிதவை எண் கிடைக்கிறது.
8/3 =2. 6666666666666665 எனினும், சரியான முறையில் விகிதமுறு எண்களை குறிப்பதற்கு தொகுதி, பகுதி ஆகிய இரண்டையும் இணைந்து கொடுக்க வேண்டும்.
(v) செயற்கூறு கருத்துக்களைக் கொண்டு, நிரலின் சில பகுதிகளை செயல்படுத்துவதற்கு முன்னதாக நாம் ஒரு நிரலின் செயல்திறனை மேம்படுத்திக் கொள்ள முடியும். நாம், ஒரு விகிதமுறு எண்ணை, தொகுதி மற்றும் பகுதி கொண்டு அமைக்க முடியும் என்று கருதிக்கொள்வோம். அதே போன்று, கொடுக்கப்பட்ட விகிதமுறு எண்ணிற்கு நாம் தொகுதி மற்றும் பகுதியை தேர்ந்தெடுக்க முடியும். மேலும் கண்ஸ்டரக்டர் மற்றும் செலக்டர்ஸ் கொண்டும் நிறைவேற்றலாம்.
(vi) இதில் விஸ்புல் திங்கிங் என்ற சக்தி வாய்ந்த செயல் யுக்தியை பயன்படுத்தி நிரல் வடிவமைக்கப்படுகிறது. நாம் இதுவரை, ஒரு விகிதமுறு எண் எவ்வாறு அமைக்க வேண்டும் என்றோ அல்லது ஒரு கண்ஸ்டரக்டர் மற்றும் செலக்டர் எவ்வாறு செயல்படுத்தப்படுகிறது.
எடுத்துக்காட்டு:
- - constructor
- - constructs a rational number with numerator n, denominator d 
rational(n, d)
- - selector
numer(x) ⇾ returns the numerator of rational number x
denom(y) ⇾ returns the denominator of rational number y
(vii) இப்பொழுது, விகிதமுறு எண்களின் செயல்பாடுகள் செலக்டார் செயற்கூறுகள் நியூமர் மற்றும் டெனாம் கொண்டும் மற்றும் கண்ஸ்டரக்டர் செயற்கூறு ரேஸனல் கொண்டும் வரையறுக்கப்படுகிறது. ஆனால் இச்செயற்கூறுகள் வரையறுக்கப்படவில்லை. நமது தேவை என்னவென்றால், தொகுதி மற்றும் பகுதியை இணைத்து கூட்டு மதிப்பை உருவாக்கும் வழிமுறையாகும்.
(vii)  கண்ஸ்டரக்டர்ஸ் மற்றும் செலக்டர்ஸ் கொண்டு விகிதமுறு எண்களை உருவமைக்கும் போலிக் குறிமுறை 
 x, y: =8, 3
 rational(x, y)
 numer(x)/numer(y)
 - - output: 2. 6666666666666665

(i) structure அமைப்பை (OOP மொழியில் இது இனக்குழு அமைப்பு என்று அழைக்கப்படுகிறது) கொண்டு பல உருப்படி பொருளில் அனைத்து உருப்புகளும் பெயரிடப்படும் (பெயர் கொடுக்கப்பட்டு பின்வரும் போலிக்குறிமுறையை காணவும்):
class Person:
         creation()
         firstName := " "
         lastName := " "
         id := " "
         email := " "
Person எனும் புதிய தரவு வகையை படவடிவில் உருவமைக்கலாம்.

(ii) இனக்குழு கட்டமைப்பு ஒரு நபரை குறிக்கும் பல பகுதி பொருளுக்கு வடிவம் வரையறுக்கிறது. இந்த வரையறுப்பு புதிய தரவு வகையை சேர்க்கிறது. இதில் நபர் என்பது வகையாகும். ஒரு முறை வரையறுத்தலின், நாம் புதிய மாறிகளை உருவாக்கலாம்.
(iii) இந்த எடுத்துக்காட்டில் Person என்பது இனக்குழு அல்லது வகையாகும். p1 என்பது தனிப்பட்ட குக்கீ குறிக்கின்றது. குக்கீ கட்டர் கொண்டு பல குக்கீகளை தயாரிக்கலாம். அது போன்று இவ் இனக்குழுவைக் கொண்டு பல பொருள்களை உருவாக்கலாம்.
(iv) இதுவரை, இனக்குழு தொடர்புடைய தரவுகளைக் கொண்டு தரவு அருவமாக்கத்தை எவ்வாறு வரையறுக்கிறது என்று பார்த்தோம். ஓர் இனக்குழு என்பது தரவுகளை மட்டுமில்லாது செயற்கூற்றினையும் தன்னுடன் கொண்டிருக்கும்.
(v) இவ்வகை செயற்கூறுகள், இனக்குழுவிற்கு கீழ்ப்படிந்தவை, ஏனெனில் இவை இனக்குழுவின் தரவுகளை வைத்து செயல்படுகிறது.
(vi) எடுத்துக்காட்டு Person பொருளின் தரவுகளை மாற்றம் செய்தல் அல்லது ஆய்வு செய்தல் எனவே, இனக்குழு என்பது தரவு மற்றும் அத்தரவின் மீது செயலாற்றும் செயற்கூறுகளை கொண்ட தொகுப்பாகும்.
(vii) முன்னதாக பார்த்த எடுத்துக்காட்டு மற்றும் விளக்கத்தின் மூலம் அருவமாக்கம் என்பது சிக்கலான தரவுகளை எளிய முறையில் கையாள உதவுகின்றது என்பதை உணரலாம்.

List:
(i) List என்பது கோவைகளை சதுர அடைப்புக்குறிக்குள் காற்புள்ளியால்  பிரிக்கப்பட்டிருக்கும் அமைப்பு ஆகும். இவ்வகை கோவைகளை List literal என்று அழைக்கப்படுகிறது. List பல மதிப்புகளை சேமிக்கும் இம்மதிப்புகள் எவ்வகையாகவும் இருக்கலாம் அல்லது மற்றொரு லிஸ்டாகவும் இருக்கலாம்.
எடுத்துக்காட்டு : List[10, 20].
(ii) list-ன் உறுப்புகளை இரு வழியில் அணுகலாம். முதல் வழி, அதிகம் பயன்படுத்தப்படும் பன்மடங்கு மதிப்பிருத்தல். இம்முறையில், list-ன் உறுப்புகள் பிரிக்கப்பட்டு, அனைத்து உறுப்புகளும் வேறு பெயர்களுடன் இணைக்கப்படுகிறது.
lst := [10, 20]
x, y := lst
மேலே காணும் எடுத்துக்காட்டில், Xயின் மதிப்பு 10 என்றும், Y யின் மதிப்பு 20 என மதிப்பிருத்தப்படும்.
(iii) இரண்டாம் முறையில் லிஸ்டின் உறுப்புகள், உறுப்புகள் தேர்வு செயற்குறிகள் மூலம் அணுகப்படுகிறது. லிஸ்ட் லிட்டரல்ஸ் போல் அல்லாது கோவையில் ஒரு சதுர அடைப்புக்குறியை தொடர்ந்து வரும் மற்றொரு சதுர அடைப்புக்குறி லிஸ்டின் மதிப்புகளாக எடுத்துக்கொள்ளப்படுவதில்லை. ஆனால் முந்தைய கோவையின் உறுப்பை மதிப்பாக தேர்வு செய்யும்.
1st[0]
10
1st[1]
20
மேலே காணும் எடுத்துக்காட்டினை கணித முறையில் set போன்று அமைக்கலாம்.

(iv) இரு மதிப்புகளை ஒன்றாக இணைக்கும் முறையை இணைகள் (Pairs) என்று அழைக்கிறோம். List அதிகமாக பயன்படுத்தப்படும் முறையாகும். எனவே, List, Pairs என்று அழைக்கப்படுகிறது.

தரவு அருவமாக்கினை செயல்படுத்த, ஆக்கிகள் (Constructor) மற்றும் செலக்டர் (Selectors) என்ற இரண்டு செயற்கூறுகள் உருவாக்கப்பட வேண்டும்.
ஆக்கிகள் மற்றும் செலக்டர்கள் (constructors and selectors):
(i) ஆக்கி செயற்கூறுகள் அருவமாக்கம் தரவு வகையை கட்டமைக்க பயன்படுகிறது. செலக்டர் செயற்கூறுகள் தகவல்களை தரவு வகையிலிருந்து பெறுவதற்கு பயன்படுகிறது.
(ii) எடுத்துக்காட்டாக, city என்று ஒரு அருவமாக்க தரவு வகை உள்ளது என வைத்துக்கொள். City என்ற பொருள் நகரத்தின் பெயர், அட்சரேகை மற்றும் தீர்க்கரேகை பற்றிய தகவல்களை சேமித்திருக்கும் city என்ற பொருளை உருவாக்க பின்வரும் செயற்கூற்றினை பயன்படுத்தலாம்.
city := makecity (name, lat, lon)
(iii) city பொருளின் தகவல்களை பெறுவதற்கு பின்வரும் செயற்கூறுகளை பயன்படுத்தலாம்.
1. getname(city)
2. getlat(city)
3. getlon(city)
(iv) பின்வரும் போலி குறிமுறை இரு நகரங்களுக்கு இடையேயான தொலைதூரத்தை கணக்கிடும்.
distance(city1, city2):
lt1, lg1 := getlat(city1), getlon(city1)
lt2, 1g2:= getlat (city2), getlon (city2)
return ((lt1 - lt2)**2 + (lg1 - lg2)**2))^1/2
(v) மேலே காணும் குறிமுறையில், distance(), getlat() மற்றும் getlon() ஆகியவை செயற்கூறுகள் ஆகும். It என்பது அட்ச ரேகை மற்றும் lg என்பது தீர்க்கரேகையும் குறிக்கிறது. longitude. := என்பதை "assigned as" அல்லது "becomes" என்று வாசிக்க வேண்டும்.
It 1, lg1 := getlat(city1), getlon(city1)
(vi) இதனை It1 என்பது getlat(city1)ன் மதிப்பாகிறது மற்றும் lg1 என்பது getlon(city1) ன் மதிப்பாகிறது. என்று வாசிக்க வேண்டும்.
(vii) இந்த செயற்கூறுகள் எவ்வாறு செயல்படுத்தப்படுகிறது என்பதை தெரிந்து கொள்ள வேண்டியதில்லை. இதை வேறு ஒருவர் நமக்காக வரையறுத்துள்ளார் என்று கருதிக் கொள்ள வேண்டும். பயனர் செயற்கூறுகள் எப்படி செயல்படுத்தப்படுகின்றது என்று தெரிந்து வைத்திருக்க வேண்டியதில்லை எனினும் வேறு ஒருவரால் இச்செயற்கூறுகள் வரையறுக்கப்பட்டிருக்க வேண்டும்.
(viii) மேலே காணும் குறிமுறையில், ஆக்கி மற்றும் செலக்டர்களை அடையாளம் காண்போம். ஆக்கி செயற்கூறுகள் அருவமாக்க தரவு வகையை கட்டமைக்கப் பயன்படுகிறது என்பதை நாம் அறிவோம். மேலே காணும் போலிக் குறிமுறையில், cityயின் பொருளை உருவாக்கும் செயற்கூறு, ஆக்கி ஆகும்.
city := makecity(name, lat, lon) இங்கு makecity(name, lat, lon) என்ற ஆக்கி city எனும் பொருளை உருவாக்குகிறது.

(ix) செலக்டர் செயற்கூறுகள் தகவல்களை தரவு வகையிலிருந்து பெறுவதற்கு பயன்படுகிறது. மேலே காணும் குறிமுறையில்,
getname(city)
getlat(city)
getlon(city) என்பவை city எனும் பொருளிலிருந்து தகவல்களை பெற்றுத் தரும் செலக்டர் செயற்கூறுகளாகும்.