ਪਾਈਥਨ 3.11 ਵਿੱਚ ਪਾਈਲਿੰਟ ਦੇ ਬੇਕਾਰ-ਮਾਪਿਆਂ-ਪ੍ਰਤੀਨਿਧੀ ਮੰਡਲ ਅਤੇ ਸੁਪਰ-ਇਨਿਟ-ਨਾ-ਕਹਿੰਦੇ ਵਿਵਾਦ ਨੂੰ ਹੱਲ ਕਰਨਾ

ਕਲਾਸ ਦੀ ਸ਼ੁਰੂਆਤ ਵਿੱਚ ਪਾਈਲਿੰਟ ਗਲਤੀਆਂ ਨੂੰ ਸਮਝਣਾ

Pylint ਕੋਡ ਗੁਣਵੱਤਾ ਮੁੱਦਿਆਂ ਨੂੰ ਫੜਨ ਲਈ ਇੱਕ ਸਹਾਇਕ ਸਾਧਨ ਹੈ, ਪਰ ਕਈ ਵਾਰ ਇਹ ਉਹਨਾਂ ਗਲਤੀਆਂ ਨੂੰ ਫਲੈਗ ਕਰਦਾ ਹੈ ਜੋ ਵਿਰੋਧੀ ਜਾਪਦੀਆਂ ਹਨ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਪਾਈਥਨ ਵਿੱਚ ਕਲਾਸ ਵਿਰਾਸਤ ਨਾਲ ਨਜਿੱਠਣ ਵੇਲੇ। ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਇੱਕ ਆਮ ਸਮੱਸਿਆ ਪੈਦਾ ਹੁੰਦੀ ਹੈ ਸੁਪਰ() ਇੱਕ ਸਬਕਲਾਸ ਦੇ ਕੰਸਟਰਕਟਰ ਵਿੱਚ ਫੰਕਸ਼ਨ, ਦੋ ਤਰੁੱਟੀਆਂ ਵਿਚਕਾਰ ਟਕਰਾਅ ਦੀ ਅਗਵਾਈ ਕਰਦਾ ਹੈ: ਬੇਕਾਰ-ਮਾਪੇ-ਵਫ਼ਦ ਅਤੇ ਸੁਪਰ-ਇਨਿਟ-ਨਾ-ਕਹਿੰਦੇ.

ਇਹ ਸਮੱਸਿਆ ਆਮ ਤੌਰ 'ਤੇ ਸਾਹਮਣੇ ਆਉਂਦੀ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਕਾਲ ਕਰ ਰਹੇ ਹੁੰਦੇ ਹੋ super().__init__() ਇੱਕ ਸਧਾਰਨ ਉਪ-ਕਲਾਸ ਵਿੱਚ ਜਿੱਥੇ ਮਾਤਾ-ਪਿਤਾ ਕਲਾਸ ਦੀ ਹੈ __init__ ਕੋਈ ਕਾਰਜਸ਼ੀਲਤਾ ਨਹੀਂ ਜੋੜਦਾ। ਅਜਿਹੇ ਮਾਮਲਿਆਂ ਵਿੱਚ, Pylint ਰਿਪੋਰਟ ਕਰ ਸਕਦਾ ਹੈ ਕਿ ਕਾਲ ਬੇਲੋੜੀ ਹੈ, ਫਲੈਗਿੰਗ ਏ ਬੇਕਾਰ-ਮਾਪੇ-ਵਫ਼ਦ ਗਲਤੀ

ਹਾਲਾਂਕਿ, ਜੇਕਰ ਤੁਸੀਂ ਹਟਾਉਂਦੇ ਹੋ ਸੁਪਰ() ਪਹਿਲੇ ਮੁੱਦੇ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਕਾਲ ਕਰੋ, ਪਾਇਲਿੰਟ ਫਿਰ ਸ਼ਿਕਾਇਤ ਕਰੇਗਾ ਕਿ ਸੁਪਰ-ਇਨਿਟ-ਨਹੀਂ-ਕਹਿੰਦੇ ਗਲਤੀ ਸ਼ੁਰੂ ਹੋ ਗਈ ਹੈ। ਇਹ ਉਹਨਾਂ ਡਿਵੈਲਪਰਾਂ ਲਈ ਇੱਕ ਦੁਬਿਧਾ ਪੈਦਾ ਕਰਦਾ ਹੈ ਜੋ ਉਹਨਾਂ ਦੇ ਕੋਡ ਨੂੰ ਸਾਫ਼ ਅਤੇ ਚੇਤਾਵਨੀ-ਮੁਕਤ ਰੱਖਦੇ ਹੋਏ ਸਭ ਤੋਂ ਵਧੀਆ ਅਭਿਆਸਾਂ ਦੀ ਪਾਲਣਾ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਹਨ।

ਇਹ ਲੇਖ ਇਸ ਗੱਲ ਦੀ ਪੜਚੋਲ ਕਰੇਗਾ ਕਿ ਪਾਇਥਨ 3.11 ਵਿੱਚ ਇਹ ਟਕਰਾਅ ਕਿਉਂ ਹੁੰਦਾ ਹੈ ਅਤੇ ਪਾਇਲਟ ਦੀਆਂ ਦੋਵੇਂ ਤਰੁੱਟੀਆਂ ਨੂੰ ਦਬਾਏ ਬਿਨਾਂ ਉਹਨਾਂ ਤੋਂ ਬਚਣ ਲਈ ਇੱਕ ਕਦਮ-ਦਰ-ਕਦਮ ਹੱਲ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਤੁਹਾਡਾ ਕੋਡ ਕਾਰਜਸ਼ੀਲ ਅਤੇ ਅਨੁਕੂਲ ਬਣਿਆ ਰਹੇ।

ਪਾਈਲਿੰਟ ਗਲਤੀਆਂ ਨੂੰ ਸਮਝਣਾ ਅਤੇ ਕਲਾਸ ਵਿਰਾਸਤ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣਾ

ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਉਦਾਹਰਣਾਂ ਵਿੱਚ, ਮੁੱਖ ਚੁਣੌਤੀ ਵਿਵਾਦਾਂ ਨੂੰ ਹੱਲ ਕਰਨਾ ਹੈ ਪਾਇਲਿੰਟ ਚੇਤਾਵਨੀਆਂ: ਬੇਕਾਰ-ਮਾਪੇ-ਵਫ਼ਦ ਅਤੇ ਸੁਪਰ-ਇਨਿਟ-ਨਹੀਂ-ਕਹਿੰਦੇ. ਇਹ ਚੇਤਾਵਨੀਆਂ ਉਦੋਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ ਜਦੋਂ ਵਿਰਾਸਤ ਨਾਲ ਪਾਈਥਨ ਸਬ-ਕਲਾਸ ਬਣਾਉਂਦੇ ਹਨ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਸੁਪਰ() ਫੰਕਸ਼ਨ. ਪਹਿਲੀ ਚੇਤਾਵਨੀ, ਬੇਕਾਰ-ਮਾਪੇ-ਵਫ਼ਦ, ਉਦੋਂ ਵਾਪਰਦਾ ਹੈ ਜਦੋਂ ਕਾਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਸੁਪਰ() ਮੁੱਲ ਨਹੀਂ ਜੋੜਦਾ ਕਿਉਂਕਿ ਪੇਰੈਂਟ ਕਲਾਸ ਦਾ ਹੈ __init__ ਵਿਧੀ ਜਾਂ ਤਾਂ ਖਾਲੀ ਹੈ ਜਾਂ ਕੁਝ ਵੀ ਅਰਥਪੂਰਨ ਨਹੀਂ ਹੈ। ਦੂਜੇ ਪਾਸੇ, ਨੂੰ ਹਟਾਉਣਾ ਸੁਪਰ() ਕਾਲ ਦੀ ਅਗਵਾਈ ਕਰ ਸਕਦਾ ਹੈ ਸੁਪਰ-ਇਨਿਟ-ਨਹੀਂ-ਕਹਿੰਦੇ ਚੇਤਾਵਨੀ, ਜੋ ਸੁਝਾਅ ਦਿੰਦੀ ਹੈ ਕਿ ਤੁਸੀਂ ਜ਼ਰੂਰੀ ਪੇਰੈਂਟ ਸ਼ੁਰੂਆਤੀ ਤਰਕ ਨੂੰ ਬਾਈਪਾਸ ਕਰ ਰਹੇ ਹੋ।

ਇਸ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, ਉਪਰੋਕਤ ਸਕ੍ਰਿਪਟਾਂ ਵਿਰਾਸਤ ਦੀ ਵਧੇਰੇ ਸ਼ਰਤੀਆ ਅਤੇ ਮਾਡਯੂਲਰ ਹੈਂਡਲਿੰਗ ਬਣਾਉਣ 'ਤੇ ਕੇਂਦ੍ਰਤ ਕਰਦੀਆਂ ਹਨ। ਪਹਿਲੇ ਹੱਲ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਪੇਸ਼ ਕਰਦੇ ਹਾਂ ਜੇਕਰ ਇਹ ਜਾਂਚ ਕਰਨ ਲਈ ਸ਼ਰਤ ਹੈ ਕਿ ਕੀ ਕਾਲ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਕੋਈ ਕੀਵਰਡ ਆਰਗੂਮੈਂਟ ਪਾਸ ਕੀਤੇ ਗਏ ਹਨ ਸੁਪਰ(). ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਸੁਪਰ() ਬੇਕਾਰ-ਪੈਰੈਂਟ-ਡੈਲੀਗੇਸ਼ਨ ਗਲਤੀ ਤੋਂ ਬਚਦੇ ਹੋਏ, ਲੋੜ ਪੈਣ 'ਤੇ ਹੀ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਜਦੋਂ kwargs ਖਾਲੀ ਹਨ, ਅਸੀਂ ਮਾਤਾ-ਪਿਤਾ ਦੀ ਸ਼ੁਰੂਆਤ ਨੂੰ ਛੱਡ ਦਿੰਦੇ ਹਾਂ, ਇਸ ਤਰ੍ਹਾਂ ਸਾਫ਼ ਅਤੇ ਕੁਸ਼ਲ ਕੋਡ ਬਣਾਈ ਰੱਖਦੇ ਹਾਂ। ਇਹ ਤਰਕ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਦੇ ਹੋਏ ਪਾਇਲਿੰਟ ਦੇ ਮਿਆਰਾਂ ਨਾਲ ਇਕਸਾਰ ਹੋਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।

ਦੂਸਰਾ ਹੱਲ ਇਸ ਵਿਚਾਰ ਨੂੰ ਹੋਰ ਸੁਧਾਰ ਕਰਦਾ ਹੈ ਨਾਲ ਇੱਕ ਚੈਕ ਪੇਸ਼ ਕਰਕੇ hasattr() ਫੰਕਸ਼ਨ ਇਹ ਦੇਖਣ ਲਈ ਕਿ ਕੀ ਪੇਰੈਂਟ ਕਲਾਸ ਕੋਲ ਅਸਲ ਵਿੱਚ ਇੱਕ ਹੈ __init__ ਢੰਗ. ਇਹ ਤਰੀਕਾ ਕਾਲ ਕਰਨ ਤੋਂ ਬਚਦਾ ਹੈ ਸੁਪਰ() ਜਦੋਂ ਮਾਤਾ-ਪਿਤਾ ਨੂੰ ਸ਼ੁਰੂਆਤੀਕਰਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ ਹੈ, ਜੋ ਦੋਵਾਂ ਚੇਤਾਵਨੀਆਂ ਨੂੰ ਦਿਖਾਈ ਦੇਣ ਤੋਂ ਰੋਕਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ। ਦੀ ਵਰਤੋਂ hasattr() ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਪੇਰੈਂਟ ਕਲਾਸ ਸਿਰਫ ਉਦੋਂ ਸ਼ੁਰੂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ ਉਚਿਤ ਹੋਵੇ, ਕੋਡ ਨੂੰ ਹੋਰ ਗਤੀਸ਼ੀਲ ਅਤੇ ਵੱਖ-ਵੱਖ ਵਿਰਾਸਤੀ ਦ੍ਰਿਸ਼ਾਂ ਦੇ ਅਨੁਕੂਲ ਬਣਾਉਂਦਾ ਹੈ।

ਤੀਸਰਾ ਹੱਲ ਬੇਲੋੜੀ ਵਿਰਾਸਤ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਖਤਮ ਕਰਨ ਲਈ ਕੋਡ ਨੂੰ ਰੀਫੈਕਟਰਿੰਗ ਦੁਆਰਾ ਇੱਕ ਹੋਰ ਸਖਤ ਪਹੁੰਚ ਲੈਂਦਾ ਹੈ। ਜੇਕਰ ਮਾਤਾ-ਪਿਤਾ ਵਰਗ ਕੋਈ ਨਾਜ਼ੁਕ ਕਾਰਜਸ਼ੀਲਤਾ ਜਾਂ ਵਿਵਹਾਰ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕਰਦਾ ਹੈ, ਤਾਂ ਅਸੀਂ ਵਿਰਾਸਤ ਨੂੰ ਹਟਾਉਂਦੇ ਹਾਂ ਅਤੇ ਇਲਾਜ ਕਰਦੇ ਹਾਂ ਫੂ ਇੱਕ ਸਟੈਂਡਅਲੋਨ ਕਲਾਸ ਦੇ ਰੂਪ ਵਿੱਚ। ਇਹ ਪੂਰੀ ਤਰ੍ਹਾਂ ਦੀ ਜ਼ਰੂਰਤ ਨੂੰ ਦੂਰ ਕਰਦਾ ਹੈ ਸੁਪਰ() ਅਤੇ ਸੰਬੰਧਿਤ ਚੇਤਾਵਨੀਆਂ, ਸਮੱਸਿਆ ਦਾ ਇੱਕ ਸਾਫ਼, ਵਧੇਰੇ ਸਿੱਧਾ ਹੱਲ ਪੇਸ਼ ਕਰਦੀਆਂ ਹਨ। ਧਿਆਨ ਨਾਲ ਵਿਚਾਰ ਕਰਕੇ ਕਿ ਕੀ ਵਿਰਾਸਤ ਦੀ ਲੋੜ ਹੈ, ਇਹ ਹੱਲ ਸੁਪਰਕਲਾਸ ਡੈਲੀਗੇਸ਼ਨ ਨਾਲ ਸਬੰਧਤ ਆਮ ਮੁੱਦਿਆਂ ਤੋਂ ਬਚਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।

# Solution 1: Modify the class design to avoid unnecessary super() calls
# This approach is ideal if Bar.__init__() doesn't add any functionality
# and Foo does not need the parent's initialization logic.

class Bar:
    def __init__(self, kwargs):
        pass  # No logic here

class Foo(Bar):
    def __init__(self, kwargs):
        if kwargs:  # Initialize only if kwargs are present
            super().__init__(kwargs)

# This avoids the useless-parent-delegation error, since super()
# is only called when needed.

# Solution 2: Implement a conditional super() based on the parent's init logic
# This ensures super() is called only if the parent has a meaningful init logic.

class Bar:
    def __init__(self, kwargs):
        self.data = kwargs.get('data', None)

class Foo(Bar):
    def __init__(self, kwargs):
        if hasattr(Bar, '__init__'):
            super().__init__(kwargs)
        else:
            self.data = kwargs.get('data', None)

# This handles cases where Bar has an actual init logic and avoids
# unnecessary calls to super() if Bar has no init behavior.

# Solution 3: Refactor to eliminate inheritance if super() is not needed
# If the inheritance isn't critical, consider refactoring to remove it altogether.

class Bar:
    pass  # Empty class with no functionality

class Foo:
    def __init__(self, kwargs):
        self.data = kwargs.get('data', None)

# In this scenario, the unnecessary inheritance is eliminated,
# which also removes the need for super() calls.

import unittest

class TestFoo(unittest.TestCase):
    def test_foo_initialization(self):
        obj = Foo(data='test')
        self.assertEqual(obj.data, 'test')

if __name__ == '__main__':
    unittest.main()

# This test ensures the Foo class initializes correctly across all solutions
# and that the class behavior is consistent with the input data.

ਬਿਹਤਰ ਕਲਾਸ ਡਿਜ਼ਾਈਨ ਦੁਆਰਾ ਪਾਈਲਿੰਟ ਵਿਰਾਸਤ ਦੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਹੱਲ ਕਰਨਾ

Pylint ਚੇਤਾਵਨੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਵੇਲੇ ਇੱਕ ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਪਹਿਲੂ ਜਿਵੇਂ ਕਿ ਬੇਕਾਰ-ਮਾਪੇ-ਵਫ਼ਦ ਅਤੇ ਸੁਪਰ-ਇਨਿਟ-ਨਹੀਂ-ਕਹਿੰਦੇ ਤੁਹਾਡੇ ਸਮੁੱਚੇ ਕਲਾਸ ਡਿਜ਼ਾਈਨ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰ ਰਿਹਾ ਹੈ। ਇਹਨਾਂ ਗਲਤੀਆਂ ਤੋਂ ਬਚਣ ਦਾ ਇੱਕ ਤਰੀਕਾ ਇਹ ਹੈ ਕਿ ਤੁਹਾਡੇ ਕੋਡ ਵਿੱਚ ਵਿਰਾਸਤ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ ਇਸ ਬਾਰੇ ਮੁੜ ਵਿਚਾਰ ਕਰਨਾ ਹੈ। ਕੁਝ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਸਮੱਸਿਆ ਬੇਲੋੜੀ ਵਿਰਾਸਤ ਤੋਂ ਪੈਦਾ ਹੋ ਸਕਦੀ ਹੈ ਜਿੱਥੇ ਪੇਰੈਂਟ ਕਲਾਸ ਮਹੱਤਵਪੂਰਨ ਕਾਰਜਸ਼ੀਲਤਾ ਦੀ ਪੇਸ਼ਕਸ਼ ਨਹੀਂ ਕਰਦੀ ਹੈ। ਵਿਰਾਸਤ ਨੂੰ ਮਜਬੂਰ ਕਰਨ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਵਰਤੋਂ ਦੇ ਕੇਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ, ਰਚਨਾ ਜਾਂ ਸਟੈਂਡਅਲੋਨ ਕਲਾਸਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।

ਪਾਈਥਨ ਵਿੱਚ, ਵਿਰਾਸਤ ਨਾਲ ਡਿਜ਼ਾਈਨ ਕਰਦੇ ਸਮੇਂ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਪੇਰੈਂਟ ਕਲਾਸ ਦੁਬਾਰਾ ਵਰਤੋਂ ਯੋਗ ਤਰਕ ਪ੍ਰਦਾਨ ਕਰ ਰਿਹਾ ਹੈ ਜੋ ਬਾਲ ਵਰਗ ਨੂੰ ਲਾਭ ਪਹੁੰਚਾਉਂਦਾ ਹੈ। ਨਹੀਂ ਤਾਂ, ਕਾਲ ਕਰਨਾ super() ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਬੇਲੋੜੀ ਸ਼ੁਰੂਆਤ ਹੋਵੇਗੀ, ਜੋ ਬਿਲਕੁਲ ਉਹੀ ਹੈ ਜੋ ਟਰਿੱਗਰ ਕਰਦਾ ਹੈ ਬੇਕਾਰ-ਮਾਪੇ-ਵਫ਼ਦ ਗਲਤੀ ਦੂਜੇ ਪਾਸੇ, ਵਿਰਾਸਤ ਨੂੰ ਹਟਾਉਣ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ਸੰਭਾਵੀ ਤੌਰ 'ਤੇ ਉਪਯੋਗੀ ਸਾਂਝੀ ਕਾਰਜਸ਼ੀਲਤਾ ਤੱਕ ਪਹੁੰਚ ਗੁਆ ਸਕਦੇ ਹੋ। ਇਸ ਵਪਾਰ ਨੂੰ ਸੰਤੁਲਿਤ ਕਰਨ ਲਈ ਆਬਜੈਕਟ-ਅਧਾਰਿਤ ਡਿਜ਼ਾਈਨ ਸਿਧਾਂਤਾਂ ਦੀ ਡੂੰਘੀ ਸਮਝ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਕੁਝ ਸਥਿਤੀਆਂ ਵਿੱਚ, ਡਿਵੈਲਪਰ Pylint ਚੇਤਾਵਨੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦਬਾ ਸਕਦੇ ਹਨ # pylint: disable ਟਿੱਪਣੀਆਂ ਹਾਲਾਂਕਿ ਇਹ ਇੱਕ ਅਸਥਾਈ ਹੱਲ ਹੋ ਸਕਦਾ ਹੈ, ਆਮ ਤੌਰ 'ਤੇ ਲੰਬੇ ਸਮੇਂ ਲਈ ਇਸ ਦੀ ਸਿਫ਼ਾਰਸ਼ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ। ਦਬਾਉਣ ਵਾਲੀਆਂ ਚੇਤਾਵਨੀਆਂ ਦੀ ਵਰਤੋਂ ਉਦੋਂ ਹੀ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ ਜਦੋਂ ਤੁਹਾਨੂੰ ਪੱਕਾ ਪਤਾ ਹੋਵੇ ਕਿ ਪਾਇਲਟ ਚੇਤਾਵਨੀ ਤੁਹਾਡੇ ਕੋਡ ਦੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਪ੍ਰਭਾਵਤ ਨਹੀਂ ਕਰਦੀ ਹੈ। ਸਾਫ਼ ਅਤੇ ਕੁਸ਼ਲ ਕਲਾਸ ਵਿਰਾਸਤ ਲਈ ਅਨੁਕੂਲ ਬਣਾਉਣਾ, ਅਤੇ ਇਹ ਸਮਝਣਾ ਕਿ ਕਦੋਂ ਵਰਤਣਾ ਹੈ super() ਉਚਿਤ ਤੌਰ 'ਤੇ, ਵਧੇਰੇ ਰੱਖ-ਰਖਾਅਯੋਗ ਅਤੇ ਸਕੇਲੇਬਲ ਕੋਡ ਦੀ ਅਗਵਾਈ ਕਰਦਾ ਹੈ।