ਪਾਈਥਨ ਦੇ ਸੁਪਰ () ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰਨਾ
ਪਾਈਥਨ ਦੇ ਆਬਜੈਕਟ-ਓਰੀਐਂਟਡ ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ ਸੁਪਰ() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਅਕਸਰ ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਲਈ ਉਲਝਣ ਦਾ ਇੱਕ ਸਰੋਤ ਹੁੰਦੀ ਹੈ। ਇਹ ਸ਼ਕਤੀਸ਼ਾਲੀ ਫੰਕਸ਼ਨ ਮੁੱਖ ਤੌਰ 'ਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਕਿ ਬੇਸ ਕਲਾਸਾਂ ਦੀਆਂ __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__") | ਇੱਕ ਸੁਨੇਹਾ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ Derived ਕਲਾਸ ਨੂੰ Base.__init__ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸ਼ੁਰੂ ਕੀਤਾ ਗਿਆ ਸੀ। |
| print("Derived class with super().__init__") | ਇੱਕ ਸੁਨੇਹਾ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਡਿਰਾਈਵਡ ਕਲਾਸ ਸੁਪਰ().__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__() ਬਨਾਮ ਸੁਪਰ().__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() ਬੇਸ ਕਲਾਸ ਦੇ ਨਾਮ ਨੂੰ ਐਬਸਟਰੈਕਟ ਕਰਦਾ ਹੈ, ਕੋਡ ਨੂੰ ਬਦਲਾਵਾਂ ਲਈ ਵਧੇਰੇ ਅਨੁਕੂਲ ਬਣਾਉਂਦਾ ਹੈ। ਇਹ ਐਬਸਟਰੈਕਸ਼ਨ ਪੋਲੀਮੋਰਫਿਜ਼ਮ ਅਤੇ ਇਨਕੈਪਸੂਲੇਸ਼ਨ ਦੇ ਸਿਧਾਂਤਾਂ ਨਾਲ ਵੀ ਮੇਲ ਖਾਂਦਾ ਹੈ, ਜੋ ਆਬਜੈਕਟ-ਓਰੀਐਂਟਡ ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ ਬੁਨਿਆਦੀ ਹਨ।
ਪਾਈਥਨ ਦੇ ਸੁਪਰ () ਬਾਰੇ ਆਮ ਸਵਾਲ ਅਤੇ ਜਵਾਬ
- ਕੀ ਹੈ super() ਪਾਈਥਨ ਵਿੱਚ?
- super() ਇੱਕ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਇੱਕ ਮਾਤਾ ਜਾਂ ਪਿਤਾ ਜਾਂ ਭੈਣ-ਭਰਾ ਕਲਾਸ ਤੋਂ ਵਿਧੀਆਂ ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਇੱਕ ਵਿਰਾਸਤ ਲੜੀ ਵਿੱਚ ਸਹੀ ਸ਼ੁਰੂਆਤੀ ਅਤੇ ਵਿਧੀ ਦੇ ਹੱਲ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ।
- ਕਿਵੇਂ ਕਰਦਾ ਹੈ super() ਤੋਂ ਵੱਖਰਾ ਹੈ Base.__init__()?
- super() ਐਮਆਰਓ ਦੇ ਅਧਾਰ ਤੇ ਕਾਲ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਢੰਗ ਨੂੰ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਹੱਲ ਕਰਦਾ ਹੈ, ਜਦੋਂ ਕਿ Base.__init__() ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਇੱਕ ਖਾਸ ਬੇਸ ਕਲਾਸ ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ, ਜੋ ਘੱਟ ਲਚਕਦਾਰ ਹੁੰਦਾ ਹੈ।
- ਕਿਉਂ ਹੈ super() ਮਲਟੀਪਲ ਵਿਰਾਸਤ ਵਿੱਚ ਤਰਜੀਹ?
- ਬਹੁ ਵਿਰਾਸਤ ਵਿੱਚ, super() ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਸਾਰੀਆਂ ਬੇਸ ਕਲਾਸਾਂ ਨੂੰ ਐਮਆਰਓ ਦੇ ਅਨੁਸਾਰ ਸਹੀ ਢੰਗ ਨਾਲ ਸ਼ੁਰੂ ਕੀਤਾ ਗਿਆ ਹੈ, ਡੁਪਲੀਕੇਟ ਜਾਂ ਗੁੰਮ ਸ਼ੁਰੂਆਤੀਕਰਣਾਂ ਤੋਂ ਬਚਦੇ ਹੋਏ।
- ਸਕਦਾ ਹੈ super() ਦੇ ਬਾਹਰ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ __init__()?
- ਹਾਂ, super() ਦੀ ਵਰਤੋਂ ਮਾਤਾ-ਪਿਤਾ ਜਾਂ ਭੈਣ-ਭਰਾ ਕਲਾਸ ਤੋਂ ਕਿਸੇ ਵੀ ਢੰਗ ਨੂੰ ਕਾਲ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਨਾ ਕਿ ਸਿਰਫ਼ __init__().
- ਵਿਧੀ ਰੈਜ਼ੋਲੂਸ਼ਨ ਆਰਡਰ (MRO) ਕੀ ਹੈ?
- MRO ਉਹ ਕ੍ਰਮ ਹੈ ਜਿਸ ਵਿੱਚ ਪਾਈਥਨ ਕਲਾਸਾਂ ਦੀ ਲੜੀ ਵਿੱਚ ਢੰਗਾਂ ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ। ਇਹ C3 ਲੀਨੀਅਰਾਈਜ਼ੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
- ਤੁਸੀਂ ਕਲਾਸ ਦੇ MRO ਨੂੰ ਕਿਵੇਂ ਦੇਖਦੇ ਹੋ?
- ਤੁਸੀਂ MRO ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦੇਖ ਸਕਦੇ ਹੋ ClassName.mro() ਵਿਧੀ ਜਾਂ ClassName.__mro__ ਵਿਸ਼ੇਸ਼ਤਾ.
- ਜੇਕਰ ਤੁਸੀਂ ਨਹੀਂ ਵਰਤਦੇ ਤਾਂ ਕੀ ਹੁੰਦਾ ਹੈ super() ਇੱਕ ਪ੍ਰਾਪਤ ਕਲਾਸ ਵਿੱਚ?
- ਜੇਕਰ ਤੁਸੀਂ ਨਹੀਂ ਵਰਤਦੇ super(), ਬੇਸ ਕਲਾਸ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸ਼ੁਰੂ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਸੰਭਾਵੀ ਤਰੁੱਟੀਆਂ ਜਾਂ ਅਚਾਨਕ ਵਿਵਹਾਰ ਹੋ ਸਕਦਾ ਹੈ।
- ਇਸ ਨੂੰ ਵਰਤਣ ਲਈ ਸੰਭਵ ਹੈ super() ਪਾਈਥਨ 2 ਵਿੱਚ?
- ਹਾਂ, ਪਰ ਸੰਟੈਕਸ ਵੱਖਰਾ ਹੈ। ਪਾਈਥਨ 2 ਵਿੱਚ, ਤੁਸੀਂ ਵਰਤਦੇ ਹੋ super(ClassName, self).method(), ਜਦੋਂ ਕਿ ਪਾਈਥਨ 3 ਵਿੱਚ, ਤੁਸੀਂ ਬਸ ਵਰਤਦੇ ਹੋ super().method().
ਮੁੱਖ ਧਾਰਨਾਵਾਂ ਨੂੰ ਸਮੇਟਣਾ
ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ super() ਪਾਈਥਨ ਵਿੱਚ ਨਾ ਸਿਰਫ ਬੇਸ ਕਲਾਸਾਂ ਦੀ ਸਹੀ ਸ਼ੁਰੂਆਤ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਬਲਕਿ ਕੋਡ ਲਚਕਤਾ ਅਤੇ ਰੱਖ-ਰਖਾਅ ਨੂੰ ਵੀ ਵਧਾਉਂਦਾ ਹੈ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਮਲਟੀਪਲ ਵਿਰਾਸਤੀ ਸਥਿਤੀਆਂ ਵਿੱਚ ਲਾਭਦਾਇਕ ਹੈ ਜਿੱਥੇ ਬੇਸ ਕਲਾਸ ਵਿਧੀਆਂ ਲਈ ਸਿੱਧੀਆਂ ਕਾਲਾਂ ਬੋਝਲ ਅਤੇ ਗਲਤੀ-ਪ੍ਰਵਾਨ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਬੇਸ ਕਲਾਸ ਦੇ ਨਾਮਾਂ ਨੂੰ ਸੰਖੇਪ ਕਰਕੇ, super() ਕਲੀਨਰ ਅਤੇ ਹੋਰ ਅਨੁਕੂਲ ਕੋਡ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਦੀਆਂ ਬਾਰੀਕੀਆਂ ਨੂੰ ਸਮਝਣਾ super() ਬਨਾਮ Base.__init__() ਮਜਬੂਤ ਵਸਤੂ-ਮੁਖੀ ਪਾਈਥਨ ਕੋਡ ਲਿਖਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।