Python Encapsulation

பைத்தான் என்கேப்ஸுலேஷனைப் புரிந்துகொள்ளுங்கள்

பைத்தான் என்கேப்ஸுலேஷன்

என்கேப்ஸுலேஷன் என்பது ஒரு வகுப்பிற்குள் தரவைப் பாதுகாப்பது பற்றியது.

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

இது உங்கள் தரவில் தற்செயலான மாற்றங்களைத் தடுக்கிறது மற்றும் உங்கள் வகுப்பு எவ்வாறு செயல்படுகிறது என்பதன் உள் விவரங்களை மறைக்கிறது.

என்கேப்ஸுலேஷன் கருத்து:

தனிப்பட்ட தரவு
• __age
• __salary
• __grade
பொது இடைமுகம்
• get_age()
• set_age()
• get_status()

தனிப்பட்ட தரவு உள்ளே பாதுகாக்கப்பட்டுள்ளது. வெளிப்புற குறியீடு பொது முறைகள் மூலம் மட்டுமே அணுக முடியும்.

தனிப்பட்ட பண்புகள்

பைத்தானில், இரட்டை அடிக்கோடு __ முன்னொட்டைப் பயன்படுத்தி பண்புகளை தனிப்பட்டதாக ஆக்கலாம்:

எடுத்துக்காட்டு

__age என்ற தனிப்பட்ட வகுப்பு பண்பை உருவாக்கவும்:

class Person:
  def __init__(self, name, age):
    self.name = name
    self.__age = age  # தனிப்பட்ட பண்பு

p1 = Person("Emil", 25)
print(p1.name)        # இது வேலை செய்யும்
print(p1.__age)       # இது பிழையை ஏற்படுத்தும்
வெளியீடு:
Emil
AttributeError: 'Person' object has no attribute '__age'

⚠️ குறிப்பு:

தனிப்பட்ட பண்புகளை வகுப்பிற்கு வெளியே இருந்து நேரடியாக அணுக முடியாது.

கெட்டர் மற்றும் செட்டர் முறைகள்

கெட்டர் முறை

ஒரு தனிப்பட்ட பண்பை அணுக, நீங்கள் ஒரு கெட்டர் முறையை உருவாக்கலாம்:

def get_age(self):
    return self.__age

செட்டர் முறை

ஒரு தனிப்பட்ட பண்பை மாற்ற, நீங்கள் ஒரு செட்டர் முறையை உருவாக்கலாம்:

def set_age(self, age):
    if age > 0:
        self.__age = age
    else:
        print("Age must be positive")

முழு எடுத்துக்காட்டு

class Person:
  def __init__(self, name, age):
    self.name = name
    self.__age = age

  def get_age(self):
    return self.__age

  def set_age(self, age):
    if age > 0:
      self.__age = age
    else:
      print("Age must be positive")

p1 = Person("Tobias", 25)
print("Original age:", p1.get_age())

p1.set_age(26)
print("Modified age:", p1.get_age())

p1.set_age(-5)  # செல்லுபடியாகாத மதிப்பு
வெளியீடு:
Original age: 25
Modified age: 26
Age must be positive

என்கேப்ஸுலேஷன் ஏன் பயன்படுத்த வேண்டும்?

தரவு பாதுகாப்பு

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

சரிபார்ப்பு

அதை அமைப்பதற்கு முன் தரவை சரிபார்க்கலாம். செட்டர் முறைகள் மதிப்புகளை சரிபார்க்கின்றன.

நெகிழ்வுத்தன்மை

உள் செயல்படுத்தல் வெளிப்புற குறியீட்டை பாதிக்காமல் மாற்ற முடியும்.

கட்டுப்பாடு

தரவு எவ்வாறு அணுகப்படுகிறது மற்றும் மாற்றப்படுகிறது என்பதில் முழு கட்டுப்பாடு உள்ளது.

நடைமுறை எடுத்துக்காட்டு

class Student:
  def __init__(self, name):
    self.name = name
    self.__grade = 0

  def set_grade(self, grade):
    if 0 <= grade <= 100:
      self.__grade = grade
    else:
      print("Grade must be between 0 and 100")

  def get_grade(self):
    return self.__grade

  def get_status(self):
    if self.__grade >= 60:
      return "Passed"
    else:
      return "Failed"

student = Student("Emil")
student.set_grade(85)
print("Grade:", student.get_grade())
print("Status:", student.get_status())

student.set_grade(150)  # செல்லுபடியாகாத மதிப்பு
வெளியீடு:
Grade: 85
Status: Passed
Grade must be between 0 and 100

பாதுகாக்கப்பட்ட பண்புகள்

பைத்தானில் ஒற்றை அடிக்கோடு _ முன்னொட்டைப் பயன்படுத்தி பாதுகாக்கப்பட்ட பண்புகளுக்கான ஒரு மரபும் உள்ளது:

பாதுகாக்கப்பட்ட பண்பு

பாதுகாக்கப்பட்ட பண்பை உருவாக்கவும்:

self._property
class Person:
  def __init__(self, name, salary):
    self.name = name
    self._salary = salary  # பாதுகாக்கப்பட்ட பண்பு

p1 = Person("Linus", 50000)
print(p1.name)
print(p1._salary)  # அணுகலாம், ஆனால் கூடாது

💡 முக்கியமான குறிப்பு:

ஒற்றை அடிக்கோடு _ என்பது ஒரு மரபு மட்டுமே. இது பிற நிரலாளர்களுக்கு பண்பு உள் பயன்பாட்டிற்காக உள்ளது என்று கூறுகிறது, ஆனால் பைத்தான் இந்த கட்டுப்பாட்டைக் கட்டாயப்படுத்தாது. இது "நடைமுறையில் தனிப்பட்டது" என்று அர்த்தம்.

தனிப்பட்ட முறைகள்

இரட்டை அடிக்கோடு முன்னொட்டைப் பயன்படுத்தி முறைகளையும் தனிப்பட்டதாக ஆக்கலாம்:

எடுத்துக்காட்டு

ஒரு தனிப்பட்ட முறையை உருவாக்கவும்:

class Calculator:
  def __init__(self):
    self.result = 0

  def __validate(self, num):
    if not isinstance(num, (int, float)):
      return False
    return True

  def add(self, num):
    if self.__validate(num):
      self.result += num
    else:
      print("Invalid number")

calc = Calculator()
calc.add(10)
calc.add(5)
print("Result:", calc.result)
# calc.__validate(5)  # இது பிழையை ஏற்படுத்தும்
வெளியீடு:
Result: 15

⚠️ குறிப்பு:

இரட்டை அடிக்கோடு __ கொண்ட தனிப்பட்ட பண்புகளைப் போலவே, தனிப்பட்ட முறைகளை வகுப்பிற்கு வெளியே இருந்து நேரடியாக அழைக்க முடியாது. __validate முறையை வகுப்பின் உள்ளே உள்ள மற்ற முறைகள் மட்டுமே பயன்படுத்த முடியும்.

பெயர் மேங்க்ளிங்

பெயர் மேங்க்ளிங் என்பது பைத்தான் தனிப்பட்ட பண்புகள் மற்றும் முறைகளை எவ்வாறு செயல்படுத்துகிறது என்பதாகும்.

நீங்கள் இரட்டை அடிக்கோடு __ ஐப் பயன்படுத்தும் போது, பைத்தான் உள்நாட்டில் _ClassName ஐ முன்னால் சேர்ப்பதன் மூலம் அதை தானாகவே மாற்றுகிறது.

எடுத்துக்காட்டு

பைத்தான் பெயரை எவ்வாறு மேங்கிள் செய்கிறது என்பதைப் பார்க்கவும்:

__age → _Person__age
__validate → _Calculator__validate
class Person:
  def __init__(self, name, age):
    self.name = name
    self.__age = age

p1 = Person("Emil", 30)

# இது பைத்தான் பெயரை எவ்வாறு மேங்கிள் செய்கிறது:
print(p1.name)           # Emil
print(p1._Person__age)   # 30 (பரிந்துரைக்கப்படவில்லை!)
# print(p1.__age)        # பிழை!
வெளியீடு:
Emil
30

⚠️ முக்கியமான எச்சரிக்கை:

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

பயிற்சி

பைத்தானில் ஒரு பண்பை தனிப்பட்டதாக எவ்வாறு ஆக்குவது?

ஒற்றை அடிக்கோடு முன்னொட்டைப் பயன்படுத்தவும்: _property
✗ தவறு! ஒற்றை அடிக்கோடு _ என்பது பாதுகாக்கப்பட்ட பண்புகளுக்கான மரபு மட்டுமே. இது நிரலாளர்களுக்கு "இது உள் பயன்பாட்டிற்கு மட்டுமே" என்று குறிப்பிடுகிறது, ஆனால் பைத்தான் அணுகலைத் தடுக்காது.
இரட்டை அடிக்கோடு முன்னொட்டைப் பயன்படுத்தவும்: __property
✓ சரி! பைத்தானில், இரட்டை அடிக்கோடு __ முன்னொட்டு ஒரு பண்பை தனிப்பட்டதாக ஆக்குகிறது. இது பெயர் மேங்க்ளிங்கை ஏற்படுத்துகிறது, இது வகுப்பிற்கு வெளியே இருந்து நேரடி அணுகலைத் தடுக்கிறது. எடுத்துக்காட்டு: self.__age, self.__salary
private விசைச் சொல்லைப் பயன்படுத்தவும்
✗ தவறு! பைத்தானில் private என்ற விசைச் சொல் இல்லை. C++ அல்லது Java போன்ற மொழிகளில் private இருப்பது போல் பைத்தானில் இல்லை. பைத்தான் பெயர் மேங்க்ளிங்கைப் பயன்படுத்தி இரட்டை அடிக்கோடு மூலம் தனியுரிமையை செயல்படுத்துகிறது.