pop( ) செயற்கூறு குறிப்பிட்ட உறுப்பை அதன் சுட்டெண்ணைப் பயன்படுத்தி நீக்குவதற்கு பயன்படுகிறது. உறுப்பு நீக்கப்பட்டவுடன் pop( ) செயற்கூறு நீக்கப்பட்ட உறுப்பை காண்பிக்கிறது. pop( ) செயற்கூறு List-ல் இருந்து ஒரு உறுப்பை மட்டும் நீக்கப் பயன்படுகிறது. Del கூற்று பல உறுப்புகளை நீக்குகிறது என்பதை நினைவில் கொள்க.

வெளியீடு :['A','L','S','T','T']

S = [i**2 for i in range (2,11,2)]
print (S)

(i) 12,89,79,80
(ii) 12,79,80
(iii) [ ]

பொருள்களை அழிப்பதற்கான சிறப்பு செயற்கூறு அழிப்பி (destructor) ஆகும். இது ஆக்கியின் செயல்பாட்டிற்கு எதிரானது ஆகும். பைத்தானில், _del   _(  ) செயற்கூறு அழிப்பியாகப் பயன்படுத்தப்படுகிறது.

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

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

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

Tuples-ஐ ஒற்றை உறுப்புடன் உருவாக்கும் போது, உறுப்பின் இறுதியில் காற்புள்ளியை சேர்க்க வேண்டும். காற்புள்ளி இல்லையெனில், பைத்தான் அந்த உறுப்பை ஒரு சாதாரண தரவினம் போல எடுத்துக் கொள்ளும், Tuples ஆக கருதாது. ஒரு உறுப்புடன் Tuples-ஐ உருவாக்குவது "சிங்கிள்டன்" (singleton) Tuples என அழைக்கப்படுகிறது.
எடுத்துக்காட்டு :
> > > MyTup4 = (10)
> > > type(MyTup4)
 <class 'int'>
> > > MyTup5 = (10,)
> > > type(MyTup5)
 <class 'Tuples'> 

MyList elements before update...
 2
 4
 5
 8
 10
MyList elements after updation...
 2
 4
 6
 8
10

(i) sample என்பது இனக்குழுவை குறிக்கிறது.
(ii) x மற்றும் y என்பது இனக்குழுவின் மாறிகளைக் குறிக்கிறது.
(iii) s என்பது பொருளைக் குறிக்கிறது இனக்குழுவில் உள்ள உறுப்புகளை அணுகுவதற்கு.

ஆக்கி :
ஓர் இனக்குழுவின் சான்றுரு பயன்பாட்டிற்கு வரும் பொழுது ஆக்கி என்னும் சிறப்புச் செயற்கூறு தானாகவே இயக்கப்படுகிறது. பைத்தானில், “init” என்னும் சிறப்பு செயற்கூறு ஆக்கியாக செயல்படுகிறது. இது இரட்டை அடிக்கீறில் (UnderScore)தொடங்கி இரட்டை அடிக்கீறலுடன் முடிய வேண்டும்.
                                        __init__வழிமுறையின் (ஆக்கி) பொதுவடிவம்
                              def __init__(self, [args .......]):
                                        <statements>
அழிப்பி :
பொருள்களை அழிப்பதற்கான சிறப்பு செயற்கூறு அழிப்பி (destructor) ஆகும். இது ஆக்கியின் செயல்பாட்டிற்கு எதிரானது ஆகும். பைத்தானில், _ del _(  ) செயற்கூறு அழிப்பியாகப் பயன்படுத்தப்படுகிறது.

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 ஐ நீக்குதல்

வெளிப்பாடு : [1,2,4,8,16]

(i) List-ன் உறுப்புகளை மாற்றலாம் ஆனால் Tuples-ன் உறுப்புகளை மாற்ற முடியாது. இதுவே List  மற்றும் Tuples -க்கு இடையே உள்ள முக்கியமான வேறுபாடு ஆகும்.
(ii) List-ன் உறுப்புகள் சதுர அடைப்புக் குறிக்குள் அடைக்கப்பட்டிருக்கும். ஆனால், Tuples-ன் உறுப்புகள் வளைவு குறிக்குள் அடைக்கப்பட்டிருக்கும்.
(iii) Tuple-ன் மடக்குச் செயல் List-ஐ காட்டிலும் விரைவானது.

பைத்தானில் ஆக்கிகள் மற்றும் அழிப்பிகள் :
ஆக்கி :
(i) ஓர் இனக்குழுவின் சான்றுரு பயன்பாட்டிற்கு வரும் பொழுது ஆக்கி என்னும் சிறப்புச் செயற்கூறு தானாகவே இயக்கப்படுகிறது. பைத்தானில், “init” என்னும் சிறப்பு செயற்கூறு ஆக்கியாக செயல்படுகிறது. இது இரட்டை அடிக்கீறில் (UnderScore) தொடங்கி இரட்டை அடிக்கீறலுடன் முடிய வேண்டும்.
(ii) இந்த செயற்கூறு சாதாரண செயற்கூறுவைப் போல செயல்படும், ஆனால் பொருள் உருவாக்கப்பட்டவுடன். தானாகவே இயக்கப்படும். இந்த ஆக்கி செயற்கூறை அளபுருக்களுடனோ அல்லது இல்லாமலோ வரையறுக்கலாம்.
                    _init_வழிமுறையின் (ஆக்கி) பொதுவடிவம் def __init__(self, [args .......]):
                   <statement >
(எ.கா) ஆக்கியை விளக்கும் நிரல்
class Sample: \(\rightarrow\) இனக்குழு பெயர்
                             அளபுரு
                                     \(\uparrow\)
def __init__(self, num):
print("Constructor of class Sample...")
self.num=num \(\rightarrow\) சான்றுரு மாறி
print("The value is:", num)
S=Sample(10)
(iii) மேலே உள்ள இனக்குழு "sample", இது "num"என்னும் ஒரே ஒரு அளபுருவுடன் கூடிய ஆக்கியைக் கொண்டுள்ளது. ஆக்கி இயக்கப்படும் போது முதல் "Print"கூற்று, "Constructor of class sample..." என்பதை அச்சிடும். பிறகு ஆக்கிக்கு அனுப்பப்படும் மதிப்பு. self,num=num என்ற சான்றுரு மாறியில் இருத்தப்படுகிறது.
(iv) இறுதியாக, கொடுக்கப்பட்ட சரத்துடன் அனுப்பப்பட்ட மதிப்பையும் அச்சிடுகிறது. S என்ற பொருள் 10 என்ற மெய்யான அளபுருவுடன் உருவாக்கப்படும் போது மேலே உள்ள ஆக்கி தானாகவே இயக்கப்படும். பின்வரும் வெளியீடு கிடைக்கிறது.
Constructor of class sample...
The value is : 10
ஆக்கியின் உள்ளே வரையறுக்கப்படும் இனக்குழு மாறியானது, இனக்குழுவில் உருவாக்கப்படும் பொருள்களின் எண்ணிக்கையைக் கொண்டிருக்கும்.
அழிப்பி :
பொருள்களை அழிப்பதற்கான சிறப்பு செயற்கூறு அழிப்பி (destructor) ஆகும். இது ஆக்கியின்
செயல்பாட்டிற்கு எதிரானது ஆகும். பைத்தானில், _del_() செயற்கூறு அழிப்பியாகப் பயன்படுத்தப்படுகிறது.
(எ.கா) _del_ () வழிமுறையை விளக்கும் நிரல்
class Sample:
          num=0
          def _init__(self, var):
               Sample.num+=1
               self.var=var
               print("The object value is = ",self.var)
               print("The value of class variable is=", Sample.num)
           def _del_(self):
                Sample.num-=1
                print("Object with value %d is exit from the scope"%self.var)
S1=Sample(15)
S2=Sample(35)
S3-Sample(45)
del S1, S2,S3
குறிப்பு:
del என்பதை பயன்படுத்தி ஒரு பொருளை அழிக்கும் போது __del__ () செயற்கூறு தானாகவே அழைக்கப்படும்.

கணிதத்தில் கற்ற Set செயற்பாடுகள் ஆகிய ஒட்டு (Union), வெட்டு (intersection) வேறுபாடு (difference) சமச்சீரான வேறுபாடு (Symmetric difference) , போன்றவற்றை பைத்தானிலும் பயன்படுத்தலாம்.
ஒட்டு (Union) : இது இரண்டு அல்லது அதற்கு மேற்பட்ட Set -களின் அனைத்து உறுப்புகளையும் உள்ளடக்கும்.

(i) பைத்தானின் என்ற செயற்குறி இரண்டு Set களின் இணைப்பை உருவாக்கப்பயன்படுகிறது. Union செயற்கூறும் பைத்தானின் இரண்டு Set களை இணைக்கப் பயன்படுகிறது.
(ii) எடுத்துக்காட்டு: ஒட்டு (Union) செயற்குறியைப் பயன்படுத்தி இரண்டு Set களை இணைப்பதற்கான நிரல் 
set_A ={2,4,6,8}
set_B ={'A','B','C','D'}
U_Set=Set_A | set_B
print(U_set)
வெளியீடு:
      {2,4,6,8,'A', 'D', 'C', 'B'}
வெட்டு (intersection) : இது இரண்டு Setகளின் பொதுவான உறுப்புகளை உள்ளடக்கியது.

(i) பைத்தானில் & செயற்குறி இரண்டு Set களை வெட்டுவதற்கு பயன்படுகிறது. வெட்டு (intersection()) செயற்கூறும் பைத்தானில் இரண்டு Set களை வெட்டுவதற்கு பயன்படுகிறது.
(ii) எடுத்துக்காட்டு : intersection()செயற்குறியைப் பயன்படுத்தி இரண்டு Setகளை வெட்டுவதற்கான நிரல்
set_A={'A', 2, 4, 'D'}
set_B={'A', 'B', 'C', 'D'}
print(set_A.intersection (set_B))
வெளியீடு : {'A', 'D'}
வேறுபாடு (Difference): இது முதல்Set(A)ல் உள்ள அனைத்து உறுப்புகளையும் உள்ளடக்கியது. இது இரண்டாவது Set-ஐ தவிர்க்கிறது.

(i) பைத்தானில் -(minus) செயற்குறி Set செயற்பாட்டின் வேறுபாட்டைக் கண்டறிய பயன்படுகிறது. difference() செயற்கூறும் வேறுபாட்டு செயற்பாட்டிற்காக பயன்படுகிறது.
(ii) எடுத்துக்காட்டு : (-) Minus பயன்படுத்தி இரண்டு setகளின் வேறுபாட்டுக்கான நிரல்
set_A={'A', 2, 4, 'D'}
set_B={'A', 'B', 'C', 'D'}
print(set_A - set_B)
வெளியீடு : {2, 4}
சமச்சீரான வேறுபாடு (Symmetric difference): இது இரண்டு Set-ல் உள்ள பொதுவான உறுப்புகளை மட்டும் தவிர்த்து மற்ற அனைத்து உறுப்புகளையும் உள்ளடக்கியது.

(i) Caret(^) செயற்குறி பைத்தானில் சமச்சீரான வேறுபாட்டை கண்டறிய பயன்படுகிறது. Symmetric difference() செயற்கூறும் அதே செயலை செய்ய பயன்படுகிறது.
(ii) எடுத்துக்காட்டு : Caret (^) செயற்குறியைப் பயன்படுத்தி சமச்சீரான வேறுபாட்டை கண்டறியும் நிரல்.
set_A={'A', 2, 4, 'D'}
set_B={'A', 'B', 'C', 'D'}
print(set_A ^ set_B)
வெளியீடு :: {2, 4, 'B', 'C'}