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

ചോദ്യം 1 / 4
ഒരു ക്ലാസും ഒരു ഒബ്ജക്റ്റും തമ്മിലുള്ള വ്യത്യാസം എന്താണ്?

അടുത്ത അധ്യായത്തിൽ, ഒരു ക്ലാസിന്റെ സവിശേഷതകൾ മറ്റൊരു ക്ലാസിലേക്ക് പകർന്നു നൽകുന്ന ഇൻഹെറിറ്റൻസും പോളിമോർഫിസവും നിങ്ങൾ പഠിക്കും.