பைத்தான் என்கேப்ஸுலேஷன்
என்கேப்ஸுலேஷன் என்பது ஒரு வகுப்பிற்குள் தரவைப் பாதுகாப்பது பற்றியது.
இதன் பொருள் தரவு (பண்புகள்) மற்றும் முறைகளை ஒரு வகுப்பில் ஒன்றாக வைத்திருத்தல், மேலும் வகுப்பிற்கு வெளியே இருந்து தரவை எவ்வாறு அணுகலாம் என்பதைக் கட்டுப்படுத்துதல்.
இது உங்கள் தரவில் தற்செயலான மாற்றங்களைத் தடுக்கிறது மற்றும் உங்கள் வகுப்பு எவ்வாறு செயல்படுகிறது என்பதன் உள் விவரங்களை மறைக்கிறது.
என்கேப்ஸுலேஷன் கருத்து:
• __salary
• __grade
• 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) # இது பிழையை ஏற்படுத்தும்
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) # செல்லுபடியாகாத மதிப்பு
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) # செல்லுபடியாகாத மதிப்பு
Status: Passed
Grade must be between 0 and 100
பாதுகாக்கப்பட்ட பண்புகள்
பைத்தானில் ஒற்றை அடிக்கோடு _ முன்னொட்டைப் பயன்படுத்தி பாதுகாக்கப்பட்ட பண்புகளுக்கான ஒரு மரபும் உள்ளது:
பாதுகாக்கப்பட்ட பண்பு
பாதுகாக்கப்பட்ட பண்பை உருவாக்கவும்:
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) # இது பிழையை ஏற்படுத்தும்
குறிப்பு:
இரட்டை அடிக்கோடு __ கொண்ட தனிப்பட்ட பண்புகளைப் போலவே, தனிப்பட்ட முறைகளை வகுப்பிற்கு வெளியே இருந்து நேரடியாக அழைக்க முடியாது. __validate முறையை வகுப்பின் உள்ளே உள்ள மற்ற முறைகள் மட்டுமே பயன்படுத்த முடியும்.
பெயர் மேங்க்ளிங்
பெயர் மேங்க்ளிங் என்பது பைத்தான் தனிப்பட்ட பண்புகள் மற்றும் முறைகளை எவ்வாறு செயல்படுத்துகிறது என்பதாகும்.
நீங்கள் இரட்டை அடிக்கோடு __ ஐப் பயன்படுத்தும் போது, பைத்தான் உள்நாட்டில் _ClassName ஐ முன்னால் சேர்ப்பதன் மூலம் அதை தானாகவே மாற்றுகிறது.
எடுத்துக்காட்டு
பைத்தான் பெயரை எவ்வாறு மேங்கிள் செய்கிறது என்பதைப் பார்க்கவும்:
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) # பிழை!
30
முக்கியமான எச்சரிக்கை:
மேங்கிள் செய்யப்பட்ட பெயரைப் பயன்படுத்தி தனிப்பட்ட பண்புகளை அணுக முடியும் என்றாலும், இது பரிந்துரைக்கப்படவில்லை. இது என்கேப்ஸுலேஷனின் நோக்கத்தை முறியடிக்கிறது. எப்போதும் கெட்டர் மற்றும் செட்டர் முறைகளைப் பயன்படுத்தவும்.