പൈത്തണിൻ്റെ സൂപ്പർ(), __init__() രീതികൾ പര്യവേക്ഷണം ചെയ്യുന്നു

പൈത്തണിൻ്റെ സൂപ്പർ() ഉപയോഗിച്ച് ആരംഭിക്കുന്നു

പൈത്തണിൻ്റെ ഒബ്ജക്റ്റ് ഓറിയൻ്റഡ് പ്രോഗ്രാമിംഗിൽ സൂപ്പർ() ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നത് തുടക്കക്കാർക്ക് പലപ്പോഴും ആശയക്കുഴപ്പം ഉണ്ടാക്കുന്നു. അടിസ്ഥാന ക്ലാസുകളുടെ __init__() രീതികൾ ശരിയായി വിളിക്കപ്പെടുന്നുവെന്ന് ഉറപ്പാക്കാൻ ഈ ശക്തമായ ഫംഗ്ഷൻ പ്രാഥമികമായി ഉപയോഗിക്കുന്നു, ഇത് കൂടുതൽ പരിപാലിക്കാവുന്നതും അളക്കാവുന്നതുമായ കോഡ് ഘടനയെ സുഗമമാക്കുന്നു.

ഈ ലേഖനത്തിൽ, Base.__init__() ഉം super().__init__()ഉപയോഗിക്കുന്നതും തമ്മിലുള്ള വ്യത്യാസങ്ങൾ ഞങ്ങൾ പരിശോധിക്കും, ഒപ്പം super() പൊതുവെ തിരഞ്ഞെടുക്കപ്പെട്ട സമീപനം എന്തുകൊണ്ടാണെന്ന് പര്യവേക്ഷണം ചെയ്യും. ഈ ആശയങ്ങൾ പ്രായോഗികമായി ചിത്രീകരിക്കുന്നതിന് ഞങ്ങൾ കോഡ് ഉദാഹരണങ്ങളും നൽകും.

പൈത്തണിൻ്റെ സൂപ്പർ() ഉപയോഗത്തിൻ്റെ ആഴത്തിലുള്ള വിശദീകരണം

മുകളിൽ നൽകിയിരിക്കുന്ന സ്ക്രിപ്റ്റുകൾ ഉപയോഗത്തെ വ്യക്തമാക്കുന്നു super() ഒപ്പം Base.__init__() ഒരു ക്ലാസ് ശ്രേണിയിൽ അടിസ്ഥാന ക്ലാസുകൾ ആരംഭിക്കുന്നതിന് പൈത്തണിൽ. ആദ്യ സ്ക്രിപ്റ്റിൽ, ഞങ്ങൾ ഒരു അടിസ്ഥാന ക്ലാസ് നിർവചിക്കുന്നു Base ഒരു കൂടെ __init__() ക്ലാസിൻ്റെ ഒരു ഉദാഹരണം ആരംഭിക്കുമ്പോൾ "ബേസ് സൃഷ്‌ടിച്ചത്" എന്ന് പ്രിൻ്റ് ചെയ്യുന്ന രീതി. ഞങ്ങൾ രണ്ട് ഡിറൈവ്ഡ് ക്ലാസുകൾ നിർവചിക്കുന്നു, ChildA ഒപ്പം ChildB. ഇൻ ChildA, ദി Base.__init__(self) രീതി വ്യക്തമായി സ്വന്തം ഉള്ളിൽ വിളിക്കുന്നു __init__() അടിസ്ഥാന ക്ലാസ് ശരിയായി ആരംഭിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുന്നതിനുള്ള രീതി. ഈ സമീപനം ലളിതമാണ്, എന്നാൽ ഒന്നിലധികം അടിസ്ഥാന ക്ലാസുകളോ സങ്കീർണ്ണമായ പാരമ്പര്യ ഘടനകളോ ഉണ്ടെങ്കിൽ അത് ബുദ്ധിമുട്ടായിരിക്കും.

ഇൻ ChildB, ദി super(ChildB, self).__init__() പകരം രീതി ഉപയോഗിക്കുന്നു. ദി super() പൈത്തണിലെ ഫംഗ്‌ഷൻ ബേസ് ക്ലാസ് രീതികളെ വിളിക്കുന്നതിനുള്ള കൂടുതൽ വഴക്കമുള്ളതും പരിപാലിക്കാവുന്നതുമായ മാർഗമാണ്, പ്രത്യേകിച്ച് ഒന്നിലധികം പാരമ്പര്യ സാഹചര്യങ്ങളിൽ. മെത്തേഡ് റെസലൂഷൻ ഓർഡർ (എംആർഒ) പിന്തുടർന്ന് ശരിയായ ക്രമത്തിൽ വിളിക്കേണ്ട രീതി ഇത് യാന്ത്രികമായി പരിഹരിക്കുന്നു. ഇത് കോഡ് ലളിതമാക്കുക മാത്രമല്ല, ക്ലാസ് ശ്രേണിയിലെ മാറ്റങ്ങൾക്ക് കൂടുതൽ കരുത്തുറ്റതും അനുയോജ്യവുമാക്കുകയും ചെയ്യുന്നു. നേരിട്ടുള്ള ഉപയോഗത്തെ താരതമ്യം ചെയ്തുകൊണ്ട് രണ്ടാമത്തെ സ്ക്രിപ്റ്റ് ഈ ആശയങ്ങളെ കൂടുതൽ വിശദീകരിക്കുന്നു Base.__init__() കൂടാതെ super() ഫംഗ്ഷൻ, ഓരോ രീതിയും പ്രാരംഭ പ്രക്രിയയെ എങ്ങനെ ബാധിക്കുന്നുവെന്ന് കാണിക്കുന്നു.

class Base(object):
    def __init__(self):
        print("Base created")

class ChildA(Base):
    def __init__(self):
        Base.__init__(self)
        print("ChildA created")

class ChildB(Base):
    def __init__(self):
        super(ChildB, self).__init__()
        print("ChildB created")

ChildA()
ChildB()

class Base:
    def __init__(self):
        print("Base class initialized")

class DerivedWithBaseInit(Base):
    def __init__(self):
        Base.__init__(self)
        print("Derived class with Base.__init__")

class DerivedWithSuperInit(Base):
    def __init__(self):
        super().__init__()
        print("Derived class with super().__init__")

print("Creating DerivedWithBaseInit:")
derived1 = DerivedWithBaseInit()

print("Creating DerivedWithSuperInit:")
derived2 = DerivedWithSuperInit()

പൈത്തണിൻ്റെ സൂപ്പർ() ഫംഗ്ഷനിലേക്ക് ഡീപ്പർ ഡൈവിംഗ്

മുമ്പത്തെ വിശദീകരണങ്ങൾ അടിസ്ഥാന ഉപയോഗത്തിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുമ്പോൾ super() ഒപ്പം Base.__init__(), ഉപയോഗിക്കുന്നതിൻ്റെ ചില വിപുലമായ വശങ്ങളും നേട്ടങ്ങളും മനസ്സിലാക്കേണ്ടത് പ്രധാനമാണ് super(). ഒന്നിലധികം അനന്തരാവകാശങ്ങളുമായുള്ള അതിൻ്റെ അനുയോജ്യതയാണ് ഒരു പ്രധാന നേട്ടം. സങ്കീർണ്ണമായ ഒരു ക്ലാസ് ശ്രേണിയിൽ, ഒരു ക്ലാസ് ഒന്നിലധികം അടിസ്ഥാന ക്ലാസുകളിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ചേക്കാം super() രീതി റെസലൂഷൻ ഓർഡർ (എംആർഒ) അനുസരിച്ച് എല്ലാ അടിസ്ഥാന ക്ലാസുകളും ശരിയായി ആരംഭിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുന്നു. ഒരു ബേസ് ക്ലാസ് ഒന്നിലധികം തവണ ആരംഭിക്കുന്നതോ അല്ലാത്തതോ ആയ പ്രശ്‌നങ്ങളെ ഇത് തടയുന്നു.

കോഡിൻ്റെ മെച്ചപ്പെട്ട വായനാക്ഷമതയും പരിപാലനക്ഷമതയുമാണ് മറ്റൊരു നിർണായക വശം. ഉപയോഗിക്കുമ്പോൾ Base.__init__(), പ്രോഗ്രാമർ അടിസ്ഥാന ക്ലാസിന് വ്യക്തമായി പേര് നൽകണം, ഇത് കോഡിന് വഴക്കം കുറയ്ക്കും. അടിസ്ഥാന ക്ലാസ്സിൻ്റെ പേര് മാറുകയോ അല്ലെങ്കിൽ അനന്തരാവകാശ ഘടന വികസിക്കുകയോ ചെയ്താൽ, എല്ലാ നേരിട്ടുള്ള കോളുകളും Base.__init__() അപ്ഡേറ്റ് ചെയ്യേണ്ടതുണ്ട്. വിപരീതമായി, super() അടിസ്ഥാന ക്ലാസ് നാമം സംഗ്രഹിക്കുന്നു, കോഡ് മാറ്റങ്ങൾക്ക് കൂടുതൽ അനുയോജ്യമാക്കുന്നു. ഈ അമൂർത്തീകരണം ഒബ്‌ജക്റ്റ് ഓറിയൻ്റഡ് പ്രോഗ്രാമിംഗിൽ അടിസ്ഥാനപരമായ പോളിമോർഫിസത്തിൻ്റെയും എൻക്യാപ്‌സുലേഷൻ്റെയും തത്വങ്ങളുമായി പൊരുത്തപ്പെടുന്നു.