ಗೆಟರ್ ಮತ್ತು ಸೆಟರ್ಗಳು (Getters and Setters)
ಪೈಥಾನ್ನಲ್ಲಿ, ಅಟ್ರಿಬ್ಯೂಟ್ನ ಹೆಸರಿನ ಮೊದಲು ಅಂಡರ್ಸ್ಕೋರ್ (_) ಬಳಸುವ ಮೂಲಕ ಅದನ್ನು "ಪ್ರೈವೇಟ್" ಎಂದು ಸೂಚಿಸಲಾಗುತ್ತದೆ (ಉದಾ: _name). ಇದು ಕೇವಲ ಒಂದು ಕನ್ವೆನ್ಷನ್ ಆಗಿದ್ದರೂ, ಆ ಅಟ್ರಿಬ್ಯೂಟ್ ಅನ್ನು ಕ್ಲಾಸ್ನ ಹೊರಗೆ ನೇರವಾಗಿ ಬಳಸಬಾರದು ಎಂದು ಇತರ ಪ್ರೋಗ್ರಾಮರ್ಗಳಿಗೆ ಸೂಚಿಸುತ್ತದೆ.
@property ಬಳಸುವುದರಿಂದ, ನಾವು ಎನ್ಕ್ಯಾಪ್ಸುಲೇಶನ್ನ ಪ್ರಯೋಜನಗಳನ್ನು ಪಡೆಯುವುದರ ಜೊತೆಗೆ, ಕೋಡ್ ಅನ್ನು ಕ್ಲೀನ್ ಮತ್ತು ಓದಲು ಸುಲಭವಾಗಿ ಇಡಬಹುದು.
govardhan.score = 95ಎಂದು ಬರೆದಾಗ,@score.setterಇಂದ ಅಲಂಕರಿಸಲ್ಪಟ್ಟscore()ಸೆಟರ್ ಮೆಥಡ್ ಕಾಲ್ ಆಗುತ್ತದೆ.govardhan.scoreಎಂದು ಓದಿದಾಗ,@propertyಇಂದ ಅಲಂಕರಿಸಲ್ಪಟ್ಟscore()ಗೆಟರ್ ಮೆಥಡ್ ಕಾಲ್ ಆಗುತ್ತದೆ.scoreಎಂಬ ಪ್ರಾಪರ್ಟಿಯನ್ನು ರಚಿಸಲಾಗಿದೆ. ಈ ಉದಾಹರಣೆಯಲ್ಲಿ:
``` print(f"ಅಂತಿಮ ಅಂಕ: {govardhan.score}") # ಅಂಕ ಬದಲಾಗುವುದಿಲ್ಲ govardhan.score = 105 # ಇದು ದೋಷ ಸಂದೇಶವನ್ನು ಪ್ರಿಂಟ್ ಮಾಡುತ್ತದೆ
ಅಮಾನ್ಯ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸಲು ಪ್ರಯತ್ನಿಸುವುದು
print("-" * 20)
print(f"ಹೊಸ ಅಂಕ: {govardhan.score}")
govardhan.score = 95 # ಇದು score ಸೆಟರ್ ಮೆಥಡ್ ಅನ್ನು ಕಾಲ್ ಮಾಡುತ್ತದೆ
ಸೆಟರ್ ಅನ್ನು ಕಾಲ್ ಮಾಡುವುದು
print("-" * 20)
print(f"ಪ್ರಸ್ತುತ ಅಂಕ: {govardhan.score}")
ಗೆಟರ್ ಅನ್ನು ಕಾಲ್ ಮಾಡುವುದು (ಮೆಥಡ್ನಂತೆ ಅಲ್ಲ, ಅಟ್ರಿಬ್ಯೂಟ್ನಂತೆ)
govardhan = Student("ಗೋವರ್ಧನ್", 85)
ವಿದ್ಯಾರ್ಥಿ ಆಬ್ಜೆಕ್ಟ್ ರಚಿಸುವುದು
print("ದೋಷ: ಅಂಕಗಳು 0 ಮತ್ತು 100 ರ ನಡುವೆ ಇರಬೇಕು!")
else:
self._score = new_score
if 0 <= new_score <= 100:
print(f"ಸೆಟರ್: '{self.name}' ಅವರ ಅಂಕಗಳನ್ನು {new_score} ಕ್ಕೆ ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ...")
"""ಇದು ಸೆಟರ್ ಮೆಥಡ್. ಅಂಕಗಳನ್ನು ವ್ಯಾಲಿಡೇಟ್ ಮಾಡಿ ಹೊಂದಿಸುತ್ತದೆ."""
def score(self, new_score):
@score.setter
return self._score
print(f"ಗೆಟರ್: '{self.name}' ಅವರ ಅಂಕಗಳನ್ನು ಪಡೆಯಲಾಗುತ್ತಿದೆ...")
"""ಇದು ಗೆಟರ್ ಮೆಥಡ್. ಅಂಕಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ."""
def score(self):
@property
self._score = score # ಪ್ರೈವೇಟ್ ಅಟ್ರಿಬ್ಯೂಟ್
self.name = name
def __init__(self, name, score):
class Student: ```python
ಒಬ್ಬ ವಿದ್ಯಾರ್ಥಿಯ ಅಂಕಗಳನ್ನು ನಿರ್ವಹಿಸುವ Student ಕ್ಲಾಸ್ ಅನ್ನು ರಚಿಸೋಣ. ಅಂಕಗಳು 0 ಮತ್ತು 100 ರ ನಡುವೆ ಇರಬೇಕು ಎಂಬ ನಿಯಮವನ್ನು ಜಾರಿಗೊಳಿಸಲು ನಾವು ಸೆಟರ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ.
ಉದಾಹರಣೆ: ವಿದ್ಯಾರ್ಥಿಯ ಅಂಕಗಳು
@<property_name>.deleter: ಡಿಲೀಟರ್ ಮೆಥಡ್ ಅನ್ನು ಡಿಫೈನ್ ಮಾಡುತ್ತದೆ.@<property_name>.setter: ಸೆಟರ್ ಮೆಥಡ್ ಅನ್ನು ಡಿಫೈನ್ ಮಾಡುತ್ತದೆ.@property: ಗೆಟರ್ ಮೆಥಡ್ ಅನ್ನು ಡಿಫೈನ್ ಮಾಡುತ್ತದೆ.@propertyಮೂರು ಸಂಬಂಧಿತ ಡೆಕೊರೇಟರ್ಗಳನ್ನು ಹೊಂದಿದೆ:
ಪೈಥಾನ್ನಲ್ಲಿ ಗೆಟರ್ ಮತ್ತು ಸೆಟರ್ಗಳನ್ನು ರಚಿಸಲು "ಪೈಥಾನಿಕ್" ವಿಧಾನವೆಂದರೆ @property ಡೆಕೊರೇಟರ್ ಅನ್ನು ಬಳಸುವುದು. ಇದು ಮೆಥಡ್ಗಳನ್ನು ಅಟ್ರಿಬ್ಯೂಟ್ಗಳಂತೆ ಬಳಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
@property ಡೆಕೊರೇಟರ್ ಬಳಕೆ
- ಹೆಚ್ಚಿನ ಫ್ಲೆಕ್ಸಿಬಿಲಿಟಿ (Increased Flexibility): ಭವಿಷ್ಯದಲ್ಲಿ ಅಟ್ರಿಬ್ಯೂಟ್ನ ಆಂತರಿಕ ರಚನೆ ಬದಲಾದರೂ, ಗೆಟರ್ ಮತ್ತು ಸೆಟರ್ ಮೆಥಡ್ಗಳನ್ನು ಬಳಸುವುದರಿಂದ ಕ್ಲಾಸ್ನ ಹೊರಗಿನ ಕೋಡ್ಗೆ ಯಾವುದೇ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ.
- ಡೇಟಾ ಪ್ರವೇಶದ ಮೇಲೆ ನಿಯಂತ್ರಣ (Controlled Access): ಅಟ್ರಿಬ್ಯೂಟ್ಗಳನ್ನು ಓದಲು-ಮಾತ್ರ (read-only) ಅಥವಾ ಬರೆಯಲು-ಮಾತ್ರ (write-only) ಮಾಡಬಹುದು.
- ಡೇಟಾ ವ್ಯಾಲಿಡೇಶನ್ (Data Validation): ಅಟ್ರಿಬ್ಯೂಟ್ಗೆ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸುವಾಗ, ಅದು ಸರಿಯಾದ ಫಾರ್ಮ್ಯಾಟ್ನಲ್ಲಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ಸೆಟರ್ಗಳು ಅವಕಾಶ ನೀಡುತ್ತವೆ.
ಗೆಟರ್ ಮತ್ತು ಸೆಟರ್ಗಳನ್ನು ಏಕೆ ಬಳಸಬೇಕು?
ಎನ್ಕ್ಯಾಪ್ಸುಲೇಶನ್ ಎಂದರೆ, ಡೇಟಾ (ಅಟ್ರಿಬ್ಯೂಟ್ಗಳು) ಮತ್ತು ಆ ಡೇಟಾದ ಮೇಲೆ ಕೆಲಸ ಮಾಡುವ ಮೆಥಡ್ಗಳನ್ನು ಒಂದೇ ಯೂನಿಟ್ (ಕ್ಲಾಸ್) ಒಳಗೆ ಕಟ್ಟಿಹಾಕುವುದು. ಇದು ಡೇಟಾವನ್ನು ನೇರ ಪ್ರವೇಶದಿಂದ ರಕ್ಷಿಸುತ್ತದೆ ಮತ್ತು ಡೇಟಾದ ಸಮಗ್ರತೆಯನ್ನು ಕಾಪಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ಎನ್ಕ್ಯಾಪ್ಸುಲೇಶನ್ ಎಂದರೇನು?
ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ನಲ್ಲಿ (OOP), ಗೆಟರ್ (Getter) ಮತ್ತು ಸೆಟರ್ (Setter) ಮೆಥಡ್ಗಳು ಒಂದು ಕ್ಲಾಸ್ನ ಪ್ರೈವೇಟ್ ಅಟ್ರಿಬ್ಯೂಟ್ಗಳ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು (get) ಮತ್ತು ಹೊಂದಿಸಲು (set) ಬಳಸುವ ಮೆಥಡ್ಗಳಾಗಿವೆ. ಇವು ಎನ್ಕ್ಯಾಪ್ಸುಲೇಶನ್ (Encapsulation) ಪರಿಕಲ್ಪನೆಯ ಒಂದು ಪ್ರಮುಖ ಭಾಗವಾಗಿವೆ.