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

Good Morning Bindu Madhavan

Code:
class Sample :
      def __init__(self, n1, n2):
            self._n1=n1
            self._n2=n2
def sum(self):
      print ("Class Variable 1:",self._n1)
      print ("Class Variable 2:", self._n2)
S=Sample (5,10)
S.sum()
வெளியீடு :
>>>
Class Variable 1 : 5
Class Variable 2 : 10
Sum : 15
>>>

பைத்தான் Dictionary, del  சிறப்புச் சொல் ஒரு குறிப்பிட்ட உறுப்பை நீக்குவதற்கு பயன்படுகிறது. clear ( ) செயற்கூறு Dictionary-ன் அனைத்து உறுப்புகளையும் நீக்குவதற்கு பயன்படுகிறது.
எடுத்துக்காட்டு :
Dict = ={'Roll No' : 12001, 'SName': 'Meena', 'Mark1': 98,'Mark2' : 86}
print("Dictionary elements before deletion: \n", Dict)
del Dict['Mark1'] # குறிப்பிட்ட உறுப்பை நீக்குதல் 
print("Dictionary elements after deletion of a element: \n", Dict)
Dict.clear() # அனைத்து உறுப்புகளையும் நீக்குதல்
print("Dictionary after deletion of all elements: \n", Dict)
del Dict
print (Dict) # முழு Dictionary ஐ நீக்குதல்

sort() - List-ல் உள்ள உறுப்புகளை வரிசையாக்கம் செய்கிறது. reverse, key இரண்டு செயலுருபுகளும் கட்டாயமில்லாதவை
(i) reverse ஐ True என பொருத்தினால் இறங்கு வரிசையில் லிஸ்ட் வரிசையாக்கமாகும்.
(ii) ஏறுவரிசை தானமைவு வரிசையாக்கமாகும்.
(iii) Key=myFunc; "myFunc" வரிசையாக்க வரண்முறையைக் குறிப்பிடும் பயனர் வரையறுத்த செயற்கூறின் பெயர்.
தொடரியல் :
List.sort(reverse=True|False, key=myFunc)
எடுத்துக்காட்டு :
MyList=["Thilothamma', 'Tharani', 'Anitha', 'SaiSree', 'Lavanya']
MyList.sort()
print(MyList)
MyList.sort(reverse=True)
print(MyList)
வெளியீடு:
['Anitha', 'Lavanya', 'SaiSree', "Tharani', "Thilothamma']
['Thilothamma', 'Tharani', 'SaiSree', 'Lavanya', 'Anitha']

தொடரியல்	விளக்கம்	எடுத்துக்காட்டு
count( str,beg, end)	ஒரு சரத்தில் கொடுக்கப்பட்ட பரப்பிற்குள் உள்ள துணைச் சரங்களின் (substring) எண்ணிக்கையை திருப்பும். ஒரு துணைச் சரம் என்பது ஒற்றை குறியுருவாக கூட இருக்கலாம். பரப்பு செயலுருபுகளை கொடுக்க வேண்டியது கட்டாயமில்லை கொடுக்காவிட்டால் பைத்தான் முழு சரத்தையும் தேடும். தேடல் எழுத்துணர்வு மிக்கது (case sensitive) என்பதை நினைவில் கொள்க.	> > > str1="Raja Raja Chozhan" > > > print(str1. count('Raja') 2 > > > print(str1. count('r')) 0 > > > print(str1. count('R')) 2 > > > print(str1. count ('a')) 5 > > > print(str1. count('a',0,5)) 2 > > > print(str1. count('a',11)) 1

weool

1) தற்சுழற்சி செயற்கூறு வெளிப்புற குறிமுறையிலிருந்து அழைக்கப்படும்.
2) அடிப்படை நிபந்தனை நிறைவேற்றப்பட்டால் நிரலானது ஏற்ற வெளியீடு கொடுத்து வெளியேறும்.
3) இல்லையெனில், செயற்கூறு தேவையான செயற்பாட்டை இயக்கும் மேலும் தற்சுழற்சி முறையில் தன்னைத் தானே அழைத்துக் கொள்ளும்.

y= int (input ("Enter year"))
      if y % 4 == 0:
                print ("The given year is a leap year")
      else :
                 print ("The given year is not a leap year")
வெளியீடு:
       Enter the year 2012
       Leap year

செயற்கூறினுள் முழுதளாவி மாறியை மாற்றம் செய்தால் UnboundLocalError என்ற பிழையை காண்பிக்கும்.

உள்ளமை மாறியின் விதிமுறைகள் :
(i) உள்ளமை மாறியின் வரையெல்லை அது வரையறுக்கப்பட்டுள்ள தொகுதிக்குள் மட்டுமே பயன்படுத்த முடியும்.
(ii) செயற்கூறினுள் மாறி உருவாக்கப்படும் போது அது உள்ளமைவாக அமையும்.
(iii) செயற்கூறு இயக்கப்படும் போது மட்டுமே உள்ளமை மாறிகள் உயிர்பெறும்.
(iv) முறையான அளபுருக்கள் அதன் செயற்கூறுக்கு உள்ளமையானது ஆகும்.

தொடரியல் :
while < condition >:
      statements block 1
[else:
      statements block2]

if ...else கூற்றானது சரி தொகுதி மற்றும் தவறு தொகுதி இரண்டையுமே சரிபார்ப்பதற்கான கட்டுப்பாட்டை வழங்குகிறது. 'if..else' கூற்றின் தொடரியல்.
தொடரியல்:
if <condition>:
           statements-block 1
           else:
           statements-block 2

பைத்தானில், சர நிலையுருக்கள், என்பது மேற்கோள் குறிக்குள் அடைக்கப்பட்ட குறியுருக்களின் தொடராகும். பைத்தானில், சரங்களை ஒற்றை, இரட்டை மற்றும் மூன்று மேற்கோள் குறிகளில் அடைக்கலாம். குறியுரு மதிப்பிருக்கள் ஒற்றை அல்லது இரட்டை மேற்கோள்குறியை கொண்டிருக்கும். பல வரி சர நிலையுருவை மூன்று மேற்கோள் "' '" குறிக்குள் கொடுக்கப்பட வேண்டும். பைத்தானில் ஒரு குறியுருவானது சர நிலையுருவாகவும் கருதப்படும்.
சர நிலையுரு செயல் விளக்கம் :
# Demo Program to test String Literals
                   strings = "This is Python"
                   char = "C"
                   multiline_str = ""This is a multiline
                   string with more than one line code."'
                   print (strings)
                   print (char)
                   print (multiline_str)
# End of the Program
வெளியீடு :
This is Python
C
This is a multiline string with more than one line code.

மும்ம செயற்குறி நிபந்தனை செயற்குறி என்றும் அழைக்கப்படுகிறது. இது சமன்பாடுகளின் நிபந்தனையை சரி அல்லது தவறா என்று சோதித்து செயல்படுத்தும், மும்ம செயற்குறி பல வரி if-else கூற்று போல் அல்லாது நிபந்தனைகளை ஒற்றை வரியில் சோதிக்க அனுமதிக்கிறது.
நிபந்தனைச் செயற்குறியின் தொடரியல்,
Variable Name = [on_true] if [Test expression] else [on_false]
எடுத்துக்காட்டு:
min = 49 if 49 < 50 else 50 # min = 49
min = 50 if 49 > 50 else 49 # min = 49

கணித செயற்குறிகள், இரு செயலேற்பிகள் ஏற்றுக் கொண்டு அதன் மீது கணித செயல்பாடுகளை செய்யும். அவை எளிய முறை கணித செயல்பாடுகளாக பயன்படுகிறது. பெரும்பான்மையாக கணிப்பொறி மொழிகள் இதுபோன்ற செயற்குறிகளை கொண்டிருக்கும். அவை சமன்பாடுகளை பயன்படுத்தி தொடர் கணிப்பீடுகளை செய்யப் பயன்படுகிறது.
பைத்தான் பின்வரும் கணித செயற்குறிகளை கொண்டுள்ளது.

செயற்குறி - செயல்பாடு	எடுத்துக்காட்டு	தீர்வு
a = 100, b = 10 என மதிப்பாக கொண்டு பின்வரும் கோவையை மதிப்பீடுக
+ (கூட்டல்)	> > > a + b	110
- (கழித்தல்)	> > > a - b	90
* (பெருக்கல்)	> > > a * b	1000
/ (வகுத்தல்)	> > > a / b	10.0
% (வகுமீது)	> > > a % 30	10
** (அடுக்கு)	> > > a ** 2	10000
// (முழு எண் வகுத்தி)	> > > a / / 30	3

Asymptotic குறியீடுகள் நேரம் மற்றும் இடச்சிக்கல்களைப் பற்றிய அர்த்தமுள்ள கூற்றுகளைப் பயன்படுத்தும் ஒரு மொழியாகும். பின்வரும் மூன்று Asymptotic குறியீடுகள் நெறிமுறையில் நேரச் சிக்கலைக் குறிக்க மிகவும் பயன்படுகிறது.
(i) Big O : நெறிமுறையின் மிக மோசமான நிலையை விவரிக்க Big O பெரும்பாலும் பயன்படுத்தப்படுகிறது.
(ii) Big \(\Omega\): Big Omega, Big O-வின் தலைகீழ் ஆகும். Big O-asymptotic (மோசமான நிலையில்) செயற்கூறின் உச்ச வரம்பையும், Big Omega அதன் கீழ்வரையை குறிக்கும் (சிறந்த நிலையில்).
(iii) Big : \(Θ\) = நெறிமுறையானது கீழ் எல்லை = மேல் எல்லை என்னும் சிக்கலைக் கொண்டிருந்தால், உதாரணத்திற்கு O (n log n) மற்றும் \(\Omega\)(n log n), ஆகிய சிக்கல்களைக் கொண்டுள்ளது என வைத்துக் கொள்வோம். உண்மையில் அதனுடைய சிக்கல் \(Θ\) (n log n), என்பது ஆகும். இதனுடைய அர்த்தம் என்னவென்றால் நெறிமுறையின் இயங்கு நேரம் மிகச் சிறந்த நிலை மற்றும் மிக மோசமான நிலை ஆகிய இரண்டு நிலையிலுமே எப்பொழுதும் n log n ஆக இருக்கும்.

நெறிமுறை f(n)-ன் சிக்கலானது, அது n அளவிலான உள்ளீட்டு தரவை எடுத்துக்கொண்டு இயங்கும் நேரம் மற்றும் நினைவகத்தில் அதற்கு தேவைப்படும் இட ஒதுக்கீடு பொறுத்தது
(i) நேரசிக்கல் (Time complexity): ஒரு நெறிமுறை செயலை செய்து முடிக்க எண்ணிக்கையே நெறிமுறையின் நேரசிக்கல் எனப்படும்
(ii) இடச்சிக்கல் (space): ஒரு நெறிமுறையின் செயல்பாடு முடியும்வரை அதற்கு தேவைப்படும் நினைவக இடமே இடச்சிக்கல் எனப்படும். நெறிமுறைக்கு தேவைப்படும் இடம் பின்வரும் இரு கூறுகளின் கூட்டுத் தொகையாகும்
நிலையான பகுதி: இது நெறிமுறைக்கு தேவையான தரவு மற்றும் மாறிகளை சேமிக்க பயன்படும் கூட்டு இடத்தை வரையறுக்கும். எடுத்துக்காட்டு நிரல் நெறிமுறையில் பயன்படுத்தப்படும் மாறிகள் மற்றும் மாறிலிகள்.
மாறும் பகுதி: சிக்கலின் அளவு மற்றும் சுழற்சிக்கு தேவைப்படும் அனைத்து மாறிகளின் கூட்ட இடத்தின் அளவை பொறுத்து 'n' வரையறுக்கப்படும். எடுத்துக்காட்டாக: என்ற மதிப்பின் தொடர் பொருட்களை தற்சுழற்சி மூலம் கண்டறிதல்.

Color:= Red - முழுதளாவிய வரையெல்லை
b:= Blue - இணைக்கப்பட்ட வரையெல்லை
g:= Green - உள்ளமை வரையெல்லை
வெளியீடு:
Red Blue Green
Red Blue
Red

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

மேலே குறிப்பிட்ட எடுத்துக்காட்டில் Disp1 () என்ற செயற்கூறு Disp () என்ற செயற்கூறினுள் வரையறுக்கப்பட்டுள்ளது. 'a' என்ற மாறி Disp () என்ற செயற்கூறினுள் வரையறுக்கப்பட்டிருந்தாலும் Disp 1 () என்ற செயற்கூறும் அதைப் பயன்படுத்த முடியும். ஏனெனில் இந்த செயற்கூறு Disp () என்பதன் உறுப்பாகும்.

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

மேலே உள்ள குறிமுறையை இயக்கும்போது, மாறி a என்பது 7 என்ற மதிப்பை வெளியிடுகிறது. ஏனெனில், இது உள்ளமை வரையெல்லையில் வரையறுக்கப்பட்டு, அங்கேயே அச்சிடப்படுகிறது.

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

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

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

(i) செயற்கூறுக்கு அளபுருக்களை அனுப்பாத போதும், செயற்கூறின் உள்ளே உள்ள மாறியானது பக்க விளைவுகளை ஏற்படுத்தும். இந்த வகையான செயற்கூறை impure செயற்கூறு என்பர்.
(ii) ஒரு செயற்கூறு வரையறை தொகுதியின் வெளியே உள்ள மாறிகள் அல்லது செயற்கூறுகளைச் சார்ந்து இருந்து ஒவ்வொரு முறை அழைக்கும் பொழுதும் செயற்கூறு ஒரே மாதிரியாக இயக்கப்படும் என கூற இயலாது.
(iii) எடுத்துக்காட்டாக : random ( ) என்கிற கணித செயற்கூறு ஒரே மாதிரியான அழைப்புக்கூற்றுக்கு வெவ்வேறு விதமான வெளியீடுகளைக் கொடுக்கும்.
let a : random ()
    if a > 10 then
return: a
else
   return:10
(iv) இங்கு, Random என்பது impure செயற்கூறு ஆகும். ஏனெனில் இதனை அழைக்கும் பொழுது என்ன விடை கிடைக்கும் என நிச்சயமாக கூற இயலாது.