பைத்தான் ஆப்ஜெக்ட் ஒரியண்டட் கருத்துக்களை சப்போர்ட் செய்கின்றது.இது
என்கேப்சுலேசன்,இன்ஹெரிட்டன்ஸ், பாலிமார்பிசம் போன்றவற்றை பயன்படுத்துகின்றது.ஆப்ஜெக்ட்
ஒரியண்டட் நிரலாக்கத்தின் முக்கிய கோட்பாடு டேட்டாவையும் மெத்தடையும் ஒரே யுனிட் ஆக
உருவாக்கி அதற்கு வெளியே நேரடியாக டேட்டாவை அனுக முடியாது செய்தலே ஆகும்.
ஆப்ஜெக்ட் ஒரியண்டட் நிரலாக்கத்தின் முக்கிய கருத்துக்கள்.
1. Class
2. Objects
3. Polymorphism
4. Encapsulation
5. Inheritance
கிளாஸ்.
கிளாஸ் என்பது ஆப்ஜெக்டுகளின் தொகுப்பாகும்.ஒரு கிளாஸ் உருவாக்கப்படும்
நோக்கத்தை பின் வருமாறு புரிந்து கொள்ளலாம்.
சான்றாக நாய்களின் இனம்,வயது போன்றவற்றை ஒரு லிஸ்ட் ஆக எழுதினால் முதல்
எலிமெண்ட் இனத்தையும், இரண்டாவது எலிமெண்ட் வயதையும் குறிப்பிடலாம். இதே 100 எண்ணிக்கையில்
வெவ்வேறு இன நாய்கள் என்றால் என்ன செய்ய முடியும்?இதில் மேலும் ஆட்ரிபியூட்களை சேர்க்க
வேண்டுமானால் என்ன செய்யலாம்.இங்கு தான் ஒரு கிளாஸ் உருவாக்கப்படுவதின் தேவை எழுகின்றது.
ஊப்ஸ் பைத்தான் பற்றிய சில முக்கிய குறிப்புகள்.
1. கிளாஸ்கள் class என்ற கீவேர்டு மூலம்
உருவாக்கப்படுகின்றது.
2. ஆட்ரிபியூட்கள் வேரியபிளாக எழுதப்படுகின்றது.
3. பிஹேவியர்கள் மெத்தட்களாக எழுதப்படுகின்றது.
4. ஆட்ரிபியூட்கள் எப்பொழுதுமே பப்ளிக்
ஆகும் இது டாட் ஆபரேட்டர் கொண்டு ஆக்சஸ் செய்யப்படுகின்றது.
சான்று MyClass.MyAttribute.
கிளாசை உருவாக்குவதின் சிண்டாக்ஸ்.
class ClassName:
# Statement-1
.
.
.
# Statement-N
பைத்தானில் ஒரு எம்ப்டி கிளாஸ் சான்று நிரல்.
# Python3
program to
#
demonstrate defining
# a class
class
Dog:
pass
மேலே உள்ள சான்று நிரலில் class என்ற கீவேர்டு மூலம் Dog என்றொரு கிளாஸ்
உருவாக்கப்பட்டு உள்ளது.
ஆப்ஜெக்ட்ஸ்.
ஆப்ஜெக்ட் என்பது ஸ்டேட் மற்றும் பிஹேவியர் கொண்ட ஒரு என்டைட்டி ஆகும்.இது
எந்த ஒரு ரியல் வேர்ல்டு ஆப்ஜெட்ட்டாகவும் இருக்கலாம்.
சான்று மேஜை, பேனா, கத்தி, வாகனம், பறவை, இன்டிஜெர்,ஃப்ளோட்டிங்க்
பாயின்ட் எண்கள் அர்ரே, லிஸ்ட் போன்ற எல்லாமே ஆப்ஜெக்டுகள் தான்.எண் 20 ஒரு ஆப்ஜெக்ட்
ஒரு ஸ்ட்ரிங்க் “hello” என்பது ஒரு ஆப்ஜெக்ட்.
ஆப்ஜெக்ட்களின் உள்ளடக்கம்.
ஸ்டேட்: இது எப்பொழுதுமே ஒரு ஆப்ஜெக்டின் ஆட்ரிபியூட்டைகொண்டிருக்கின்றது.
ஆப்ஜெக்டின் பிராப்பர்ட்டி என்றும் சொள்ளலாம்.
பிஹேவியர்: இது மெத்தட்களாக குறிப்பிடப்படுகின்றது. இது ஒரு ஆப்ஜெக்ட்
மற்றொரு ஆப்ஜெக்டிற்க்கு ரெஸ்பான்ஸ் செய்வதை பிரதிபலிக்கின்றது.
ஐடெண்ட்டி:இது ஒரு ஆப்ஜெக்டிற்க்கு கொடுக்கப்படும் தனிப்ப்ட்ட பெயர்
ஆகும் .இது ஒரு ஆப்ஜெக்ட் மற்றொரு ஆப்ஜெக்டுடன் இன்டெராக்ட் செய்ய உதவுகின்றது.
இவற்றை புரிந்து கொள்ள dog என்றொரு மாதிரி கிளாசை உருவாக்குவோம்.
இதில் ஐடெண்டி ஆனது dog –ன் பெயர் ஆகும்.
ஸ்டேட் ஆனது இனம் ,நிறம்,வயது.
பிஹேவியர் ஆனது சாப்பிடுதல் ,தூங்குதல்,குரைத்தல்.
சான்று ஒரு ஆப்ஜெட் உருவாக்குதல்.
obj =
Dog()
இதில் obj என்பது Dog கிளாசின் ஆப்ஜெக்ட் ஆக அறிவிக்கப் படுகின்றது.
இப்பொழுது கிளாஸ் மற்றும்
ஆப்ஜெக்டுகளை குறிப்பிடும் சில கீவேர்டுகள் பற்றி காண்போம்.
Self.
ஒரு மெத்தட் ஆனது அதன் முதல் பாராமீட்டர் ஆக ஒரு self என்றொரு பாராமீட்டரைக்
கொண்டிருத்தல் வேண்டும்.இதற்கு எந்த ஒரு டேட்டாவை நாம் கொடுப்பதில்லை. பைத்தானே குறிப்பிடுகின்றது.
மெத்தட்களுக்கு எந்த ஒரு பாராமீட்டர் இல்லாவிட்டாலும் இது இருக்க வேண்டும்.
இது cpp-ன் this பாயிண்டரையும் ஜாவாவின் this ரெஃபெரென்சையும் ஒத்திருக்கின்றது.
ஒரு ஆப்ஜெக்ட் மூலமாக MyObject.MyMethod(arg1, arg2) என அழைக்கும்
பொழுது பைத்தான் தானியங்கி முறையில் MyObject.MyMethod( self, arg1, arg2)என மாற்றியமைக்கின்றது.
__init__ மெத்தட்.
இது C++, java, c# ஆகியவற்றின் கன்ஸ்ட்ரக்டர்களைப் போன்றது ஆகும்.இது
ஒரு கிளாஸிற்க்க்கு ஆப்ஜெக்ட் உருவாக்கும் பொழுது தானியங்கி முறையில் அழைக்கப்படுகின்றது.இது
வேரியபிள்களை தொடக்க மதிப்பிருத்த பயன்படுகின்றது.
சான்று நிரல்-1
|
class
Dog:
#
class attribute
attr1
= "mammal"
#
Instance attribute
def
__init__(self, name):
self.name
= name
# Driver
code
# Object
instantiation
Rodger =
Dog("Rodger")
Tommy =
Dog("Tommy")
#
Accessing class attributes
print("Rodger
is a {}".format(Rodger.__class__.attr1))
print("Tommy
is also a {}".format(Tommy.__class__.attr1))
#
Accessing instance attributes
print("My
name is {}".format(Rodger.name))
print("My
name is {}".format(Tommy.name))
|
Output
Rodger is
a mammal
Tommy is
also a mammal
My name is
Rodger
My name is
Tommy
சான்று நிரல்-2
|
class
Dog:
#
class attribute
attr1
= "mammal"
#
Instance attribute
def
__init__(self, name):
self.name
= name
def
speak(self):
print("My
name is {}".format(self.name))
# Driver
code
# Object
instantiation
Rodger =
Dog("Rodger")
Tommy =
Dog("Tommy")
#
Accessing class methods
Rodger.speak()
Tommy.speak()
|
Output
My name is
Rodger
My name is
Tommy
இன்ஹெரிடன்ஸ்:
இது ஒரு கிளாசில் உள்ள பிராப்பர்ட்டிகளை மற்றொரு கிளாஸ் இன்ஹெரிட்
செய்தல் ஆகும்.டெரிவ் செய்யப்படும் கிளாஸ் பேஸ்கிளாஸ் அல்லது பேரண்ட் கிளாஸ் என அழைக்கப்படுகின்ற்து.
டெரிவ்டு ஆன கிளாஸ் டெரிவ்டு கிளாஸ் அல்லது சைல்ட் கிளாஸ் என அழைக்கப்படுகின்றது.
இன்ஹெரிடன்சின் பயன்கள.
இது ரியல் வேர்ல்டு ரிலேசன்சிப்பை குறிப்பிட் உதவுகின்றது.
இது நிரல் மறு பயன்பாட்டிற்கு உதவுகின்றது.திரும்பவும் ஒரே நிரல் வரிகளை
எழுத தேவையில்லை .ஒரு கிளாசிற்கு பிராப்பர்ட்டி உருவாக்கும் பொழுது கூடுதலாக என்ன தேவைப்படுகின்ற்தோ
அதை மற்றும் சேர்த்துக் கொண்டால் போதும்.
சான்று நிரல்.
|
# Python
code to demonstrate how parent constructors
# are
called.
# parent
class
class
Person(object):
#
__init__ is known as the constructor
def
__init__(self, name, idnumber):
self.name
= name
self.idnumber
= idnumber
def
display(self):
print(self.name)
print(self.idnumber)
def
details(self):
print("My
name is {}".format(self.name))
print("IdNumber:
{}".format(self.idnumber))
# child
class
class
Employee(Person):
def
__init__(self, name, idnumber, salary, post):
self.salary
= salary
self.post
= post
#
invoking the __init__ of the parent class
Person.__init__(self,
name, idnumber)
def
details(self):
print("My
name is {}".format(self.name))
print("IdNumber:
{}".format(self.idnumber))
print("Post:
{}".format(self.post))
#
creation of an object variable or an instance
a =
Employee('Rahul', 886012, 200000, "Intern")
#
calling a function of the class Person using
# its
instance
a.display()
a.details()
|
Output
Rahul
886012
My name is
Rahul
IdNumber:
886012
Post:
Intern
மேலே உள்ள நிரலில் person என்பது பேரன்ட் கிளாசாகவும் Employee ஆனது
சைல்ட் கிளாசாகவும் எழுதப்படுகின்றது.எம்ப்ளாயி கிளாஸ் பெர்சன் கிளாஸை இன்ஹெரிட் செய்கின்றது.பேரண்ட்
கிளாசில் உள்ள மெத்தட்கள் சைல்ட் கிளாசில் பயன்படுத்தலாம்.
சைல்ட் கிளாஸ் ஆனது பேரண்ட் கிளாசின் மெத்தட்களை மாற்றியமைக்கலாம்.
பாலிமார்பிசம்.
ஒரு கிளாசின் ஓரே மெம்பர் ஆனது வெவ்வேறு நிலைகளை கொண்டிருத்தல் ஆகும்.கீழே
உள்ள நிரலில் ஒரு பறவை பறக்குமா அல்லது பறக்காதா என்பது ஒற்றை ஃபங்க்சனாக ஓவர் ரைட்
செய்யப்பட்ட நிரலாக எழுதப்படுகின்றது.
|
class
Bird:
def
intro(self):
print("There
are many types of birds.")
def
flight(self):
print("Most
of the birds can fly but some cannot.")
class
sparrow(Bird):
def
flight(self):
print("Sparrows
can fly.")
class
ostrich(Bird):
def
flight(self):
print("Ostriches
cannot fly.")
obj_bird
= Bird()
obj_spr
= sparrow()
obj_ost
= ostrich()
obj_bird.intro()
obj_bird.flight()
obj_spr.intro()
obj_spr.flight()
obj_ost.intro()
obj_ost.flight()
|
Output
There are many
types of birds.
Most of
the birds can fly but some cannot.
There are
many types of birds.
Sparrows
can fly.
There are
many types of birds.
Ostriches
cannot fly.
என்கேப்சுலேசன்.
இது ஆப்ஜெக்ட் ஒரியண்டட் நிரலாக்கத்தின்
அடிப்படை கருத்துரு ஆகும்.இது டேட்டாவையும் மெத்தட்களையும் ஒற்றை பகுதியாக எழுதி கிளாசிற்கு
வெளியே டேட்டாவை நேரடியாக ஆக்சஸ் செய்யாமல் மெத்தட் மூலமாக ஆக்சஸ் செய்யப்படுகின்றது.
எனவே டேட்டா ஆக்சிடெண்டல் ஆக மாற்றியமைக்க முடியாது.
ஒரு கிளாஸானது என்கேப்சுலேசனிற்கு சான்றாகும். இது டேட்டாவையும் மெத்தடையும்
ஒற்றை யுனிட் ஆக கொண்டுள்ளது.
சான்று நிரல்.
|
# Python
program to
#
demonstrate private members
#
Creating a Base class
class
Base:
def
__init__(self):
self.a
= "GeeksforGeeks"
self.__c
= "GeeksforGeeks"
#
Creating a derived class
class
Derived(Base):
def
__init__(self):
#
Calling constructor of
#
Base class
Base.__init__(self)
print("Calling
private member of base class: ")
print(self.__c)
# Driver
code
obj1 =
Base()
print(obj1.a)
#
Uncommenting print(obj1.c) will
# raise
an AttributeError
#
Uncommenting obj2 = Derived() will
# also
raise an AtrributeError as
#
private member of base class
# is
called inside derived class
|
Output
GeeksforGeeks
மேலே உள்ள நிரலில் c ஆனது பிரவேட் ஆக எழுதப்பட்டுள்ளது.எனவே இதை நேரடியாக
ஆக்சஸ் செய்ய இயலாது. இதம் மதிப்பை நேரடியாக மாற்றியமைக்கவும் இயலாது.
நன்றி.
முத்து கார்த்திகேயன் ,மதுரை.
To learn python in online and direct class(Madurai,Tamilnad,India)
contact:
Muthukarthikeyan
91 9629329142
