ಪೈಥಾನ್‌ನ ಸೂಪರ್() ಮತ್ತು __init__() ವಿಧಾನಗಳನ್ನು ಅನ್ವೇಷಿಸಲಾಗುತ್ತಿದೆ

ಪೈಥಾನ್‌ನ ಸೂಪರ್ () ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುವುದು

ಪೈಥಾನ್‌ನ ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ಸೂಪರ್() ಫಂಕ್ಷನ್‌ನ ಬಳಕೆಯು ಆರಂಭಿಕರಿಗಾಗಿ ಸಾಮಾನ್ಯವಾಗಿ ಗೊಂದಲದ ಮೂಲವಾಗಿದೆ. ಈ ಶಕ್ತಿಯುತ ಕಾರ್ಯವನ್ನು ಪ್ರಾಥಮಿಕವಾಗಿ ಮೂಲ ವರ್ಗಗಳ __init__() ವಿಧಾನಗಳನ್ನು ಸರಿಯಾಗಿ ಕರೆಯಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಬಳಸಲಾಗುತ್ತದೆ, ಇದು ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಹುದಾದ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಕೋಡ್ ರಚನೆಯನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತದೆ.

ಈ ಲೇಖನದಲ್ಲಿ, Base.__init__() ಮತ್ತು super().__init__() ಅನ್ನು ಬಳಸುವ ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳನ್ನು ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ ಮತ್ತು ಸೂಪರ್() ಸಾಮಾನ್ಯವಾಗಿ ಆದ್ಯತೆಯ ವಿಧಾನ ಏಕೆ ಎಂದು ಅನ್ವೇಷಿಸುತ್ತೇವೆ. ಆಚರಣೆಯಲ್ಲಿ ಈ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ವಿವರಿಸಲು ನಾವು ಕೋಡ್ ಉದಾಹರಣೆಗಳನ್ನು ಸಹ ಒದಗಿಸುತ್ತೇವೆ.

ಆಜ್ಞೆ	ವಿವರಣೆ
Base.__init__(self)	ಮೂಲ ವರ್ಗದ __init__ ವಿಧಾನವನ್ನು ನೇರವಾಗಿ ಕರೆಯುತ್ತದೆ. ಮೂಲ ವರ್ಗವನ್ನು ಸರಿಯಾಗಿ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಬಳಸಲಾಗುತ್ತದೆ.
super(ChildB, self).__init__()	ಸೂಪರ್() ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಮೂಲ ವರ್ಗದ __init__ ವಿಧಾನವನ್ನು ಕರೆಯುತ್ತದೆ. ಮೂಲ ವರ್ಗಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲು ಇದು ಆದ್ಯತೆಯ ವಿಧಾನವಾಗಿದೆ.
print("Base created")	ಕನ್ಸೋಲ್‌ಗೆ ಸಂದೇಶವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. ಡೀಬಗ್ ಮಾಡಲು ಮತ್ತು ಮೂಲ ವರ್ಗವನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.
print("ChildA created")	ಕನ್ಸೋಲ್‌ಗೆ ಸಂದೇಶವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. ChildA ಅನ್ನು ರಚಿಸಲಾಗಿದೆ ಮತ್ತು ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.
print("ChildB created")	ಕನ್ಸೋಲ್‌ಗೆ ಸಂದೇಶವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. ಮಗುವನ್ನು ರಚಿಸಲಾಗಿದೆ ಮತ್ತು ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.
print("Derived class with Base.__init__")	Base.__init__ ಬಳಸಿಕೊಂಡು ಪಡೆದ ವರ್ಗವನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ ಎಂದು ಸೂಚಿಸುವ ಸಂದೇಶವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.
print("Derived class with super().__init__")	ಸೂಪರ್().__init__ ಬಳಸಿಕೊಂಡು ಪಡೆದ ವರ್ಗವನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ ಎಂದು ಸೂಚಿಸುವ ಸಂದೇಶವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.

ಪೈಥಾನ್‌ನ ಸೂಪರ್() ಬಳಕೆಯ ಆಳವಾದ ವಿವರಣೆ

ಮೇಲೆ ಒದಗಿಸಲಾದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಇದರ ಬಳಕೆಯನ್ನು ವಿವರಿಸುತ್ತವೆ ಮತ್ತು ವರ್ಗ ಶ್ರೇಣಿಯೊಳಗೆ ಮೂಲ ವರ್ಗಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲು ಪೈಥಾನ್‌ನಲ್ಲಿ. ಮೊದಲ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ನಾವು ಎಂಬ ಬೇಸ್ ವರ್ಗವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ ಒಂದು ಜೊತೆ __init__() ವರ್ಗದ ನಿದರ್ಶನವನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ "ಬೇಸ್ ರಚಿಸಲಾಗಿದೆ" ಎಂದು ಮುದ್ರಿಸುವ ವಿಧಾನ. ನಂತರ ನಾವು ಎರಡು ಪಡೆದ ವರ್ಗಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ, ಮತ್ತು . ರಲ್ಲಿ , ದಿ Base.__init__(self) ವಿಧಾನವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ತನ್ನದೇ ಆದ ರೀತಿಯಲ್ಲಿ ಕರೆಯಲಾಗುತ್ತದೆ ಮೂಲ ವರ್ಗವನ್ನು ಸರಿಯಾಗಿ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ವಿಧಾನ. ಈ ವಿಧಾನವು ಸರಳವಾಗಿದೆ ಆದರೆ ಬಹು ಮೂಲ ವರ್ಗಗಳು ಅಥವಾ ಸಂಕೀರ್ಣವಾದ ಆನುವಂಶಿಕ ರಚನೆಗಳು ಇದ್ದಲ್ಲಿ ತೊಡಕಾಗಿರಬಹುದು.

ರಲ್ಲಿ , ದಿ ಬದಲಿಗೆ ವಿಧಾನವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ದಿ ಪೈಥಾನ್‌ನಲ್ಲಿನ ಕಾರ್ಯವು ಬೇಸ್ ಕ್ಲಾಸ್ ವಿಧಾನಗಳನ್ನು ಕರೆಯಲು ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಮಾರ್ಗವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ಬಹು ಆನುವಂಶಿಕ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ. ವಿಧಾನ ರೆಸಲ್ಯೂಶನ್ ಕ್ರಮವನ್ನು (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__() ದೃಢವಾದ ವಸ್ತು-ಆಧಾರಿತ ಪೈಥಾನ್ ಕೋಡ್ ಬರೆಯಲು ಅತ್ಯಗತ್ಯ.