பைத்தானில் ஊப்ஸ் கருத்துருக்கள்.

 

                             

பைத்தான் ஆப்ஜெக்ட் ஒரியண்டட் கருத்துக்களை சப்போர்ட் செய்கின்றது.இது என்கேப்சுலேசன்,இன்ஹெரிட்டன்ஸ், பாலிமார்பிசம் போன்றவற்றை பயன்படுத்துகின்றது.ஆப்ஜெக்ட் ஒரியண்டட் நிரலாக்கத்தின் முக்கிய கோட்பாடு டேட்டாவையும் மெத்தடையும் ஒரே யுனிட் ஆக உருவாக்கி அதற்கு வெளியே நேரடியாக டேட்டாவை அனுக முடியாது செய்தலே ஆகும்.

ஆப்ஜெக்ட் ஒரியண்டட் நிரலாக்கத்தின் முக்கிய கருத்துக்கள்.

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