ਪਾਈਥਨ ਵਿੱਚ ਵੇਰੀਏਬਲ ਪਾਸਿੰਗ ਨੂੰ ਸਮਝਣਾ: ਹਵਾਲਾ ਬਨਾਮ ਮੁੱਲ

ਜਾਣ-ਪਛਾਣ: ਪਾਈਥਨ ਵੇਰੀਏਬਲ ਪਾਸਿੰਗ ਦੀ ਪੜਚੋਲ ਕਰਨਾ

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

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

ਪਾਈਥਨ ਵਿੱਚ ਪਾਸ-ਦਰ-ਸੰਦਰਭ ਲਾਗੂ ਕਰਨਾ

ਪਹਿਲੀ ਸਕ੍ਰਿਪਟ ਪਾਈਥਨ ਵਿੱਚ ਪਾਸ-ਬਾਈ-ਸੰਦਰਭ ਦੇ ਪ੍ਰਭਾਵ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇੱਕ ਪਰਿਵਰਤਨਯੋਗ ਸੂਚੀ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ। ਕਲਾਸ ਵਿੱਚ PassByReference, ਵੇਰੀਏਬਲ self.variable ਇੱਕ ਸਿੰਗਲ ਸਟ੍ਰਿੰਗ ਐਲੀਮੈਂਟ 'ਅਸਲੀ' ਵਾਲੀ ਸੂਚੀ ਦੇ ਤੌਰ 'ਤੇ ਸ਼ੁਰੂ ਕੀਤਾ ਗਿਆ ਹੈ। ਢੰਗ self.change(self.variable) ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਵਿਧੀ ਨੂੰ ਇਸ ਸੂਚੀ ਨੂੰ ਪਾਸ ਕਰਨਾ. ਵਿਧੀ ਦੇ ਅੰਦਰ, ਹੁਕਮ var[0] = 'Changed' ਸੂਚੀ ਦੇ ਪਹਿਲੇ ਤੱਤ ਨੂੰ ਸੋਧਦਾ ਹੈ। ਕਿਉਂਕਿ ਸੂਚੀਆਂ ਪਰਿਵਰਤਨਸ਼ੀਲ ਹਨ, ਇਹ ਤਬਦੀਲੀ ਵਿਧੀ ਦੇ ਬਾਹਰ ਪ੍ਰਤੀਬਿੰਬਿਤ ਹੁੰਦੀ ਹੈ, ਨਤੀਜੇ ਵਜੋਂ ਆਉਟਪੁੱਟ 'ਬਦਲਿਆ' ਹੁੰਦਾ ਹੈ। ਇਹ ਸਕ੍ਰਿਪਟ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਕਿਵੇਂ ਪਰਿਵਰਤਨਸ਼ੀਲ ਕਿਸਮਾਂ ਜਿਵੇਂ ਕਿ ਸੂਚੀਆਂ ਦੀ ਵਰਤੋਂ ਨਾਲ ਪਾਸ-ਦਰ-ਸੰਦਰਭ ਵਿਵਹਾਰ ਦੀ ਨਕਲ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

ਦੂਜੀ ਸਕ੍ਰਿਪਟ ਪੇਸ਼ ਕਰਦੀ ਹੈ ਏ Wrapper ਇੱਕ ਮੁੱਲ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਕਲਾਸ, ਪਾਸ-ਦਰ-ਸੰਦਰਭ-ਵਰਗੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਲਈ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਵਿੱਚ PassByReference ਕਲਾਸ, ਵੇਰੀਏਬਲ self.variable ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਨਾਲ ਸ਼ੁਰੂ ਕੀਤਾ ਗਿਆ ਹੈ Wrapper ਜਿਸ ਵਿੱਚ 'ਅਸਲੀ' ਹੈ। ਢੰਗ self.change(self.variable) ਪਾਸ ਕਰਨਾ, ਕਿਹਾ ਜਾਂਦਾ ਹੈ Wrapper ਉਦਾਹਰਨ. ਵਿਧੀ ਦੇ ਅੰਦਰ, ਹੁਕਮ var.value = 'Changed' ਨੂੰ ਸੋਧਦਾ ਹੈ value ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ Wrapper ਉਦਾਹਰਨ. ਇਹ ਤਬਦੀਲੀ ਵਿਧੀ ਦੇ ਬਾਹਰ ਪ੍ਰਤੀਬਿੰਬਿਤ ਹੁੰਦੀ ਹੈ, ਜਿਸ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਆਉਟਪੁੱਟ 'ਬਦਲਿਆ' ਹੁੰਦਾ ਹੈ। ਇਹ ਪਹੁੰਚ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਕਿਵੇਂ ਇੱਕ ਕਸਟਮ ਰੈਪਰ ਕਲਾਸ ਬਣਾਉਣਾ ਪਾਸ-ਦਰ-ਸੰਦਰਭ ਦੇ ਸਮਾਨ ਪ੍ਰਭਾਵਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦਾ ਹੈ।

ਪਰਿਵਰਤਨਸ਼ੀਲ ਸਟੇਟ ਪਾਸਿੰਗ ਲਈ ਸ਼ਬਦਕੋਸ਼ਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਤੀਜੀ ਲਿਪੀ ਪਾਸ-ਦਰ-ਸੰਦਰਭ ਦੇ ਪ੍ਰਭਾਵ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇੱਕ ਸ਼ਬਦਕੋਸ਼ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ। ਵਿੱਚ PassByReference ਕਲਾਸ, ਵੇਰੀਏਬਲ self.variable ਇੱਕ ਸਿੰਗਲ ਕੁੰਜੀ-ਮੁੱਲ ਜੋੜਾ {'key': 'Original'} ਦੇ ਨਾਲ ਇੱਕ ਸ਼ਬਦਕੋਸ਼ ਦੇ ਰੂਪ ਵਿੱਚ ਸ਼ੁਰੂ ਕੀਤਾ ਗਿਆ ਹੈ। ਢੰਗ self.change(self.variable) ਵਿਧੀ ਨੂੰ ਇਸ ਸ਼ਬਦਕੋਸ਼ ਨੂੰ ਪਾਸ ਕਰਨਾ, ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਵਿਧੀ ਦੇ ਅੰਦਰ, ਹੁਕਮ var['key'] = 'Changed' ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਕੁੰਜੀ ਨਾਲ ਸੰਬੰਧਿਤ ਮੁੱਲ ਨੂੰ ਸੋਧਦਾ ਹੈ। ਕਿਉਂਕਿ ਸ਼ਬਦਕੋਸ਼ ਪਰਿਵਰਤਨਸ਼ੀਲ ਹਨ, ਇਹ ਤਬਦੀਲੀ ਵਿਧੀ ਦੇ ਬਾਹਰ ਪ੍ਰਤੀਬਿੰਬਿਤ ਹੁੰਦੀ ਹੈ, ਨਤੀਜੇ ਵਜੋਂ ਆਉਟਪੁੱਟ 'ਬਦਲਿਆ' ਹੁੰਦਾ ਹੈ। ਇਹ ਸਕ੍ਰਿਪਟ ਉਜਾਗਰ ਕਰਦੀ ਹੈ ਕਿ ਕਿਵੇਂ ਪਰਿਵਰਤਨਸ਼ੀਲ ਕਿਸਮਾਂ ਜਿਵੇਂ ਕਿ ਸ਼ਬਦਕੋਸ਼ਾਂ ਦੀ ਵਰਤੋਂ ਨਾਲ ਪਾਸ-ਦਰ-ਸੰਦਰਭ ਵਿਵਹਾਰ ਦੀ ਨਕਲ ਕਰ ਸਕਦਾ ਹੈ।

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

class PassByReference:
    def __init__(self):
        self.variable = ['Original']
        self.change(self.variable)
        print(self.variable[0])

    def change(self, var):
        var[0] = 'Changed'

pbr = PassByReference()

class Wrapper:
    def __init__(self, value):
        self.value = value

class PassByReference:
    def __init__(self):
        self.variable = Wrapper('Original')
        self.change(self.variable)
        print(self.variable.value)

    def change(self, var):
        var.value = 'Changed'

pbr = PassByReference()

class PassByReference:
    def __init__(self):
        self.variable = {'key': 'Original'}
        self.change(self.variable)
        print(self.variable['key'])

    def change(self, var):
        var['key'] = 'Changed'

pbr = PassByReference()

ਪਾਈਥਨ ਦੇ ਵੇਰੀਏਬਲ ਹੈਂਡਲਿੰਗ ਮਕੈਨਿਜ਼ਮ ਨੂੰ ਸਮਝਣਾ

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

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

ਪਾਈਥਨ ਵੇਰੀਏਬਲ ਪਾਸਿੰਗ 'ਤੇ ਇਨਸਾਈਟਸ ਨੂੰ ਸਮਾਪਤ ਕਰਨਾ

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