29: ക്ലാസുകളും ഒബ്ജക്റ്റുകളും
ഈ കോഴ്സിൽ ഇതുവരെ ഉപയോഗിച്ച ലിസ്റ്റ്, സ്ട്രിംഗ് പോലുള്ളവ, ഡാറ്റയും (ഉള്ളടക്കം) ബിഹേവിയറും (.append(), .upper() പോലുള്ള മെത്തേഡുകൾ) ഒരുമിച്ച് ചേർത്ത് വെച്ചിരിക്കുന്നു. ഇപ്പോൾ, നമുക്ക് സ്വന്തമായി അത്തരം പുതിയ ഡാറ്റാ തരങ്ങൾ ഉണ്ടാക്കാൻ പഠിക്കാം — ഇതാണ് ക്ലാസുകൾ.
ക്ലാസ് എന്താണ്? ഒബ്ജക്റ്റ് എന്താണ്?
ഒരു ക്ലാസ് ഒരു ബ്ലൂപ്രിന്റ് (design) ആണ് — ഒരു വീടിന്റെ പ്ലാൻ പോലെ. ആ പ്ലാൻ ഉപയോഗിച്ച് ഉണ്ടാക്കുന്ന യഥാർത്ഥ വീടുകളാണ് ഒബ്ജക്റ്റുകൾ (instances). ഒരു പ്ലാനിൽ നിന്ന് പല വീടുകൾ ഉണ്ടാക്കാം — ഓരോന്നിനും അതിന്റേതായ നിറവും വിലാസവും ഉണ്ടാകും, പക്ഷേ എല്ലാം ഒരേ അടിസ്ഥാന ഘടന പിന്തുടരും.
ഒരു ലളിതമായ ക്ലാസ്
class Dog: pass my_dog = Dog() print(type(my_dog))
class Dog: ഒരു പുതിയ ബ്ലൂപ്രിന്റ് നിർവചിക്കുന്നു. Dog() എന്ന് വിളിക്കുമ്പോൾ, ആ ബ്ലൂപ്രിന്റിൽ നിന്ന് ഒരു യഥാർത്ഥ ഒബ്ജക്റ്റ് ഉണ്ടാകുന്നു.
`__init__` മെത്തേഡ്
ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുമ്പോൾ തന്നെ, അതിന് ചില ഡാറ്റ നൽകാൻ __init__ എന്ന പ്രത്യേക മെത്തേഡ് ഉപയോഗിക്കുന്നു. ഒബ്ജക്റ്റ് ഉണ്ടാകുന്ന ഉടനെ ഇത് സ്വയമേവ പ്രവർത്തിക്കും.
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
my_dog = Dog("Rex", 3)
print(my_dog.name)
print(my_dog.age)self എന്നത് "ഈ പ്രത്യേക ഒബ്ജക്റ്റ്" എന്നാണ് സൂചിപ്പിക്കുന്നത്. ക്ലാസിനുള്ളിലെ ഓരോ മെത്തേഡിന്റെയും ആദ്യ പാരാമീറ്റർ എപ്പോഴും self ആയിരിക്കണം — ഇത് പൈത്തൺ സ്വയമേവ കൈകാര്യം ചെയ്യുന്നു, Dog("Rex", 3) എന്ന് വിളിക്കുമ്പോൾ self-ന് വേണ്ടി ഒന്നും പ്രത്യേകം കൊടുക്കേണ്ട.
ഇൻസ്റ്റൻസ് വേരിയബിളുകൾ: ഓരോ ഒബ്ജക്റ്റിനും അതിന്റേതായ ഡാറ്റ
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
dog1 = Dog("Rex", 3)
dog2 = Dog("Bruno", 5)
print(dog1.name, dog1.age)
print(dog2.name, dog2.age)dog1, dog2 ഒരേ ബ്ലൂപ്രിന്റിൽ (Dog) നിന്ന് ഉണ്ടാക്കിയതാണെങ്കിലും, ഓരോന്നിനും അതിന്റേതായ സ്വതന്ത്രമായ name, age മൂല്യങ്ങളുണ്ട്.
മെത്തേഡുകൾ
ക്ലാസിനുള്ളിൽ നിർവചിക്കുന്ന ഫംഗ്ഷനുകളാണ് മെത്തേഡുകൾ — ഇവയ്ക്ക് self ഉപയോഗിച്ച് ആ ഒബ്ജക്റ്റിന്റെ സ്വന്തം ഡാറ്റ ആക്സസ് ചെയ്യാം.
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
def bark(self):
print(f"{self.name} says Woof!")
dog1 = Dog("Rex", 3)
dog1.bark()ക്ലാസ് വേരിയബിളുകൾ vs ഇൻസ്റ്റൻസ് വേരിയബിളുകൾ
__init__-നുള്ളിൽ self.xxx ആയി സെറ്റ് ചെയ്യുന്നത് ഇൻസ്റ്റൻസ് വേരിയബിൾ ആണ് — ഓരോ ഒബ്ജക്റ്റിനും വെവ്വേറെ. ക്ലാസിനുള്ളിൽ, __init__-ന് പുറത്ത് നേരിട്ട് എഴുതുന്നത് ക്ലാസ് വേരിയബിൾ ആണ് — എല്ലാ ഒബ്ജക്റ്റുകളും ഇത് പങ്കിടുന്നു.
class Dog:
species = "Canine" # ക്ലാസ് വേരിയബിൾ — എല്ലാ Dog ഒബ്ജക്റ്റുകൾക്കും പൊതുവായത്
def __init__(self, name):
self.name = name # ഇൻസ്റ്റൻസ് വേരിയബിൾ — ഓരോന്നിനും വെവ്വേറെ
dog1 = Dog("Rex")
dog2 = Dog("Bruno")
print(dog1.species, dog2.species)
print(dog1.name, dog2.name)യഥാർത്ഥ ജീവിത ഉദാഹരണം: ബാങ്ക് അക്കൗണ്ട്
class BankAccount:
def __init__(self, owner, balance=0):
self.owner = owner
self.balance = balance
def deposit(self, amount):
self.balance += amount
print(f"Deposited {amount}. New balance: {self.balance}")
def withdraw(self, amount):
if amount > self.balance:
print("Insufficient balance!")
else:
self.balance -= amount
print(f"Withdrew {amount}. New balance: {self.balance}")
account = BankAccount("Anu", 1000)
account.deposit(500)
account.withdraw(2000)
account.withdraw(300)മുൻ അധ്യായത്തിലെ unittest.TestCase ഓർക്കുന്നുണ്ടോ? class TestAdd(unittest.TestCase): എന്നത് കൃത്യമായി ഇതേ ക്ലാസ് സിന്റാക്സ് തന്നെയാണ് ഉപയോഗിച്ചത് — ഇപ്പോൾ അത് പൂർണ്ണമായി മനസ്സിലാകും.
സാധാരണ തുടക്കക്കാരുടെ തെറ്റുകൾ
- ഒരു മെത്തേഡിന്റെ ആദ്യ പാരാമീറ്ററായി
selfഎഴുതാൻ മറക്കുന്നു - ക്ലാസ് ഉപയോഗിക്കാൻ
Dog()എന്ന് ബ്രാക്കറ്റ് ഇടാൻ മറന്ന്,Dog(ബ്ലൂപ്രിന്റ് തന്നെ) ഒബ്ജക്റ്റ് ആണെന്ന് കരുതുന്നു - ക്ലാസ് വേരിയബിളും ഇൻസ്റ്റൻസ് വേരിയബിളും തമ്മിൽ മാറിപ്പോകുന്നു
ഈ അധ്യായത്തിന്റെ സംഗ്രഹം
- ക്ലാസ് (ബ്ലൂപ്രിന്റ്), ഒബ്ജക്റ്റ് (ഇൻസ്റ്റൻസ്) എന്നിവ തമ്മിലുള്ള വ്യത്യാസം മനസ്സിലാക്കി
__init__ഉപയോഗിച്ച് ഒബ്ജക്റ്റിന് പ്രാരംഭ ഡാറ്റ നൽകിselfഎന്താണെന്ന് പഠിച്ചു- ഇൻസ്റ്റൻസ് വേരിയബിളും ക്ലാസ് വേരിയബിളും തമ്മിലുള്ള വ്യത്യാസം കണ്ടു
- ഒരു ബാങ്ക് അക്കൗണ്ട് ക്ലാസ് ഉദാഹരണം ഉണ്ടാക്കി
വ്യായാമങ്ങൾ
name,subject,marksഎന്നിവയുള്ള ഒരുStudentക്ലാസ് ഉണ്ടാക്കി, ഒരുshow()മെത്തേഡ് ചേർത്ത് വിവരങ്ങൾ പ്രിന്റ് ചെയ്യുകStudentക്ലാസ് ഉപയോഗിച്ച് 2 വ്യത്യസ്ത വിദ്യാർത്ഥികളെ ഉണ്ടാക്കി, ഇരുവരുടെയും വിവരങ്ങൾ വെവ്വേറെ പ്രിന്റ് ചെയ്യുകlength,widthഎന്നിവയുള്ള ഒരുRectangleക്ലാസ് ഉണ്ടാക്കി, വിസ്തീർണ്ണം (length * width) കണക്കാക്കുന്ന ഒരുarea()മെത്തേഡ് ചേർക്കുക
Quiz & Self Assessment
അടുത്ത അധ്യായത്തിൽ, ഒരു ക്ലാസിന്റെ സവിശേഷതകൾ മറ്റൊരു ക്ലാസിലേക്ക് പകർന്നു നൽകുന്ന ഇൻഹെറിറ്റൻസും പോളിമോർഫിസവും നിങ്ങൾ പഠിക്കും.