ਪਾਈਥਨ ਵਿੱਚ ਵੇਰੀਏਬਲ ਲੰਬਾਈ ਆਰਗੂਮੈਂਟਾਂ (*args, **kwargs) ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ

ਹੇਠਾਂ ਦਿੱਤੇ ਫੰਕਸ਼ਨ ਆਰਗੂਮੈਂਟਸ ਸ਼ਾਇਦ ਸਭ ਤੋਂ ਆਮ ਹਨ ਜੋ ਤੁਹਾਨੂੰ ਸਟੰਪ ਕਰਦੇ ਹਨ ਜਦੋਂ ਤੁਸੀਂ ਪਾਈਥਨ ਕੋਡ ਨੂੰ ਦੇਖਦੇ ਹੋ ਅਤੇ ਕਹਿੰਦੇ ਹੋ, “ਇਹ ਕੀ ਹੈ?

• *args
• **kwargs

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

• *
• **

*args,**kwargs ਨਾਮ ਅਕਸਰ ਇੱਕ ਕਨਵੈਨਸ਼ਨ ਵਜੋਂ ਵਰਤੇ ਜਾਂਦੇ ਹਨ। ਹਾਲਾਂਕਿ, ਹੋਰ ਨਾਮ ਉਦੋਂ ਤੱਕ ਸਵੀਕਾਰਯੋਗ ਹਨ ਜਦੋਂ ਤੱਕ * ਅਤੇ ** ਸ਼ੁਰੂ ਵਿੱਚ ਹਨ। ਹੇਠਾਂ ਦਿੱਤਾ ਨਮੂਨਾ ਕੋਡ *args,**kwargs ਨਾਂ ਵਰਤਦਾ ਹੈ।

ਹੇਠਾਂ ਦਿੱਤੇ ਵੇਰਵੇ ਹੇਠਾਂ ਦਿੱਤੇ ਗਏ ਹਨ.

• *args:ਇੱਕ ਟੂਪਲ ਦੇ ਤੌਰ ‘ਤੇ ਕਈ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ
• **kwargs:ਇੱਕ ਸ਼ਬਦਕੋਸ਼ ਦੇ ਤੌਰ ‘ਤੇ ਮਲਟੀਪਲ ਕੀਵਰਡ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ

*args:ਇੱਕ ਟੂਪਲ ਦੇ ਤੌਰ ‘ਤੇ ਕਈ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ

ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਆਰਬਿਟਰੇਰੀ ਸੰਖਿਆ ਨੂੰ * ਨਾਲ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ *ਆਰਗਸ ਵਿੱਚ।

def my_sum(*args):
    return sum(args)

print(my_sum(1, 2, 3, 4))
# 10

print(my_sum(1, 2, 3, 4, 5, 6, 7, 8))
# 36

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

def my_sum2(*args):
    print('args: ', args)
    print('type: ', type(args))
    print('sum : ', sum(args))

my_sum2(1, 2, 3, 4)
# args:  (1, 2, 3, 4)
# type:  <class 'tuple'>
# sum :  10

ਇਸ ਨੂੰ ਸਥਿਤੀ ਦੀ ਦਲੀਲ ਨਾਲ ਵੀ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ।

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

def func_args(arg1, arg2, *args):
    print('arg1: ', arg1)
    print('arg2: ', arg2)
    print('args: ', args)

func_args(0, 1, 2, 3, 4)
# arg1:  0
# arg2:  1
# args:  (2, 3, 4)

func_args(0, 1)
# arg1:  0
# arg2:  1
# args:  ()

* ਨਾਲ ਚਿੰਨ੍ਹਿਤ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਪਹਿਲਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਕੇਸ ਵਿੱਚ, ਹਾਲਾਂਕਿ, *args ਤੋਂ ਬਾਅਦ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਕੀਵਰਡ ਰੂਪ ਵਿੱਚ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਤਫਾਕਨ, ਕੀਵਰਡ ਫਾਰਮੈਟ “ਆਰਗੂਮੈਂਟ ਨਾਮ = ਮੁੱਲ” ਰੂਪ ਹੈ।

ਆਖਰੀ ਮੁੱਲ ਸਥਿਤੀ ਸੰਬੰਧੀ ਆਰਗੂਮੈਂਟ ਨੂੰ ਆਪਣੇ ਆਪ ਪਾਸ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਸ ਲਈ, ਜੇਕਰ ਇਹ ਇੱਕ ਕੀਵਰਡ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ ‘ਤੇ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਇੱਕ TypeError ਗਲਤੀ ਦਾ ਨਤੀਜਾ ਹੋਵੇਗਾ।

def func_args2(arg1, *args, arg2):
    print('arg1: ', arg1)
    print('arg2: ', arg2)
    print('args: ', args)

# func_args2(0, 1, 2, 3, 4)
# TypeError: func_args2() missing 1 required keyword-only argument: 'arg2'

func_args2(0, 1, 2, 3, arg2=4)
# arg1:  0
# arg2:  4
# args:  (1, 2, 3)

ਜੇਕਰ ਸਿਰਫ਼ * ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਅਗਲੀਆਂ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਹਮੇਸ਼ਾ ਕੀਵਰਡ ਆਰਗੂਮੈਂਟਾਂ ਦੇ ਤੌਰ ‘ਤੇ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।(keyword-only argument)

def func_args_kw_only(arg1, *, arg2):
    print('arg1: ', arg1)
    print('arg2: ', arg2)

# func_args_kw_only(100, 200)
# TypeError: func_args_kw_only() takes 1 positional argument but 2 were given

func_args_kw_only(100, arg2=200)
# arg1:  100
# arg2:  200

**kwargs:ਇੱਕ ਸ਼ਬਦਕੋਸ਼ ਦੇ ਤੌਰ ‘ਤੇ ਮਲਟੀਪਲ ਕੀਵਰਡ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ

ਕੀਵਰਡ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਆਰਬਿਟਰੇਰੀ ਸੰਖਿਆ ਨੂੰ ,** ਨਾਲ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜਿਵੇਂ ਕਿ **ਕਵਾਰਗਸ।

ਫੰਕਸ਼ਨ ਵਿੱਚ, ਆਰਗੂਮੈਂਟ ਦਾ ਨਾਮ ਇੱਕ ਡਿਕਸ਼ਨਰੀ ਵਜੋਂ ਪ੍ਰਾਪਤ ਹੁੰਦਾ ਹੈ ਜਿਸਦੀ ਕੁੰਜੀ ਕੁੰਜੀ ਹੁੰਦੀ ਹੈ ਅਤੇ ਜਿਸਦਾ ਮੁੱਲ ਮੁੱਲ ਹੁੰਦਾ ਹੈ।

def func_kwargs(**kwargs):
    print('kwargs: ', kwargs)
    print('type: ', type(kwargs))

func_kwargs(key1=1, key2=2, key3=3)
# kwargs:  {'key1': 1, 'key2': 2, 'key3': 3}
# type:  <class 'dict'>

ਇਸਦੀ ਵਰਤੋਂ ਸਥਿਤੀ ਦਲੀਲ ਦੇ ਨਾਲ ਜੋੜ ਕੇ ਵੀ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

def func_kwargs_positional(arg1, arg2, **kwargs):
    print('arg1: ', arg1)
    print('arg2: ', arg2)
    print('kwargs: ', kwargs)

func_kwargs_positional(0, 1, key1=1)
# arg1:  0
# arg2:  1
# kwargs:  {'key1': 1}

ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਨ ਵੇਲੇ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ** ਦੇ ਨਾਲ ਡਿਕਸ਼ਨਰੀ ਆਬਜੈਕਟ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਨ ਨਾਲ, ਇਸ ਨੂੰ ਫੈਲਾਉਣਾ ਅਤੇ ਸੰਬੰਧਿਤ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ ‘ਤੇ ਪਾਸ ਕਰਨਾ ਸੰਭਵ ਹੈ।

d = {'key1': 1, 'key2': 2, 'arg1': 100, 'arg2': 200}

func_kwargs_positional(**d)
# arg1:  100
# arg2:  200
# kwargs:  {'key1': 1, 'key2': 2}

** ਨਾਲ ਚਿੰਨ੍ਹਿਤ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਸਿਰਫ਼ ਆਰਗੂਮੈਂਟ ਦੇ ਅੰਤ ‘ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ** ਨਾਲ ਚਿੰਨ੍ਹਿਤ ਆਰਗੂਮੈਂਟ ਤੋਂ ਬਾਅਦ ਇੱਕ ਹੋਰ ਆਰਗੂਮੈਂਟ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਨਾਲ ਇੱਕ ਸਿੰਟੈਕਸ ਐਰਰ ਗਲਤੀ ਹੋਵੇਗੀ।

# def func_kwargs_error(**kwargs, arg):
#     print(kwargs)

# SyntaxError: invalid syntax