30: ഇൻഹെറിറ്റൻസും പോളിമോർഫിസവും
Dog, Cat പോലുള്ള പല ക്ലാസുകൾക്കും പൊതുവായ കാര്യങ്ങളുണ്ടാകും — രണ്ടിനും ഒരു പേരും ഒരു ശബ്ദവും ഉണ്ട്, രണ്ടും "മൃഗങ്ങൾ" ആണ്. ഓരോ ക്ലാസിലും ഒരേ കോഡ് ആവർത്തിക്കുന്നതിന് പകരം, പൊതുവായ ഭാഗം ഒരിടത്ത് എഴുതി മറ്റുള്ളവയ്ക്ക് പകർന്നു നൽകാം — ഇതാണ് ഇൻഹെറിറ്റൻസ്.
ഒരു പേരന്റ് ക്ലാസ്
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
print(f"{self.name} makes a sound")
animal = Animal("Generic Animal")
animal.speak()ഒരു ചൈൽഡ് ക്ലാസ്
class Dog(Animal): എഴുതിയാൽ, Dog, Animal-ന്റെ എല്ലാ ഗുണങ്ങളും ഇൻഹെറിറ്റ് ചെയ്യും — വീണ്ടും എഴുതേണ്ട ആവശ്യമില്ല.
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
print(f"{self.name} makes a sound")
class Dog(Animal):
pass
dog = Dog("Rex")
dog.speak() # Dog സ്വന്തമായി ഒന്നും നിർവചിച്ചിട്ടില്ല, പക്ഷേ Animal-ന്റെ speak() കിട്ടുംമെത്തേഡ് ഓവർറൈഡ് ചെയ്യുന്നു
ചൈൽഡ് ക്ലാസിന് പേരന്റിന്റെ ഒരു മെത്തേഡ്, അതേ പേരിൽ സ്വന്തമായി എഴുതി മാറ്റിവെക്കാം (override).
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
print(f"{self.name} makes a sound")
class Dog(Animal):
def speak(self):
print(f"{self.name} says Woof!")
dog = Dog("Rex")
dog.speak()`super()` ഉപയോഗിച്ച് പേരന്റ് ക്ലാസ് വിളിക്കുന്നു
ചൈൽഡ് ക്ലാസിന് സ്വന്തമായി അധിക ഡാറ്റ വേണമെങ്കിൽ, സ്വന്തം __init__ എഴുതി, super().__init__() ഉപയോഗിച്ച് പേരന്റിന്റെ __init__-നെ വീണ്ടും എഴുതാതെ വിളിക്കാം.
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
print(f"{self.name} makes a sound")
class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name) # Animal-ന്റെ __init__ പ്രവർത്തിപ്പിക്കുന്നു
self.breed = breed
def speak(self):
print(f"{self.name} ({self.breed}) says Woof!")
dog = Dog("Rex", "Labrador")
dog.speak()പോളിമോർഫിസം എന്താണ്?
പോളിമോർഫിസം എന്നാൽ, വ്യത്യസ്ത ക്ലാസുകളിലെ ഒബ്ജക്റ്റുകൾ, ഒരേ പേരിലുള്ള മെത്തേഡ് വിളിച്ചാൽ, ഓരോന്നും അതിന്റേതായ രീതിയിൽ പ്രതികരിക്കുന്നു എന്നാണ്.
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
print(f"{self.name} makes a sound")
class Dog(Animal):
def speak(self):
print(f"{self.name} says Woof!")
class Cat(Animal):
def speak(self):
print(f"{self.name} says Meow!")
animals = [Dog("Rex"), Cat("Whiskers"), Animal("Unknown")]
for animal in animals:
animal.speak()ലൂപ്പിലെ കോഡ് ഒരേ ഒരു വരി മാത്രമാണ് (animal.speak()), പക്ഷേ ഓരോ ഒബ്ജക്റ്റും അതിന്റെ സ്വന്തം ക്ലാസിലെ speak() ആണ് പ്രവർത്തിപ്പിക്കുന്നത്. ഇതാണ് പോളിമോർഫിസത്തിന്റെ ശക്തി — ഓരോ തരത്തിനും വെവ്വേറെ if-കൾ എഴുതേണ്ട ആവശ്യമില്ല.
`isinstance()` ഉപയോഗിച്ച് തരം പരിശോധിക്കുന്നു
class Animal: pass class Dog(Animal): pass dog = Dog() print(isinstance(dog, Dog)) # True print(isinstance(dog, Animal)) # True - Dog ഒരു Animal കൂടിയാണ്
സാധാരണ തുടക്കക്കാരുടെ തെറ്റുകൾ
- ചൈൽഡ് ക്ലാസിൽ സ്വന്തം
__init__എഴുതുമ്പോൾsuper().__init__()വിളിക്കാൻ മറന്ന്, പേരന്റിന്റെ ഡാറ്റ സെറ്റ് ആകാതെ വരുന്നു - ഒരു മെത്തേഡ് ഓവർറൈഡ് ചെയ്യുമ്പോൾ, പേരന്റിന്റെ പ്രധാനപ്പെട്ട ലോജിക് ആകസ്മികമായി ഒഴിവാക്കിക്കളയുന്നു
class Dog(Animal):എന്നതിലെ ബ്രാക്കറ്റ് മറന്ന്, സാധാരണ ക്ലാസ് പോലെ എഴുതി ഇൻഹെറിറ്റൻസ് നഷ്ടപ്പെടുത്തുന്നു
ഈ അധ്യായത്തിന്റെ സംഗ്രഹം
- ഇൻഹെറിറ്റൻസ് ഉപയോഗിച്ച് പേരന്റ് ക്ലാസിന്റെ ഗുണങ്ങൾ ചൈൽഡ് ക്ലാസിലേക്ക് പകർന്നു
- മെത്തേഡ് ഓവർറൈഡ് ചെയ്തു
super()ഉപയോഗിച്ച് പേരന്റിന്റെ__init__വീണ്ടും ഉപയോഗിച്ചു- പോളിമോർഫിസം ഉപയോഗിച്ച്, വ്യത്യസ്ത ക്ലാസുകളെ ഒരേ ലൂപ്പിൽ കൈകാര്യം ചെയ്തു
isinstance()ഉപയോഗിച്ച് തരം പരിശോധിച്ചു
വ്യായാമങ്ങൾ
area()മെത്തേഡുള്ള ഒരുShapeക്ലാസ് ഉണ്ടാക്കി (0തിരികെ നൽകട്ടെ),Circle(Shape)എന്ന ചൈൽഡ് ക്ലാസിൽarea()ഓവർറൈഡ് ചെയ്ത് ശരിയായ വിസ്തീർണ്ണം കണക്കാക്കുകVehicleഎന്ന പേരന്റ് ക്ലാസും,Car,Bikeഎന്നീ രണ്ട് ചൈൽഡ് ക്ലാസുകളും ഉണ്ടാക്കി, ഓരോന്നിനും വ്യത്യസ്തമായdescribe()മെത്തേഡ് എഴുതി, ഒരു ലിസ്റ്റിൽ ഇട്ട് ലൂപ്പ് ചെയ്ത് വിളിക്കുകsuper().__init__()ഉപയോഗിച്ച്, പേരന്റ് ക്ലാസിന്റെ ഡാറ്റയും സ്വന്തം അധിക ഡാറ്റയും ഉള്ള ഒരു ചൈൽഡ് ക്ലാസ് എഴുതുക
Quiz & Self Assessment
class Dog(Animal): എന്ന് എഴുതിയാൽ എന്ത് സംഭവിക്കും?അടുത്ത അധ്യായത്തിൽ, ഒരു ഒബ്ജക്റ്റിന്റെ ഡാറ്റ സംരക്ഷിക്കാൻ സഹായിക്കുന്ന എൻകാപ്സുലേഷനും, പൈത്തണിന്റെ പ്രത്യേക മാജിക് മെത്തേഡുകളും നിങ്ങൾ പഠിക്കും.