ವಿಷಯಕ್ಕೆ ತೆರಳಿ

ಪೈಥಾನ್ OOP: ಇನ್ಹೆರಿಟೆನ್ಸ್ ಸಂದರ್ಶನ ಪ್ರಶ್ನೆಗಳು

1. ಇನ್ಹೆರಿಟೆನ್ಸ್ (Inheritance) ಎಂದರೇನು?

ಉತ್ತರ: ಇನ್ಹೆರಿಟೆನ್ಸ್ ಎನ್ನುವುದು ಒಂದು ಕ್ಲಾಸ್ (ಚೈಲ್ಡ್ ಅಥವಾ ಸಬ್‌ಕ್ಲಾಸ್) ಬೇರೊಂದು ಕ್ಲಾಸ್‌ನ (ಪೇರೆಂಟ್ ಅಥವಾ ಸೂಪರ್‌ಕ್ಲಾಸ್) ಗುಣಲಕ್ಷಣಗಳನ್ನು (ಅಟ್ರಿಬ್ಯೂಟ್ಸ್) ಮತ್ತು ನಡವಳಿಕೆಗಳನ್ನು (ಮೆಥಡ್ಸ್) ಪಡೆದುಕೊಳ್ಳುವ ಪ್ರಕ್ರಿಯೆ. ಇದು ಕೋಡ್ ಪುನರ್ಬಳಕೆಯನ್ನು (code reusability) ಉತ್ತೇಜಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: Dog ಮತ್ತು Cat ಕ್ಲಾಸ್‌ಗಳು Animal ಕ್ಲಾಸ್‌ನಿಂದ ಇನ್ಹೆರಿಟ್ ಮಾಡಬಹುದು. Animal ಕ್ಲಾಸ್‌ನಲ್ಲಿರುವ eat() ಮೆಥಡ್ ಎರಡೂ ಕ್ಲಾಸ್‌ಗಳಿಗೆ ಲಭ್ಯವಿರುತ್ತದೆ.

class Animal:
    def eat(self):
        print("This animal is eating.")


class Dog(Animal):  # Animal ಕ್ಲಾಸ್‌ನಿಂದ ಇನ್ಹೆರಿಟ್ ಮಾಡಲಾಗಿದೆ
    def bark(self):
        print("The dog is barking.")


d = Dog()
d.eat()  # ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ನ ಮೆಥಡ್
d.bark()  # ಚೈಲ್ಡ್ ಕ್ಲಾಸ್‌ನ ಮೆಥಡ್

2. ಪೈಥಾನ್‌ನಲ್ಲಿರುವ ವಿವಿಧ ರೀತಿಯ ಇನ್ಹೆರಿಟೆನ್ಸ್‌ಗಳು ಯಾವುವು?

ಉತ್ತರ:

  • ಸಿಂಗಲ್ ಇನ್ಹೆರಿಟೆನ್ಸ್ (Single Inheritance): ಒಂದು ಚೈಲ್ಡ್ ಕ್ಲಾಸ್ ಒಂದೇ ಒಂದು ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ನಿಂದ ಇನ್ಹೆರಿಟ್ ಮಾಡುತ್ತದೆ. ( A -> B)
  • ಮಲ್ಟಿಪಲ್ ಇನ್ಹೆರಿಟೆನ್ಸ್ (Multiple Inheritance): ಒಂದು ಚೈಲ್ಡ್ ಕ್ಲಾಸ್ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ಗಳಿಂದ ಇನ್ಹೆರಿಟ್ ಮಾಡುತ್ತದೆ. (A, B -> C)
  • ಮಲ್ಟಿಲೆವೆಲ್ ಇನ್ಹೆರಿಟೆನ್ಸ್ (Multilevel Inheritance): ಒಂದು ಚೈಲ್ಡ್ ಕ್ಲಾಸ್ ಬೇರೊಂದು ಚೈಲ್ಡ್ ಕ್ಲಾಸ್‌ನಿಂದ ಇನ್ಹೆರಿಟ್ ಮಾಡುತ್ತದೆ. (A -> B -> C)
  • ಹೈರಾರ್ಕಿಕಲ್ ಇನ್ಹೆರಿಟೆನ್ಸ್ (Hierarchical Inheritance): ಒಂದೇ ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ನಿಂದ ಹಲವಾರು ಚೈಲ್ಡ್ ಕ್ಲಾಸ್‌ಗಳು ಇನ್ಹೆರಿಟ್ ಮಾಡುತ್ತವೆ. (A -> B, A -> C)
  • ಹೈಬ್ರಿಡ್ ಇನ್ಹೆರಿಟೆನ್ಸ್ (Hybrid Inheritance): ಮೇಲಿನ ಎರಡು ಅಥವಾ ಅದಕ್ಕಿಂತ ಹೆಚ್ಚು ಇನ್ಹೆರಿಟೆನ್ಸ್‌ಗಳ ಸಂಯೋಜನೆ.

3. super() ಫಂಕ್ಷನ್‌ನ ಉಪಯೋಗವೇನು?

ಉತ್ತರ: super() ಫಂಕ್ಷನ್ ಚೈಲ್ಡ್ ಕ್ಲಾಸ್‌ನಿಂದ ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ನ ಮೆಥಡ್‌ಗಳನ್ನು (ವಿಶೇಷವಾಗಿ __init__()) ಕಾಲ್ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ. ಇದು ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ನ ಇನಿಶಿಯಲೈಸೇಶನ್ ಮತ್ತು ಇತರ ಮೆಥಡ್‌ಗಳನ್ನು ಚೈಲ್ಡ್ ಕ್ಲಾಸ್‌ನಲ್ಲಿ ಬಳಸಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಉದಾಹರಣೆ:

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


class Employee(Person):
    def __init__(self, name, age, emp_id):
        # ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ನ __init__ ಅನ್ನು ಕಾಲ್ ಮಾಡುವುದು
        super().__init__(name, age)
        self.emp_id = emp_id


emp = Employee("Ravi", 30, "E123")
print(emp.name)  # "Ravi"
print(emp.emp_id)  # "E123"

4. ಮೆಥಡ್ ಓವರ್‌ರೈಡಿಂಗ್ (Method Overriding) ಎಂದರೇನು?

ಉತ್ತರ: ಚೈಲ್ಡ್ ಕ್ಲಾಸ್‌ನಲ್ಲಿ ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ನಲ್ಲಿರುವ ಅದೇ ಹೆಸರಿನ ಮೆಥಡ್ ಅನ್ನು ಪುನಃ ಡಿಫೈನ್ ಮಾಡಿದರೆ, ಅದನ್ನು ಮೆಥಡ್ ಓವರ್‌ರೈಡಿಂಗ್ ಎನ್ನುತ್ತಾರೆ. ಚೈಲ್ಡ್ ಕ್ಲಾಸ್‌ನ ಆಬ್ಜೆಕ್ಟ್ ಆ ಮೆಥಡ್ ಅನ್ನು ಕಾಲ್ ಮಾಡಿದಾಗ, ಚೈಲ್ಡ್ ಕ್ಲಾಸ್‌ನಲ್ಲಿರುವ ಮೆಥಡ್ ಎಕ್ಸಿಕ್ಯೂಟ್ ಆಗುತ್ತದೆ, ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ನದ್ದಲ್ಲ.

ಉದಾಹರಣೆ:

class Bird:
    def fly(self):
        print("Most birds can fly.")


class Ostrich(Bird):
    # fly() ಮೆಥಡ್ ಅನ್ನು ಓವರ್‌ರೈಡ್ ಮಾಡಲಾಗಿದೆ
    def fly(self):
        print("Ostriches cannot fly.")


b = Bird()
o = Ostrich()

b.fly()  # "Most birds can fly."
o.fly()  # "Ostriches cannot fly."

5. MRO (Method Resolution Order) ಎಂದರೇನು?

ಉತ್ತರ: MRO ಎನ್ನುವುದು ಮಲ್ಟಿಪಲ್ ಇನ್ಹೆರಿಟೆನ್ಸ್‌ನಲ್ಲಿ, ಒಂದು ಮೆಥಡ್ ಅನ್ನು ಹುಡುಕಲು ಪೈಥಾನ್ ಅನುಸರಿಸುವ ಕ್ರಮ. ಪೈಥಾನ್ ಮೊದಲು ಪ್ರಸ್ತುತ ಕ್ಲಾಸ್‌ನಲ್ಲಿ ಮೆಥಡ್ ಅನ್ನು ಹುಡುಕುತ್ತದೆ, ನಂತರ ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ಗಳಲ್ಲಿ ಎಡದಿಂದ ಬಲಕ್ಕೆ ಹುಡುಕುತ್ತದೆ.

ClassName.mro() ಅಥವಾ help(ClassName) ಬಳಸಿ MRO ಅನ್ನು ನೋಡಬಹುದು.

ಉದಾಹರಣೆ:

class A: pass


class B(A): pass


class C(A): pass


class D(B, C): pass


print(D.mro())
# [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

ಇಲ್ಲಿ, D ಯ ಮೆಥಡ್ ಅನ್ನು ಹುಡುಕುವಾಗ, ಪೈಥಾನ್ D -> B -> C -> A ಕ್ರಮವನ್ನು ಅನುಸರಿಸುತ್ತದೆ.