ಪೈಥಾನ್ OOP: ಪಾಲಿಮಾರ್ಫಿಸಂ ಸಂದರ್ಶನ ಪ್ರಶ್ನೆಗಳು
1. ಪಾಲಿಮಾರ್ಫಿಸಂ (Polymorphism) ಎಂದರೇನು?
ಉತ್ತರ: "ಪಾಲಿಮಾರ್ಫಿಸಂ" ಎಂಬ ಪದದ ಅರ್ಥ "ಹಲವಾರು ರೂಪಗಳು". ಪ್ರೋಗ್ರಾಮಿಂಗ್ನಲ್ಲಿ, ಒಂದೇ ಮೆಥಡ್ ಅಥವಾ ಆಪರೇಟರ್ ಬೇರೆ ಬೇರೆ ಕ್ಲಾಸ್ಗಳು ಅಥವಾ ಡೇಟಾ ಟೈಪ್ಗಳೊಂದಿಗೆ ವಿಭಿನ್ನವಾಗಿ ವರ್ತಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಪಾಲಿಮಾರ್ಫಿಸಂ ಎನ್ನುತ್ತಾರೆ.
ಉದಾಹರಣೆ:
+ ಆಪರೇಟರ್ ಸಂಖ್ಯೆಗಳನ್ನು ಕೂಡಿಸುತ್ತದೆ (5 + 3 = 8) ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ಗಳನ್ನು ಜೋಡಿಸುತ್ತದೆ (
"Hello" + "World" = "HelloWorld"). ಇಲ್ಲಿ + ಆಪರೇಟರ್ ಪಾಲಿಮಾರ್ಫಿಕ್ ಆಗಿದೆ.
2. ಪೈಥಾನ್ನಲ್ಲಿ ಪಾಲಿಮಾರ್ಫಿಸಂ ಅನ್ನು ಹೇಗೆ ಸಾಧಿಸಲಾಗುತ್ತದೆ?
ಉತ್ತರ: ಪೈಥಾನ್ನಲ್ಲಿ ಪಾಲಿಮಾರ್ಫಿಸಂ ಅನ್ನು ಮುಖ್ಯವಾಗಿ ಎರಡು ವಿಧಾನಗಳಲ್ಲಿ ಸಾಧಿಸಲಾಗುತ್ತದೆ:
- ಡಕ್ ಟೈಪಿಂಗ್ (Duck Typing): "ಒಂದು ಪಕ್ಷಿ ಬಾತುಕೋಳಿಯಂತೆ ನಡೆದರೆ, ಬಾತುಕೋಳಿಯಂತೆ ಈಜಿದರೆ, ಮತ್ತು ಬಾತುಕೋಳಿಯಂತೆ ಕೂಗಿದರೆ, ಅದು ಬಾತುಕೋಳಿಯೇ ಇರಬೇಕು" ಎಂಬ ತತ್ವದ ಮೇಲೆ ಇದು ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಅಂದರೆ, ಒಂದು ಆಬ್ಜೆಕ್ಟ್ನ ಟೈಪ್ಗಿಂತ, ಅದು ಹೊಂದಿರುವ ಮೆಥಡ್ಗಳು ಅಥವಾ ನಡವಳಿಕೆಗಳು ಮುಖ್ಯ.
- ಮೆಥಡ್ ಓವರ್ರೈಡಿಂಗ್ (Method Overriding): ಚೈಲ್ಡ್ ಕ್ಲಾಸ್ನಲ್ಲಿ ಪೇರೆಂಟ್ ಕ್ಲಾಸ್ನ ಮೆಥಡ್ ಅನ್ನು ಪುನಃ ಡಿಫೈನ್ ಮಾಡುವುದು.
3. ಡಕ್ ಟೈಪಿಂಗ್ (Duck Typing) ಅನ್ನು ಉದಾಹರಣೆಯೊಂದಿಗೆ ವಿವರಿಸಿ.
ಉತ್ತರ: ಡಕ್ ಟೈಪಿಂಗ್ನಲ್ಲಿ, ನಾವು ಆಬ್ಜೆಕ್ಟ್ನ ಕ್ಲಾಸ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುವುದಿಲ್ಲ. ಬದಲಾಗಿ, ನಮಗೆ ಬೇಕಾದ ಮೆಥಡ್ ಆ ಆಬ್ಜೆಕ್ಟ್ನಲ್ಲಿ ಇದೆಯೇ ಎಂದು ಮಾತ್ರ ನೋಡುತ್ತೇವೆ.
ಉದಾಹರಣೆ:
ಕೆಳಗಿನ describe() ಫಂಕ್ಷನ್ಗೆ ಯಾವುದೇ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಕಳುಹಿಸಬಹುದು, ಆದರೆ ಅದರಲ್ಲಿ talk() ಮತ್ತು move() ಮೆಥಡ್ಗಳು
ಇರಬೇಕು.
class Duck:
def talk(self):
return "Quack!"
def move(self):
return "Walks and swims."
class Dog:
def talk(self):
return "Woof!"
def move(self):
return "Walks and runs."
def describe(animal):
# ಆಬ್ಜೆಕ್ಟ್ನ ಟೈಪ್ ಅನ್ನು ಪರೀಕ್ಷಿಸದೆ, ಮೆಥಡ್ಗಳನ್ನು ಕಾಲ್ ಮಾಡುವುದು
print(f"The animal says: {animal.talk()}")
print(f"How it moves: {animal.move()}")
duck = Duck()
dog = Dog()
describe(duck)
print("-" * 20)
describe(dog)
ಇಲ್ಲಿ, describe ಫಂಕ್ಷನ್ Duck ಮತ್ತು Dog ಎರಡೂ ಆಬ್ಜೆಕ್ಟ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ, ಏಕೆಂದರೆ ಎರಡರಲ್ಲೂ talk ಮತ್ತು
move ಮೆಥಡ್ಗಳಿವೆ.
4. ಮೆಥಡ್ ಓವರ್ಲೋಡಿಂಗ್ (Method Overloading) ಎಂದರೇನು? ಪೈಥಾನ್ ಇದನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆಯೇ?
ಉತ್ತರ: ಮೆಥಡ್ ಓವರ್ಲೋಡಿಂಗ್ ಎಂದರೆ ಒಂದೇ ಕ್ಲಾಸ್ನಲ್ಲಿ ಒಂದೇ ಹೆಸರಿನ ಹಲವಾರು ಮೆಥಡ್ಗಳನ್ನು ಹೊಂದುವುದು, ಆದರೆ ಅವುಗಳ ಪ್ಯಾರಾಮೀಟರ್ಗಳ ಸಂಖ್ಯೆ ಅಥವಾ ಟೈಪ್ ಬೇರೆ ಬೇರೆಯಾಗಿರುತ್ತದೆ.
ಪೈಥಾನ್ ಮೆಥಡ್ ಓವರ್ಲೋಡಿಂಗ್ ಅನ್ನು ನೇರವಾಗಿ ಬೆಂಬಲಿಸುವುದಿಲ್ಲ. ನೀವು ಒಂದೇ ಹೆಸರಿನ ಎರಡು ಮೆಥಡ್ಗಳನ್ನು ಡಿಫೈನ್ ಮಾಡಿದರೆ, ಕೊನೆಯದಾಗಿ ಡಿಫೈನ್ ಮಾಡಿದ ಮೆಥಡ್ ಮಾತ್ರ ಮಾನ್ಯವಾಗಿರುತ್ತದೆ.
ಆದಾಗ್ಯೂ, ಡೀಫಾಲ್ಟ್ ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳು ಅಥವಾ *args ಬಳಸಿ ಓವರ್ಲೋಡಿಂಗ್ನಂತಹ ಕಾರ್ಯವನ್ನು ಸಾಧಿಸಬಹುದು.
ಉದಾಹರಣೆ:
class Adder:
def add(self, a, b, c=0): # ಡೀಫಾಲ್ಟ್ ಆರ್ಗ್ಯುಮೆಂಟ್ ಬಳಸಿ
return a + b + c
adder = Adder()
print(adder.add(2, 3)) # 5
print(adder.add(2, 3, 5)) # 10
5. ಆಪರೇಟರ್ ಓವರ್ಲೋಡಿಂಗ್ (Operator Overloading) ಎಂದರೇನು?
ಉತ್ತರ:
ಆಪರೇಟರ್ ಓವರ್ಲೋಡಿಂಗ್ ಎಂದರೆ +, -, *, > ಮುಂತಾದ ಆಪರೇಟರ್ಗಳನ್ನು ನಮ್ಮದೇ ಕಸ್ಟಮ್ ಕ್ಲಾಸ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಂತೆ
ಮಾಡುವುದು. ಇದನ್ನು ಪೈಥಾನ್ನ ವಿಶೇಷ "ಡಂಡರ್" (dunder - double underscore) ಮೆಥಡ್ಗಳನ್ನು ಬಳಸಿ ಸಾಧಿಸಲಾಗುತ್ತದೆ.
ಉದಾಹರಣೆ:
ಎರಡು Vector ಆಬ್ಜೆಕ್ಟ್ಗಳನ್ನು ಕೂಡಿಸಲು + ಆಪರೇಟರ್ ಅನ್ನು ಓವರ್ಲೋಡ್ ಮಾಡುವುದು.
class Vector:
def __init__(self, x, y):
self.x = x
self.y = y
# '+' ಆಪರೇಟರ್ ಅನ್ನು ಓವರ್ಲೋಡ್ ಮಾಡಲು __add__ ಮೆಥಡ್
def __add__(self, other):
return Vector(self.x + other.x, self.y + other.y)
def __str__(self):
return f"Vector({self.x}, {self.y})"
v1 = Vector(2, 3)
v2 = Vector(4, 5)
v3 = v1 + v2 # __add__ ಮೆಥಡ್ ಇಲ್ಲಿ ಕಾಲ್ ಆಗುತ್ತದೆ
print(v3) # Vector(6, 8)
ಕೆಲವು ಸಾಮಾನ್ಯ ಡಂಡರ್ ಮೆಥಡ್ಗಳು:
__add__(self, other)->+__sub__(self, other)->-__mul__(self, other)->*__lt__(self, other)-><__gt__(self, other)->>__len__(self)->len()__str__(self)->str()