பைத்தானின் சூப்பர்() மற்றும் __init__() முறைகளை ஆராய்தல்

பைத்தானின் சூப்பர்() மற்றும் __init__() முறைகளை ஆராய்தல்
பைத்தானின் சூப்பர்() மற்றும் __init__() முறைகளை ஆராய்தல்

பைத்தானின் சூப்பர்() உடன் தொடங்குதல்

பைத்தானின் பொருள் சார்ந்த நிரலாக்கத்தில் சூப்பர்() செயல்பாட்டின் பயன்பாடு பெரும்பாலும் ஆரம்பநிலையாளர்களுக்கு குழப்பத்தை ஏற்படுத்துகிறது. இந்த சக்திவாய்ந்த செயல்பாடு முதன்மையாக அடிப்படை வகுப்புகளின் __init__() முறைகள் சரியாக அழைக்கப்படுவதை உறுதிசெய்யப் பயன்படுகிறது, மேலும் பராமரிக்கக்கூடிய மற்றும் அளவிடக்கூடிய குறியீடு கட்டமைப்பை எளிதாக்குகிறது.

இந்தக் கட்டுரையில், Base.__init__() மற்றும் super().__init__() ஆகியவற்றைப் பயன்படுத்துவதில் உள்ள வேறுபாடுகளை ஆராய்வோம், மேலும் super() ஏன் பொதுவாக விரும்பப்படும் அணுகுமுறை என்பதை ஆராய்வோம். இந்த கருத்துக்களை நடைமுறையில் விளக்குவதற்கு குறியீடு உதாரணங்களையும் வழங்குவோம்.

கட்டளை விளக்கம்
Base.__init__(self) அடிப்படை வகுப்பின் __init__ முறையை நேரடியாக அழைக்கிறது. அடிப்படை வகுப்பு சரியாக துவக்கப்படுவதை உறுதிசெய்யப் பயன்படுகிறது.
super(ChildB, self).__init__() சூப்பர்() செயல்பாட்டைப் பயன்படுத்தி அடிப்படை வகுப்பின் __init__ முறையை அழைக்கிறது. அடிப்படை வகுப்புகளை துவக்குவதற்கு இதுவே விருப்பமான முறையாகும்.
print("Base created") கன்சோலில் ஒரு செய்தியை அச்சிடுகிறது. பிழைத்திருத்தம் மற்றும் அடிப்படை வகுப்பு துவக்கப்பட்டதா என்பதை உறுதிப்படுத்த பயன்படுகிறது.
print("ChildA created") கன்சோலில் ஒரு செய்தியை அச்சிடுகிறது. ChildA உருவாக்கப்பட்டது மற்றும் துவக்கப்பட்டது என்பதை உறுதிப்படுத்த பயன்படுகிறது.
print("ChildB created") கன்சோலில் ஒரு செய்தியை அச்சிடுகிறது. ChildB உருவாக்கப்பட்டது மற்றும் துவக்கப்பட்டது என்பதை உறுதிப்படுத்த பயன்படுகிறது.
print("Derived class with Base.__init__") Base.__init__ ஐப் பயன்படுத்தி பெறப்பட்ட வகுப்பு துவக்கப்பட்டதைக் குறிக்கும் செய்தியை அச்சிடுகிறது.
print("Derived class with super().__init__") Super().__init__ஐப் பயன்படுத்தி பெறப்பட்ட வகுப்பு துவக்கப்பட்டதைக் குறிக்கும் செய்தியை அச்சிடுகிறது.

பைத்தானின் சூப்பர்() பயன்பாட்டின் ஆழமான விளக்கம்

மேலே கொடுக்கப்பட்ட ஸ்கிரிப்ட்களின் பயன்பாட்டை விளக்குகிறது super() மற்றும் Base.__init__() ஒரு வர்க்க படிநிலைக்குள் அடிப்படை வகுப்புகளை துவக்க பைத்தானில். முதல் ஸ்கிரிப்ட்டில், அடிப்படை வகுப்பை வரையறுக்கிறோம் Base ஒரு உடன் __init__() வகுப்பின் ஒரு நிகழ்வு துவக்கப்படும் போது "அடிப்படை உருவாக்கப்பட்டது" என்று அச்சிடும் முறை. பின்னர் இரண்டு பெறப்பட்ட வகுப்புகளை வரையறுக்கிறோம், ChildA மற்றும் ChildB. இல் ChildA, தி Base.__init__(self) முறை வெளிப்படையாக அதன் சொந்த அழைக்கப்படுகிறது __init__() அடிப்படை வகுப்பு சரியாக துவக்கப்படுவதை உறுதி செய்வதற்கான முறை. இந்த அணுகுமுறை நேரடியானது ஆனால் பல அடிப்படை வகுப்புகள் அல்லது சிக்கலான பரம்பரை கட்டமைப்புகள் இருந்தால் சிக்கலானதாக இருக்கும்.

இல் ChildB, தி super(ChildB, self).__init__() முறை பதிலாக பயன்படுத்தப்படுகிறது. தி super() பைத்தானில் உள்ள செயல்பாடு என்பது அடிப்படை வகுப்பு முறைகளை அழைப்பதற்கு மிகவும் நெகிழ்வான மற்றும் பராமரிக்கக்கூடிய வழியாகும், குறிப்பாக பல மரபுவழி சூழ்நிலைகளில். முறை தெளிவுத்திறன் வரிசையை (MRO) பின்பற்றி, சரியான வரிசையில் அழைக்கப்படும் முறையை இது தானாகவே தீர்க்கிறது. இது குறியீட்டை எளிமையாக்குவது மட்டுமல்லாமல், வர்க்கப் படிநிலையில் ஏற்படும் மாற்றங்களுக்கு ஏற்றவாறு மேலும் வலுவாகவும் மாற்றியமைக்கவும் செய்கிறது. இரண்டாவது ஸ்கிரிப்ட் நேரடியாகப் பயன்படுத்துவதை ஒப்பிடுவதன் மூலம் இந்தக் கருத்துகளை மேலும் விரிவுபடுத்துகிறது Base.__init__() மற்றும் இந்த super() செயல்பாடு, ஒவ்வொரு முறையும் துவக்க செயல்முறையை எவ்வாறு பாதிக்கிறது என்பதை நிரூபிக்கிறது.

வகுப்பு மரபுரிமையில் பைத்தானின் சூப்பர்() ஐப் புரிந்துகொள்வது

பைதான் - அடிப்படை வகுப்பை அழைக்க சூப்பர்() ஐப் பயன்படுத்துகிறது __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()

அடிப்படை வகுப்பு துவக்கத்தில் உள்ள வேறுபாடுகளை ஆராய்தல்

பைதான் - தளத்தை ஒப்பிடுதல்.__init__() vs super().__init__()

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() முறை தெளிவுத்திறன் வரிசையின் (MRO) படி அனைத்து அடிப்படை வகுப்புகளும் சரியாக துவக்கப்படுவதை உறுதி செய்கிறது. ஒரு அடிப்படை வகுப்பை பலமுறை துவக்கலாம் அல்லது இல்லாமலும் இருக்கும் சாத்தியமான சிக்கல்களை இது தடுக்கிறது.

குறியீட்டின் மேம்பட்ட வாசிப்புத்திறன் மற்றும் பராமரிக்கக்கூடிய தன்மை மற்றொரு முக்கியமான அம்சமாகும். பயன்படுத்தும் போது Base.__init__(), புரோகிராமர் அடிப்படை வகுப்பிற்கு வெளிப்படையாக பெயரிட வேண்டும், இதனால் குறியீட்டை நெகிழ்வுத்தன்மை குறைவாக இருக்கும். அடிப்படை வகுப்பின் பெயர் மாறினால் அல்லது பரம்பரை அமைப்பு உருவாகினால், ஒவ்வொரு நேரடி அழைப்பும் Base.__init__() புதுப்பிக்கப்பட வேண்டும். மாறாக, super() அடிப்படை வகுப்பின் பெயரை சுருக்கி, குறியீட்டை மாற்றங்களுக்கு ஏற்றவாறு மாற்றுகிறது. பொருள் சார்ந்த நிரலாக்கத்தில் அடிப்படையான பாலிமார்பிசம் மற்றும் என்காப்சுலேஷன் கொள்கைகளுடன் இந்த சுருக்கம் ஒத்துப்போகிறது.

பைத்தானின் சூப்பர்() பற்றிய பொதுவான கேள்விகள் மற்றும் பதில்கள்

  1. என்ன super() பைத்தானில்?
  2. super() ஒரு உள்ளமைக்கப்பட்ட செயல்பாடாகும், இது ஒரு பெற்றோர் அல்லது உடன்பிறந்த வகுப்பிலிருந்து முறைகளை அழைக்க உங்களை அனுமதிக்கிறது, பரம்பரை படிநிலையில் சரியான துவக்கம் மற்றும் முறை தீர்மானத்தை உறுதி செய்கிறது.
  3. எப்படி செய்கிறது super() இருந்து வேறுபடுகின்றன Base.__init__()?
  4. super() MRO அடிப்படையில் அழைக்கப்படும் முறையை மாறும் வகையில் தீர்க்கிறது Base.__init__() ஒரு குறிப்பிட்ட அடிப்படை வகுப்பு முறையை நேரடியாக அழைக்கிறது, இது குறைந்த நெகிழ்வுத்தன்மை கொண்டது.
  5. ஏன் super() பல பரம்பரையில் விரும்பப்படுகிறதா?
  6. பல பரம்பரையில், super() அனைத்து அடிப்படை வகுப்புகளும் MRO இன் படி சரியாக துவக்கப்படுவதை உறுதிசெய்கிறது, நகல் அல்லது விடுபட்ட துவக்கங்களைத் தவிர்க்கிறது.
  7. முடியும் super() வெளியே பயன்படுத்தப்படும் __init__()?
  8. ஆம், super() பெற்றோர் அல்லது உடன்பிறந்த வகுப்பினரிடமிருந்து எந்த முறையையும் அழைப்பதற்குப் பயன்படுத்தலாம், மட்டுமின்றி __init__().
  9. முறை தீர்மானம் ஒழுங்கு (MRO) என்றால் என்ன?
  10. MRO என்பது வகுப்புகளின் படிநிலையில் உள்ள முறைகளை பைதான் தேடும் வரிசையாகும். இது C3 லீனியரைசேஷன் அல்காரிதம் மூலம் தீர்மானிக்கப்படுகிறது.
  11. ஒரு வகுப்பின் எம்ஆர்ஓவை எப்படிப் பார்க்கிறீர்கள்?
  12. நீங்கள் MRO ஐப் பயன்படுத்தி பார்க்கலாம் ClassName.mro() முறை அல்லது ClassName.__mro__ பண்பு.
  13. நீங்கள் பயன்படுத்தாவிட்டால் என்ன நடக்கும் super() பெறப்பட்ட வகுப்பில்?
  14. நீங்கள் பயன்படுத்தவில்லை என்றால் super(), அடிப்படை வகுப்பு சரியாக துவக்கப்படாமல் இருக்கலாம், இது சாத்தியமான பிழைகள் அல்லது எதிர்பாராத நடத்தைக்கு வழிவகுக்கும்.
  15. பயன்படுத்த இயலுமா super() பைதான் 2 இல்?
  16. ஆம், ஆனால் தொடரியல் வேறுபட்டது. பைதான் 2 இல், நீங்கள் பயன்படுத்துகிறீர்கள் super(ClassName, self).method(), அதேசமயம் பைதான் 3 இல், நீங்கள் வெறுமனே பயன்படுத்துகிறீர்கள் super().method().

முக்கிய கருத்துகளை மூடுதல்

பயன்படுத்தி super() பைத்தானில் அடிப்படை வகுப்புகளின் சரியான துவக்கத்தை உறுதி செய்வது மட்டுமின்றி, குறியீடு நெகிழ்வுத்தன்மை மற்றும் பராமரிப்பையும் மேம்படுத்துகிறது. அடிப்படை வகுப்பு முறைகளுக்கான நேரடி அழைப்புகள் சிக்கலானதாகவும், பிழை ஏற்படக்கூடியதாகவும் இருக்கும் பல பரம்பரை சூழ்நிலைகளில் இது மிகவும் பயனுள்ளதாக இருக்கும். அடிப்படை வகுப்புப் பெயர்களை சுருக்கி, super() தூய்மையான மற்றும் மேலும் மாற்றியமைக்கக்கூடிய குறியீட்டை அனுமதிக்கிறது. நுணுக்கங்களைப் புரிந்துகொள்வது super() எதிராக Base.__init__() வலுவான பொருள் சார்ந்த பைதான் குறியீட்டை எழுதுவதற்கு அவசியம்.