પાયથોનની સુપર() અને __init__() પદ્ધતિઓની શોધખોળ

પાયથોનના સુપર() સાથે પ્રારંભ કરવું

પાયથોનના ઑબ્જેક્ટ-ઓરિએન્ટેડ પ્રોગ્રામિંગમાં સુપર() ફંક્શનનો ઉપયોગ ઘણીવાર નવા નિશાળીયા માટે મૂંઝવણનું કારણ બને છે. આ પાવરફુલ ફંક્શનનો ઉપયોગ મુખ્યત્વે એ સુનિશ્ચિત કરવા માટે થાય છે કે બેઝ ક્લાસની __init__() પદ્ધતિઓ યોગ્ય રીતે કહેવાય છે, વધુ જાળવણી કરી શકાય તેવી અને માપી શકાય તેવી કોડ રચનાની સુવિધા આપે છે.

આ લેખમાં, અમે Base.__init__() અને super().__init__() નો ઉપયોગ કરવા વચ્ચેના તફાવતોની તપાસ કરીશું, અને શા માટે super() સામાન્ય રીતે પસંદગીનો અભિગમ છે તેનું અન્વેષણ કરીશું. વ્યવહારમાં આ વિભાવનાઓને સમજાવવા માટે અમે કોડ ઉદાહરણો પણ પ્રદાન કરીશું.

આદેશ	વર્ણન
Base.__init__(self)	બેઝ ક્લાસની __init__ પદ્ધતિને સીધો કૉલ કરે છે. આધાર વર્ગ યોગ્ય રીતે પ્રારંભ થયેલ છે તેની ખાતરી કરવા માટે વપરાય છે.
super(ChildB, self).__init__()	સુપર() ફંક્શનનો ઉપયોગ કરીને બેઝ ક્લાસની __init__ પદ્ધતિને કૉલ કરે છે. આધાર વર્ગો શરૂ કરવા માટેની આ પસંદગીની પદ્ધતિ છે.
print("Base created")	કન્સોલ પર સંદેશ છાપે છે. ડિબગીંગ અને પુષ્ટિ કરવા માટે વપરાય છે કે બેઝ ક્લાસ આરંભ કરવામાં આવ્યો છે.
print("ChildA created")	કન્સોલ પર સંદેશ છાપે છે. ચાઇલ્ડએ બનાવવામાં અને પ્રારંભ કરવામાં આવ્યો છે તેની પુષ્ટિ કરવા માટે ઉપયોગ થાય છે.
print("ChildB created")	કન્સોલ પર સંદેશ છાપે છે. ચાઇલ્ડબી બનાવવામાં અને પ્રારંભ કરવામાં આવ્યો છે તેની પુષ્ટિ કરવા માટે ઉપયોગ થાય છે.
print("Derived class with Base.__init__")	Base.__init__ નો ઉપયોગ કરીને વ્યુત્પન્ન વર્ગ શરૂ કરવામાં આવ્યો હતો તે દર્શાવતો સંદેશ છાપે છે.
print("Derived class with super().__init__")	સુપર().__init__ નો ઉપયોગ કરીને વ્યુત્પન્ન વર્ગની શરૂઆત કરવામાં આવી હતી તે દર્શાવતો સંદેશ છાપે છે.

પાયથોનના સુપર() ઉપયોગની ઊંડાણપૂર્વકની સમજૂતી

ઉપર આપવામાં આવેલ સ્ક્રિપ્ટો ઉપયોગ સમજાવે છે અને વર્ગ પદાનુક્રમમાં બેઝ ક્લાસ શરૂ કરવા માટે પાયથોનમાં. પ્રથમ સ્ક્રિપ્ટમાં, અમે બેઝ ક્લાસને વ્યાખ્યાયિત કરીએ છીએ જેને કહેવાય છે એક સાથે __init__() પદ્ધતિ કે જે "બેઝ બનાવેલ" છાપે છે જ્યારે વર્ગનો દાખલો શરૂ થાય છે. પછી આપણે બે વ્યુત્પન્ન વર્ગોને વ્યાખ્યાયિત કરીએ છીએ, અને . માં , ધ Base.__init__(self) પદ્ધતિ સ્પષ્ટપણે તેની પોતાની અંદર કહેવામાં આવે છે આધાર વર્ગ યોગ્ય રીતે પ્રારંભ થયેલ છે તેની ખાતરી કરવા માટેની પદ્ધતિ. આ અભિગમ સીધો છે પરંતુ જો બહુવિધ આધાર વર્ગો અથવા જટિલ વારસાગત માળખાં હોય તો તે બોજારૂપ હોઈ શકે છે.

માં , ધ તેના બદલે પદ્ધતિનો ઉપયોગ થાય છે. આ Python માં ફંક્શન એ બેઝ ક્લાસ મેથડને કૉલ કરવા માટે વધુ લવચીક અને જાળવી શકાય તેવી રીત છે, ખાસ કરીને બહુવિધ વારસાગત દૃશ્યોમાં. તે મેથડ રિઝોલ્યુશન ઓર્ડર (MRO) ને અનુસરીને, યોગ્ય ક્રમમાં કૉલ કરવાની પદ્ધતિને આપમેળે ઉકેલે છે. આ માત્ર કોડને સરળ બનાવતું નથી પણ તેને વર્ગ પદાનુક્રમમાં ફેરફારો માટે વધુ મજબૂત અને અનુકૂલનક્ષમ બનાવે છે. બીજી સ્ક્રિપ્ટના પ્રત્યક્ષ ઉપયોગની તુલના કરીને આ વિભાવનાઓને વધુ વિસ્તૃત કરે છે Base.__init__() અને કાર્ય, દરેક પદ્ધતિ આરંભ પ્રક્રિયાને કેવી રીતે અસર કરે છે તે દર્શાવે છે.

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() સુનિશ્ચિત કરે છે કે મેથડ રિઝોલ્યુશન ઓર્ડર (MRO) અનુસાર તમામ બેઝ ક્લાસ યોગ્ય રીતે શરૂ થયા છે. આ સંભવિત સમસ્યાઓને અટકાવે છે જ્યાં બેઝ ક્લાસ ઘણી વખત શરૂ થઈ શકે છે અથવા બિલકુલ નહીં.

અન્ય નિર્ણાયક પાસું કોડની સુધારેલ વાંચનક્ષમતા અને જાળવણીક્ષમતા છે. ઉપયોગ કરતી વખતે , પ્રોગ્રામરે સ્પષ્ટપણે બેઝ ક્લાસનું નામ આપવું જોઈએ, જે કોડને ઓછો લવચીક બનાવે છે. જો બેઝ ક્લાસનું નામ બદલાય છે અથવા વારસાનું માળખું વિકસિત થાય છે, તો દરેક ડાયરેક્ટ કોલ અપડેટ કરવાની જરૂર છે. વિપરીત, બેઝ ક્લાસ નામને અમૂર્ત કરે છે, કોડને ફેરફારો માટે વધુ સ્વીકાર્ય બનાવે છે. આ એબ્સ્ટ્રેક્શન પોલીમોર્ફિઝમ અને એન્કેપ્સ્યુલેશનના સિદ્ધાંતો સાથે પણ ગોઠવે છે, જે ઑબ્જેક્ટ-ઓરિએન્ટેડ પ્રોગ્રામિંગમાં મૂળભૂત છે.

ઉપયોગ કરીને પાયથોનમાં માત્ર બેઝ ક્લાસના યોગ્ય આરંભની ખાતરી જ નહીં પરંતુ કોડની સુગમતા અને જાળવણીક્ષમતા પણ વધારે છે. તે બહુવિધ વારસાગત પરિસ્થિતિઓમાં ખાસ કરીને ફાયદાકારક છે જ્યાં બેઝ ક્લાસ પદ્ધતિઓ પર ડાયરેક્ટ કૉલ્સ બોજારૂપ અને ભૂલ-સંભવિત બની શકે છે. આધાર વર્ગના નામોને અમૂર્ત કરીને, ક્લીનર અને વધુ સ્વીકાર્ય કોડ માટે પરવાનગી આપે છે. ની ઘોંઘાટ સમજવી વિરુદ્ધ Base.__init__() મજબૂત ઑબ્જેક્ટ-ઓરિએન્ટેડ પાયથોન કોડ લખવા માટે જરૂરી છે.