1. பைத்தான் பயனிலா (garbage) மதிப்புகளைச் சேகரிக்கும் தானியங்கியைப் பயன்படுத்துகிறது. இந்த பண்புக்கூறு C++ ல் கிடையாது.
2. C++ நிலையான வகையைச் (Statically typed) சார்ந்த மொழி, ஆனால் பைத்தான் ஒரு மாறக்கூடிய வகையைச் (Dynamically typed) சார்ந்த மொழியாகும்.
3. பைத்தான் இடைமொழி மாற்றி மூலம் இயங்குகிறது. ஆனால் C++ நிரல்பெயர்ப்பியின் மூலம் தொகுக்கப்பட்டு இயக்கப்படுகிறது.
4. C++ நிரல் குறிமுறையைக் காட்டிலும் பைத்தான் குறிமுறை 5 லிருந்து 10 மடங்கு குறைவானது.
5. பைத்தானில், வெளிப்படையாக தரவினங்களை அறிவிக்க தேவையில்லை. ஆனால் C++-ல் அவை அறிவிக்கப்பட வேண்டும்.
6. பைத்தானில், ஒரு செயற்கூறு எந்த வகை செயலுருபையும் ஏற்கும். மேலும், முன்னதாக எந்த ஒரு அறிவிப்பும் இல்லாமல் பல மதிப்புகளை திருப்பியனுப்பும். ஆனால் C++ return கூற்று ஒரே ஒரு மதிப்பை மட்டுமே திருப்பியனுப்பும்.

ஹிஸ்டோகிராம் மற்றும் பட்டை வரைபடங்களுக்கு இடையே உள்ள வேறுபாடுகளை பின்வருமாறு குறிப்பிடலாம்:
1. ஹிஸ்டோகிராம் வரைபடம், எண் வகை தரவுகளுக்கு இடையேயான அதிர்வெண்ணை பட்டை வடிவ வரைபடத்தில் காட்டும், பட்டை வரைபடம் பல்வேறு வகையான தரவுகளை ஒப்பிட பயன்படுகிறது.
2. ஹிஸ்டோகிராம், மாறிகளின் தொடருக்கு இடையேயான அதிர்வெண்ணை பட்டை வடிவ வரைபடம் வெவ்வேறான மாறிகளை ஒப்பிடும் படத்தை காண்பிக்கும்
3. ஹிஸ்டோகிராம் எண்வகை தரவுகளும், பட்டை வரைபடம் வகைப்படுத்தப்பட்ட தரவுகளிலும் செயலாற்றும்.
4. ஹிஸ்டோகிராம் உள்ள பட்டைகளுக்கு இடையே இடைவெளியிருப்பதில்லை. ஆனால் பட்டை வரைப்படத்தில் தோன்றும் பட்டைகளிடையே முறையான இடைவெளிகள் மூலம் தரவுகளுக்கிடையே தொடர்பின்மையை காண்பிக்கும்
5. ஹிஸ்டோகிராம் எண்கள் உறுப்புகளாக அவை தரவுகளின் தொடர்புகளை வெளிப்படுத்த ஒன்றாக வகைப்படுத்தப்படும், பட்டை வரைபடத்தில் தரவுகள் தனி உறுப்புகளாக கருதப்படுகிறது
6. பட்டை வரைப்படத்தில் தொகுதிகளை உச்ச மதிப்பிலிருந்து குறைந்த மதிப்பிற்கு மறு வரியிறக்கம் செய்ய முடியும். ஆனால் ஹிஸ்டோகிராமில் இவை தொடர் வரிசையாக இருப்பதால் இது சாத்தியமில்லை.
7. ஹிஸ்டோகிராமில் செவ்வக தொகுதியின் அகலம் ஒரே அளவில் இல்லாதிருக்கலாம். ஆனால் பட்டை வரைபடத்தில் எப்போதும் அகலம் ஒரே மாதிரியானதாக இருக்கும்.

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] என்றும் அணுகப்படும்.

str 1="ABCDEFGH"
str2=late"
for i in str1:
print ((i+str2),end='\t')
வெளியீடு:
Aate Bate Cate Date Eate Fate Gate Hate

தேவைப்படும் செயலுருபுகள்:
1) செயலுருபுகளை சரியான இடவரிசையில் செயற்கூற்றுக்கு அனுப்புவதே தேவைப்படும் செயலுருப்புகள் எனப்படும்.
2) இங்கு, செயற்கூறு அழைப்புக் கூற்றில் உள்ள செயலுருபுகளின் எண்ணிக்கை, செயற்கூறு வரையறையோடு சரியாக பொருந்த வேண்டும்.
3) தொடரியல் பிழையை தவிர்த்து, தேவையான வெளியீட்டை பெறுவதற்கு குறைந்தது ஒரு செயலுருபாவது  தேவை.
எடுத்துக்காட்டு:
def printstring( str):
print ("Example - Required arguments ")
print (str)
return
# Now you can call printstring() function
printstring("Welcome")
வெளியீடு:
Example - Required arguments
Welcome
சிறப்புச் சொல் செயலுருபுகள்:
1) அளபுருக்க்களின் பெயரை அடையாளம் கண்டபின்பு சிறப்புச் சொல் செயலுருபானது செயற்கூறினை அழைக்கிறது.
2) சிறப்புச் சொல் செயலுருபின் மதிப்பு அளபுரு பெயருடன் பொருந்த வேண்டும். எனவே, முறையற்ற வரிசையிலும் செயலுருபுகளைக் கொடுக்கலாம்.
எடுத்துக்காட்டு:
def printdata (name):
print ("Example-1 Keyword arguments")
print ("Name :",name) 
return
# Now you can call printdata() function
printdata(name = "Gshan")
வெளியீடு:
Example-1 Keyword arguments
Name :Gshan.
தானமைவு செயலுருபுகள்:
1) பைத்தானில், செயற்கூறை அழைக்கும் போது எந்த மதிப்பும் கொடுக்கப்படவில்லை எனில், செயலுருபானது தானாகவே மதிப்பை எடுத்துக் கொள்ளும். இதுவே தானமைவு செயலுருபு ஆகும்.
2) பின்வரும் எடுத்துக்காட்டில் செயலுருபுவை அனுப்பாதபோது தானமைவு Salary -யை அச்சிடுவதைக் காணலாம்.
எடுத்துக்காட்டு:
def printinfo( name, salary = 3500):
print ("Name:", name)
print ("Salary:", salary)
return
printinfo("Mani ")
வெளியீடு:
Name: Mani 
Salary: 3500
மாறும் நீள செயலுருபுகள்:
1) சில சமயங்களில், ஏற்கனவே குறிப்பிடப்பட்ட செயலுருபுகளை விட அதிகமான செயலுருபுகளை அனுப்ப வேண்டிய தேவை இருக்கும்.
2) மீண்டும் செயற்கூறினை மறுவரையறை செய்வது கடினமான செயல் அதற்கு பதிலாக மாறும் நீள செயலுருபுகளை பயன்படுத்தலாம்.
3) செயற்கூறு வரையறையில் இது குறிப்பிடப்படுவதில்லை. மாறாக இந்த செயலுருபுகளை குறிப்பிடுவதற்கு * குறியீடு பயன்படுகிறது.
மாறும் நீள செயலுருபின் பொதுவடிவம்:
def function_name(*args):
function_body
return statement
எடுத்துக்காட்டு:
def printnos (*nos):
for n in nos:
print (n)
return
# now invoking the printnos() function
print ('Printing two values')
printnos (1,2)
print ('Printing three values')
printnos (10,20,30)
வெளியீடு:
Printing two values
1
2
Printing three values
10
20
30

செருகும் வரிசையாக்கம் (Insertion sort):
எளிமையான வரிசையாக்க நெறிமுறையான இது நெறிமுறையின் முடிவில் இறுதியாக வரிசையாக்கம் செய்யப்பட்ட அணியினை அமைக்கும். இது அணியின் கீழ்பகுதியில் வரிசையாக்கம் செய்யப்பட்ட துணைப் பட்டியலை எப்பொழுதும் அமைத்துக்கொள்ளும்
செருகும் வரிசையாக்கத்தின் போலி குறிமுறை:
(i) படிநிலை 1: முதல் உறுப்பாக இருந்தால், அது ஏற்கனவே வரிசையாக்கம் செய்யப்பட்டது
(ii) படிநிலை 2: அடுத்து உறுப்பினைத் தேர்வு செய்ய வேண்டும்
(iii) படிநிலை 3: வரிசைப்படுத்தப்பட்ட துணைப்பட்டியலிலுள்ள உறுப்புகளோடு ஒப்பீடு செய்ய வேண்டும்
(iv) படிநிலை 4: வரிசைப்படுத்தப்பட்ட துணைப்பட்டியலிலுள்ள அனைத்து உறுப்புகளுக்கும் வரிசைப்படுத்தப்பட வேண்டிய மதிப்பை விட பெரிய மதிப்பாக இருந்தால் அதனை இடமாற்றம் செய்ய வேண்டும்.
(v) படிநிலை 5: மதிப்பைச் செருகுதல் வேண்டும்
(vi) படிநிலை 6: பட்டியல் வரிசைப்படுத்தப்படும் வரை இச்செயலை மீண்டும் மீண்டும் செய்ய வேண்டும்

மேலே கொடுக்கப்பட்டுள்ள பட்டியலின் மதிப்புகளைச் செருகும் வரிசையாக்கம் நெறிமுறை மூலம் வரிசையாக்கம் செய்யப்பட்டது
 

(i) அணுகல் கட்டுப்பாடு என்பது கணினி சூழலில் உள்ள வளங்களை யாரெல்லாம் பார்வையிட மற்றும் பயன்படுத்த முடியும் என்பதை வரைமுறைப்படுத்தும் ஒரு பாதுகாப்பு தொழில்நுட்பமாகும். இது பாதுகாப்பின் ஒரு அடிப்படைக் கருத்தாகும்.
(ii) பொருளுக்கான ஆபத்தைக் குறிக்கிறது. அதாவது அணுகல் கட்டுப்பாடு என்பது தரவை அணுகுவதற்கான குறிப்பிடப்பட்ட கட்டுப்பாடாகும்.
(iii) பொருள் நோக்கு நிரலாக்க மொழியில் இது அணுகியல்பு வரையறுப்புகள் மூலம் செயல்படுத்தப்படுகிறது
(iv) C++ மற்றும் Java போன்ற பொருள் நோக்கு மொழிகள் Private, Protected, Public என்னும் சிறப்புச் சொற்களைப் பயன்படுத்தி இனக்குழு உறுப்புகளின் அணுகலைக் கட்டுப்படுத்துகிறது
(v) Private உறுப்புகளை இனக்குழுவிற்கு வெளியே இருந்து அணுக முடியாது. இனக்குழுவிற்கு உள்ள மட்டும்தான் கையாள முடியும்
(vi) Public உறுப்புகளை இனக்குழுவிற்கு வெளியே இருந்தும் அணுக முடியும். Public வழிமுறையை செயலாக்க அந்த இனக்குழுவின் பொருள் தேவைப்படுகிறது
(vii) Protected உறுப்புகள் அந்த இனக்குழு மற்றும் அதன் துணை இனக்குழுக்களால் அணுகப்படலாம். இதை அணுகுவதற்கு வேறு எந்த செயல்முறையும் அனுமதிக்காது
(ix) இது (Child) இனக்குழுவின் மரபுரிமை பெற்ற Parent இனக்குழுவின் குறிப்பிட்ட வளங்களை செயல்படுத்துகிறது. மாறி அல்லது வழிமுறையின் அணுகலை திறம்பட கட்டுப்படுத்துவதற்கான எந்த விதமான வழிமுறையையும் பைத்தான் கொண்டிருக்கவில்லை
(x) பைத்தான் ஒரு மாறி அல்லது வழிமுறையின் பெயருக்கு முன்னே ஒற்றை மற்றும் இரட்டை அடிக்கோடிடும் வழக்கத்தைப் பரிந்துரைக்கிறது. இதனால் Private மற்றும் Protected அணுகியல்பு வரையறுப்பிகளின் சில பண்புகளைப் பின்பற்றுகின்றன
(xi) பைத்தானில் தானமைவாக இனக்குழுவின் அனைத்து உறுப்புகளும் Public உறுப்புகளாகவும், C++ மற்றும் Java வில் தானமைவாக Private உறுப்புகளாகவும் உள்ளன
(xii) பைத்தானில் அனைத்து உறுப்புகளையும் இனக்குழுவிற்கு வெளியில் இருந்து அணுகமுடியும். ஆனால், C++ மற்றும் Java - வில் இவ்வாறு அணுக முடியாது

range () என்பது பைத்தானில் தொடர் மதிப்புகளை உருவாக்கப் பயன்படும் செயற்கூறாகும். range () செயற்கூறை பயன்படுத்தி நீங்கள் தொடர் மதிப்புகளுடன் List-ஐ உருவாக்கலாம். range () செயற்கூறு மூன்று செயலுறுப்புகளைக் கொண்டுள்ளது.
           range () செயற்கூறின் தொடரியல் :
           range (start value, end value, step value)  
இங்கு,
(i) start value : தொடரின் தொடக்க மதிப்பு. சுழியம் தானமைவு தொடக்க மதிப்பாகும்.
(ii) end value : தொடரின் உச்ச வரம்பு. பைத்தான் இறுதி மதிப்பை உச்ச வரம்பு-1 என எடுத்துக் கொள்கிறது.
(iii) step value : இது ஒரு விருப்ப செயலுருபு (கொடுக்க வேண்டியது கட்டாயமில்லை) இது வெவ்வேறு இடைவெளிகளில் மதிப்புகளை உருவாக்கப் பயன்படுகிறது.
எடுத்துக்காட்டு : 10 வரை உள்ள முழு எண்களை உருவாக்குதல் :
for x in range (1,11):
       print (x)
வெளியீடு :
1
2
3
4
5
6
7
8
9
10
தொடர் மதிப்புகளுடன் List-ஐ உருவாக்குதல் :
(i) range() செயற்கூறை பயன்படுத்தி நீங்கள் தொடர் மதிப்புகளுடன் கூடிய List-ஐ உருவாக்கலாம். range( ) செயற்கூறின் விடையை List ஆக மாற்றுவதற்கு, List( ) செயற்கூறு பயன்படுகிறது. List( ) செயற்கூறு range( ) ன் விடையை List - ஆக உருவாக்குகிறது.
(ii) தொடரியல் :
List_Variable=List (range())
(iii) எடுத்துக்காட்டு:
>>> Even_List = List(range(2,11,2))
>>> print(Even_List)
[2, 4, 6, 8, 10]
(iv) மேலே உள்ள குறிமுறையில், List( ) செயற்கூறு range( ) ன் விடையை Even_List என்ற List உறுப்புகளாக எடுத்துக் கொள்கிறது. எனவே, Even_List என்ற List முதல் ஐந்து இரட்டைப்படை எண்களை உறுப்புகளாக பெற்றிருக்கும்.
(v) இதுபோன்று, எந்த தொடர் எண்களையும் range() பயன்படுத்தி உருவாக்கலாம். பின்வரும் எடுத்துக்காட்டு முதல் 10 இயல் எண்களின் 2ன் அடுக்கங்களுடன் கூடிய List-ஐ உருவாக்குதலை விளக்குகிறது.
(vi ) எடுத்துக்காட்டு :
squares = [ ]
for x in range(1,11):
          s = x ** 2
          squares.append(s)
print (squares)
(vii) மேலே உள்ள நிரலில், "squares" என்ற பெயருடைய ஒரு வெற்று List உருவாக்கப்பட்டுள்ளது. பின்னர், for மடக்கு 1 முதல் 10 இயல் எண்களை range() செயற்கூறை பயன்படுத்தி உருவாக்குகிறது. மடக்கின் உள்ளே, xன் தற்போதைய மதிப்பு, 2-ன் அடுக்கேற்றத்தால் அதிகப்படுத்தப்பட்ட பின்னர் s என்ற மாறியில் சேமிக்கப்படுகிறது. இறுதியாக, நிரல் பின்வரும் மதிப்புகளை விடையாகக் காண்பிக்கிறது.
வெளியீடு:
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

உள்ளீடு மற்றும் வெளியீடு செயற்கூறுகள் :
ஒரு நிரல் பயனர் விரும்பிய பணியை நிறைவேற்றுவதற்கு பயனருடன் தொடர்பு கொள்ள வேண்டும். இதற்கு உள்ளீட்டு - வெளியீட்டு செயற்கூறுகள் பயன்படுகிறது. input( ) செயற்கூறு, ஓர் நிரலை இயக்கம் பொழுது தரவுகளை இயக்கும் பொழுது தரவுகளை உள்ளீடு செய்யவும், print( ) என்ற வெளியீடு செயற்கூறு நிரலின் தீர்வுகளை திரையில் காண்பிக்க உதவுகிறது
Print( ) செயற்கூறு
பைத்தானில், print( ) செயற்கூறு நிரலை இயக்கும் பொழுது தரவுகளை வெளியிட பயன்படுகிறது
print( ) செயற்கூறின் தொடரியல் கீழே கொடுக்கப்பட்டுள்ளது.
print ("string to be displayed as output")
print (variable)
print ("String to be displayed as output", variable)
print ("String1", variable, "String 2", variable, "String 3" .....)
எடுத்துக்காட்டு:
> > > print ("Welcome to Python Programming")
Welcome to Python Programming
> > > x = 5
> > > y = 6
> > > z = x + y
> > > print (z)
                 11
> > > print ("The sum = ", z)
         The sum = 11
> > > print ("The sum of ", x, "and", y, "is", z)
         The sum of 5 and 6 is 11
வெளியீடு
Welcome to Python programming
11
The sum = 11
The sum of 5 and 6 is 11
print( ) செயற்கூறு தீர்வுகளை திரையில் காண்பிக்கும் முன் கோவையை மதிப்பீடு செய்யவும். print( ) செயற்கூறினுள் கொடுக்கப்படும் முழு கூற்றினையும் திரையில் காட்டும். காற்புள்ளி(,) கொண்டு print( ) செயற்கூறினுள் ஒன்றுக்கு மேற்பட்ட உருப்புகளை பிரிக்கலாம்.
input ( ) செயற்கூறு
பைத்தானில், input( ) செயற்கூறு நிரலை இயக்கம் பொழுது தரவுகளை உள்ளீடாக பெற்றுக் கொள்ளப் பயன்படுகிறது. input( ) செயற்கூறின் தொடரியல், 
Variable = input ("prompt string")
இந்த தொடரியலில் உள்ள "prompt string" பயனர் கொடுக்கப்பட வேண்டிய உள்ளீடு எதுவென்பதை உணர்த்தும் கூற்று அல்லது செய்தியை கொண்டிருக்கும்
 input( ) கட்டளை அமைப்பில் உள்ள "prompt string" திரையில் தோன்றும், பயனர் இதை படித்து உள்ளீடு சாதனத்திலிருந்து எதிர்பார்க்கப்படும் தரவுகளை கொடுக்கலாம். input( ) செயற்கூறு, விசைப்பலகையின் மூலம் தட்டச்சு செய்தவற்றை மாறியில் சேமித்து வைக்கும் "prompt string" கொடுக்கப்படவில்லையெனில் திரையில் எந்த தகவலும் தோன்றாது. இதனால் பயனர் எவற்றை உள்ளீடு செய்ய வேண்டும் என்பதை தெரிந்து கொள்ள முடியாது
எடுத்துக்காட்டு 1: "prompt string" கொண்டுள்ளன input ( ) செயற்கூறு
> > > city=input ("Enter Your City:")
                          Enter Your City: Madurai
> > > print ("I am from", city)
                          I am from Madurai
எடுத்துக்காட்டு 2: "prompt string" இடம்பெறாத input( )  செயற்கூறு
> > > city=input( )
                            Rajarajan
> > > print (I am from", city)
                            I am from Rajarajan
மேலே உள்ள எடுத்துக்காட்டு 2 ல், input( ) செயற்கூற்றில் "prompt string" இடம்பெறவில்லை. எனவே, எவற்றை உள்ளீடாக தர வேண்டும் என்பது பயனர் புரிந்து கொள்ள இயலாது. நிரலுக்கு தொடர்பில்லாத தரவுகளை உள்ளிட்டால், தவறான வெளியீட்டை வெளியிடும். எனவே பயனர் நிரலை உரிய முறையில் இயக்க, "prompt string" input() செயற்கூறில் பயன்படுத்த வேண்டும்.
input() செயற்கூறு அனைத்து தரவுகளையும் சரங்களாக ஏற்றுக் கொள்ளும். பயனர் எண்களை மதிப்புகளாக உள்ளீடு செய்யும் போது, அவை வெளிப்படையாக எண்வகை தரவுகளாக மாற்றப்பட வேண்டும். int() செயற்கூறு சரவகை தரவை எண்வகை தரவாக வெளிப்படையாக மாற்ற உதவுகிறது.

Pure செயற்கூறுகள் :
(i) ஒரே மாதிரியான செயலுருபுகளை அனுப்பும் போது, ஒரே மாதிரியான விடையைத் தரும் செயற்கூறு pure செயற்கூறுகள் ஆகும். எடுத்துக்காட்டாக, கணித செயற்கூறு sin(0)-ன் விடை எப்பொழுதுமே 0 ஆகும். இதன் அர்த்தம் என்னவென்றால், அதே அளபுருக்களைக் கொண்டு செயற்கூறினை ஒவ்வொரு முறையும் அழைக்கும் போது, அதே சரியான விடையை எப்பொழுதும் பெறலாம். மாறியின் பண்பை மாற்றக் கூடிய எந்த விதமான வெளிப்புற மாறியும் இல்லாமல் இருந்தால் அந்த செயற்கூறு pure செயற்கூறாகும்.
(எ.கா)
let square x: =
return: x * x
(ii) மேலேயுள்ள square செயற்கூறு pure செயற்கூறு ஆகும். ஏனென்றால் ஒரே மாதிரியான உள்ளீட்டிற்கு வெவ்வேறு விதமான வெளியீட்டைத் தராது.
(iii) கோட்பாடு சார்ந்த நன்மைகளை pure செயற்கூறுகள் கொண்டுள்ளன. ஒரு நன்மை என்னவென்றால், இதன் pure செயற்கூறாக இருக்கும் பொழுது, அதே அளபுருக்களுடன் செயற்கூறுவை பல தடவைகள் அழைக்கும்போது, உண்மையில் நிரல் பெயர்ப்பி செயற்கூறுவை மீண்டும் ஒரு தடவை அழைக்கும் தேவை மட்டுமே ஏற்படுகிறது.
let length s: = 
   i: = 0
   if i <strlen (s) then
   -- Do something which doesn't affect s ++ i
(iv) இது இயக்கப்படும் போது, ஒவ்வொரு முறையும் strlen (s) அழைக்கப்படுகிறது strlen-க்கு ஒட்டு மொத்தமாக 's' சுழற்சி செய்ய தேவைப்படுகிறது.
(v) strlen என்பது pure செயற்கூறாகும்.
Impure செயற்கூறுகள்:
(i) செயற்கூறுக்கு அளபுருக்களை அனுப்பாதபோதும், செயற்கூறின் உள்ளே உள்ள மாறியானது பக்க விளைவுகளை ஏற்படுத்தும், இந்த வகையான செயற்கூறை impure செயற்கூறு என்பர்.
(ii) ஒரு செயற்கூறு வரையறை தொகுதியின் வெளியே உள்ள மாறிகள் அல்லது செயற்கூறுகளைச் சார்ந்து இருந்து ஒவ்வொரு முறை அழைக்கும் பொழுதும் செயற்கூறு ஒரே மாதிரியாக இயக்கப்படும் என கூற இயலாது. எடுத்துக்காட்டாக. random() என்கிற கணித செயற்கூறு ஒரே மாதிரியான அழைப்புக்கூற்றுக்கு வெவ்வேறு விதமான வெளியீடுகளைக் கொடுக்கும்.
let a : random ( )
if a > 10 then
return:a
else
return:10
(iii) இங்கு Random என்பது impure செயற்கூறு ஆகும். ஏனெனில் இதனை அழைக்கும் பொழுது என்ன விடை கிடைக்கும் என நிச்சயமாக கூற இயலாது.

வரி வரைப்படம் அல்லது வரி விளக்கப்படம் என்பது தகவல்களை, "குறிப்பான்கள்" (Marker) என்று அழைக்கப்படும் தரவு புள்ளிகளின் தொடரை நேர் கோட்டின் இணைப்பதன் மூலம் காட்டுகிறது. வரி வரைபடம் தரவுகளின் மாற்றத்தை குறிப்பிட்ட காலத்தில் நிகழக்கூடியதை காட்டும். எனவே, கால வரிசைப்படி இக்கோடுகள் அமைக்கப்படும்.

(requires: b>0)
(returns:a to power of b)
let rec pow (a:int)(b:int):int:=
if b=0 then I 
else a*pow b(a-1)

(i) DISTINCT
(ii) WHERE
(iii) GROUP BY
(iv) ORDER BY
(v) HAVING

செயலுருப்புகள் செயற்கூறினை அழைக்க பயன்படுகிறது. செயலுருபுகள் (Required
arguments), சிறப்பு சொல் செயலுருபுகள் (Keyword arguments ), தானமைவு செயலுருபுகள், (Default arguments), மற்றும் நீள செயலுருபுகள் (variable length arguments).

for var in sequence:
# code inside for loop
if condition:

While test expression:
#code inside while loop
if condition:

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

வெற்று இடைவெளிகளானது CSV செயற்கூறினுள் உள்ள csv.register_dialect ( ) என்ற இனக்குழுவின் மூலம் நீக்கலாம். dialect ஆனது CSV கோப்பினை படிப்பதற்கான வழிமுறைகளை விவரிக்கிறது. dialect-ல் "skipinitialspace" என்ற அளபுருவானது பிரிப்பானிற்கு அடுத்து வரும் வெற்று இடைவெளிகளை நீக்க உதவுகிறது.

(i) ஸ்கேட்டர் வரைவிடம்:  ஸ்கேட்டர் வரைவு என்பது தரவுகளை புள்ளிகளின் தொகுப்பாக காட்டுகிறது. ஒரு புள்ளிகளின் நிலை அதன் இரு பரிமாண மதிப்பைப் பொறுத்தது, ஒவ்வொரு மதிப்பும் கிடைமட்ட அல்லது செங்குத்து பரிமாணத்தின் நிலையை குறிக்கும்.
(ii) பெட்டி வரைவிடம்: பெட்டி வரைவிடம் என்பது சிறிய முதல் கால்மானம், சராசரி, மூன்றாம் கால்மானம் மற்றும் பெரிய (minimum, first quartile, median, third quartile அண்ட் maximum) ஆகிய ஐந்து எண்கள் திரட்டைக் கொண்டு தரவுகளின் பகிர்வை காட்டுகிறது.

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

செயற்கூறுவிற்கு வெளியே மாறியை மாற்றம் செய்வது என்பது பக்கவிளைவுகளில் ஒன்றாகும்.
எடுத்துக்காட்டு:
let y:= 0
(int) inc (int)x
y:=y+ x;
return (y) 
மேலே கூறப்பட்ட எடுத்துக்காட்டில், y-ன் மதிப்பு செயற்கூறு வரையறையின் உள்ளே மாறுவதால் விடையானது ஒவ்வொரு முறையும் மாறும். int ( ) செயற்கூறுவின் பக்க விளைவு என்னவென்றால் வெளிப்புற மாறியான 'y' ன் மதிப்பை மாற்றுவதாகும். சில பக்க விளைவுகளை அடையாளம் காண்பது எளிதானதாகும் மற்றும் சில யோசிக்க தகுந்ததாக இருக்கும். நமது Impure செயற்கூறு எந்த அளவுருக்களையும் எடுத்துக்கொள்ளாது, எந்த மதிப்பையும் திருப்பி அனுப்பாது என்பது ஒரு நல்ல அறிகுறியாகும்.

WHERE துணை நிலை கூற்றில் குறிப்பிட்டுள்ள நிபந்தனையை நிறைவேற்றும், அட்டவணையில் உள்ள வரிசைகளில் எண்ணிக்கையை SQL COUNT ( ) சார்பு விடையாகக் கொடுக்கும்
எடுத்துக்காட்டு:
import sqlite3
connection = sqlite3.connect('Academy.db'')
cursor = connection.cursor( )
cursor.execute("SELECT COUNT(*) FROM student ")
result = cursor.fetchall ( )
print(result)
வெளியீடு:
[(7,)]

(i) வினவல் அமைப்பு மொழி (Structured Query Language) என்பது தரவுத்தளங்களை அணுகுதலுக்கும், கையாளுதலுக்கும் பயன்படுத்தப்படும் ஒரு வினவல் மொழியாகும்
(ii) SQL பயனருக்கு தரவுகளை உருவாக்குதல், திரும்ப எடுத்தல், மாற்றி அமைத்தல் மற்றும் தகவல்களை பரிமாற்றம் செய்தல் போன்ற செயல்பாடுகளை செயற்படுத்த அனுமதிக்கின்றது
(iii) உறவுநிலை தரவுத்தள மேலாண்மை அமைப்பில் (Relational Data Base Management System) உள்ள தரவுகளை நிர்வகிப்பதற்கும், அணுகுவதற்கும் வடிவமைக்கப்பட்ட ஒரு மொழியாகும்

நிரல்:
class Sample:
 def__init__ ( self, num );
  print ( "Constructor of class Sample..." )
  self. num = num
  print ( "The value is : ", num )
S = Sample ( 10 )
(i) மேலே உள்ள இனக்குழு " Sample ", " num " என்னும் ஒரே ஒரு அளபுருவுடன் கூடிய ஆக்கியைக் கொண்டுள்ளது. ஆக்கி இயக்கப்படும் போது முதல் " print " கூற்று, " Constructor of class Sample... " என்பதை அச்சிடும்.
(ii) பிறகு ஆக்கிக்கு அனுப்பப்படும் மதிப்பு self. num ல் இருத்தப்படுகிறது. இறுதியாக, கொடுக்கப்பட்ட சரத்துடன் அனுப்பப்பட்ட மதிப்பையும் அச்சிடுகிறது.
(iii) S என்ற பொருள் 10 என்ற மெய்யான அளபுருவுடன் உருவாக்கப்படும் போது மேலே உள்ள ஆக்கி தானாகவே இயக்கப்படும். பின்வரும் வெளியீடு கிடைக்கிறது.
Constructor of class Sample...
The value is: 10
(iv) ஆக்கியின் உள்ளே வரையறுக்கப்படும் இனக்குழு மாறியானது, இனக்குழுவில் உருவாக்கப்படும் பொருள்களின் எண்ணிக்கையைக் கொண்டிருக்கும்.

தேர்ந்தெடுப்பு வரிசையாக்கத்தின் போலி குறிமுறை:
(i) முதல் உறுப்பில் தொடங்கி அணியில் உள்ள மிகச் சிறிய உறுப்பைத் தேடி முதல் இடத்தில உள்ள உறுப்போடு இடமாற்றம் செய்ய வேண்டும். (அணியின் சுட்டு எண் 0 - ல்)
(ii) பிறகு இரண்டாவது இடத்திற்கு சென்று துணை அணியில் உலா மிகச் சிறிய உறுப்பை சுட்டெண் 1-லிருந்து இறுதி சுட்டெண் வரை தேட வேண்டும்
(iii) கொடுக்கப்பட்ட அணியில் இரண்டாவது இடத்தில படிநிலை 2 - ல் கண்டறிந்த உறுப்பை இடமாற்றம் செய்க இடமாற்றம் அல்லது இது துணை அணியின் முதல் இடத்தில இருக்கும்
(iv) அணி வரிசையாக்கம் செய்யப்படும் வரை, இதை மீண்டும் மீண்டும் செய்தல் வேண்டும்