ਪਾਈਥਨ ਵਿੱਚ ਫੰਕਸ਼ਨ ਆਰਗੂਮੈਂਟਾਂ ਵਜੋਂ ਸੂਚੀਆਂ, ਟੂਪਲਾਂ ਅਤੇ ਸ਼ਬਦਕੋਸ਼ਾਂ ਦਾ ਵਿਸਤਾਰ ਕਰਨਾ ਅਤੇ ਪਾਸ ਕਰਨਾ

ਕਾਰੋਬਾਰ

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

ਕਿਸੇ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਦੇ ਸਮੇਂ, ਲਿਸਟਾਂ ਅਤੇ ਟੂਪਲਾਂ ਲਈ * ਅਤੇ ਸ਼ਬਦਕੋਸ਼ਾਂ ਲਈ ** ਨਾਲ ਆਰਗੂਮੈਂਟ ਦਿਓ। ਤਾਰਿਆਂ ਦੀ ਗਿਣਤੀ * ਨੋਟ ਕਰੋ।

ਹੇਠਾਂ ਦਿੱਤੇ ਵੇਰਵਿਆਂ ਦਾ ਇੱਥੇ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ।

  • ਇੱਕ ਸੂਚੀ ਦਾ ਵਿਸਤਾਰ (ਅਨਪੈਕ) ਕਰੋ ਜਾਂ * (ਇੱਕ ਤਾਰਾ) ਨਾਲ ਟਪਲ ਕਰੋ
    • ਡਿਫੌਲਟ ਆਰਗੂਮੈਂਟਾਂ ਵਾਲੇ ਫੰਕਸ਼ਨਾਂ ਲਈ
    • ਵੇਰੀਏਬਲ-ਲੰਬਾਈ ਆਰਗੂਮੈਂਟਾਂ ਵਾਲੇ ਫੰਕਸ਼ਨਾਂ ਲਈ
  • ** (ਦੋ ਤਾਰੇ) ਦੇ ਨਾਲ ਸ਼ਬਦਕੋਸ਼ ਦਾ ਵਿਸਤਾਰ (ਅਨਪੈਕ) ਕਰੋ
    • ਡਿਫੌਲਟ ਆਰਗੂਮੈਂਟਾਂ ਵਾਲੇ ਫੰਕਸ਼ਨਾਂ ਲਈ
    • ਵੇਰੀਏਬਲ-ਲੰਬਾਈ ਆਰਗੂਮੈਂਟਾਂ ਵਾਲੇ ਫੰਕਸ਼ਨਾਂ ਲਈ

ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਸਮੇਂ ਪਾਈਥਨ ਫੰਕਸ਼ਨਾਂ, ਡਿਫੌਲਟ ਆਰਗੂਮੈਂਟਾਂ, ਅਤੇ *,** ਦੇ ਨਾਲ ਵੇਰੀਏਬਲ ਲੰਬਾਈ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਬੁਨਿਆਦੀ ਵਰਤੋਂ ਲਈ ਹੇਠਾਂ ਦਿੱਤਾ ਲੇਖ ਦੇਖੋ।

ਇੱਕ ਸੂਚੀ ਦਾ ਵਿਸਤਾਰ (ਅਨਪੈਕ) ਕਰੋ ਜਾਂ * (ਇੱਕ ਤਾਰਾ) ਨਾਲ ਟਪਲ ਕਰੋ

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

def func(arg1, arg2, arg3):
    print('arg1 =', arg1)
    print('arg2 =', arg2)
    print('arg3 =', arg3)

l = ['one', 'two', 'three']

func(*l)
# arg1 = one
# arg2 = two
# arg3 = three

func(*['one', 'two', 'three'])
# arg1 = one
# arg2 = two
# arg3 = three

t = ('one', 'two', 'three')

func(*t)
# arg1 = one
# arg2 = two
# arg3 = three

func(*('one', 'two', 'three'))
# arg1 = one
# arg2 = two
# arg3 = three

ਹੇਠ ਦਿੱਤੀ ਵਿਆਖਿਆ ਇੱਕ ਸੂਚੀ ਲਈ ਹੈ, ਪਰ ਇਹ ਇੱਕ ਟੂਪਲ ‘ਤੇ ਲਾਗੂ ਹੁੰਦੀ ਹੈ।

ਜੇਕਰ ਤੱਤਾਂ ਦੀ ਸੰਖਿਆ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਸੰਖਿਆ ਨਾਲ ਮੇਲ ਨਹੀਂ ਖਾਂਦੀ, ਤਾਂ ਇੱਕ TypeError ਗਲਤੀ ਹੁੰਦੀ ਹੈ।

# func(*['one', 'two'])
# TypeError: func() missing 1 required positional argument: 'arg3'

# func(*['one', 'two', 'three', 'four'])
# TypeError: func() takes 3 positional arguments but 4 were given

ਡਿਫੌਲਟ ਆਰਗੂਮੈਂਟਾਂ ਵਾਲੇ ਫੰਕਸ਼ਨਾਂ ਲਈ

ਜੇਕਰ ਇੱਕ ਡਿਫੌਲਟ ਆਰਗੂਮੈਂਟ ਸੈੱਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਡਿਫੌਲਟ ਆਰਗੂਮੈਂਟ ਵਰਤੀ ਜਾਂਦੀ ਹੈ ਜੇਕਰ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਨਾਕਾਫ਼ੀ ਹੈ। ਜੇਕਰ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਬਹੁਤ ਜ਼ਿਆਦਾ ਹੈ, ਤਾਂ ਇੱਕ TypeError ਗਲਤੀ ਹੁੰਦੀ ਹੈ।

def func_default(arg1=1, arg2=2, arg3=3):
    print('arg1 =', arg1)
    print('arg2 =', arg2)
    print('arg3 =', arg3)

func_default(*['one', 'two'])
# arg1 = one
# arg2 = two
# arg3 = 3

func_default(*['one'])
# arg1 = one
# arg2 = 2
# arg3 = 3

# func_default(*['one', 'two', 'three', 'four'])
# TypeError: func_default() takes from 0 to 3 positional arguments but 4 were given

ਵੇਰੀਏਬਲ-ਲੰਬਾਈ ਆਰਗੂਮੈਂਟਾਂ ਵਾਲੇ ਫੰਕਸ਼ਨਾਂ ਲਈ

ਜੇਕਰ ਇੱਕ ਵੇਰੀਏਬਲ-ਲੰਬਾਈ ਆਰਗੂਮੈਂਟ ਸੈੱਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਪੋਜ਼ੀਸ਼ਨਲ ਆਰਗੂਮੈਂਟ ਲਈ ਐਲੀਮੈਂਟ ਤੋਂ ਬਾਅਦ ਸਾਰੇ ਤੱਤ ਵੇਰੀਏਬਲ-ਲੰਬਾਈ ਆਰਗੂਮੈਂਟ ਨੂੰ ਪਾਸ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।

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

func_args(*['one', 'two'])
# arg1 = one
# args = ('two',)

func_args(*['one', 'two', 'three'])
# arg1 = one
# args = ('two', 'three')

func_args(*['one', 'two', 'three', 'four'])
# arg1 = one
# args = ('two', 'three', 'four')

** (ਦੋ ਤਾਰੇ) ਦੇ ਨਾਲ ਸ਼ਬਦਕੋਸ਼ ਦਾ ਵਿਸਤਾਰ (ਅਨਪੈਕ) ਕਰੋ

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

def func(arg1, arg2, arg3):
    print('arg1 =', arg1)
    print('arg2 =', arg2)
    print('arg3 =', arg3)

d = {'arg1': 'one', 'arg2': 'two', 'arg3': 'three'}

func(**d)
# arg1 = one
# arg2 = two
# arg3 = three

func(**{'arg1': 'one', 'arg2': 'two', 'arg3': 'three'})
# arg1 = one
# arg2 = two
# arg3 = three

ਜੇਕਰ ਆਰਗੂਮੈਂਟ ਨਾਮ ਨਾਲ ਮੇਲ ਖਾਂਦੀ ਕੋਈ ਕੁੰਜੀ ਨਹੀਂ ਹੈ ਜਾਂ ਕੋਈ ਕੁੰਜੀ ਮੇਲ ਨਹੀਂ ਖਾਂਦੀ ਹੈ, ਤਾਂ ਇੱਕ TypeError ਗਲਤੀ ਹੋਵੇਗੀ।

# func(**{'arg1': 'one', 'arg2': 'two'})
# TypeError: func() missing 1 required positional argument: 'arg3'

# func(**{'arg1': 'one', 'arg2': 'two', 'arg3': 'three', 'arg4': 'four'})
# TypeError: func() got an unexpected keyword argument 'arg4'

ਡਿਫੌਲਟ ਆਰਗੂਮੈਂਟਾਂ ਵਾਲੇ ਫੰਕਸ਼ਨਾਂ ਲਈ

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

ਇੱਕ ਕੁੰਜੀ ਜੋ ਆਰਗੂਮੈਂਟ ਨਾਮ ਨਾਲ ਮੇਲ ਨਹੀਂ ਖਾਂਦੀ, ਇੱਕ TypeError ਗਲਤੀ ਦਾ ਨਤੀਜਾ ਹੋਵੇਗੀ।

def func_default(arg1=1, arg2=2, arg3=3):
    print('arg1 =', arg1)
    print('arg2 =', arg2)
    print('arg3 =', arg3)

func_default(**{'arg1': 'one'})
# arg1 = one
# arg2 = 2
# arg3 = 3

func_default(**{'arg2': 'two', 'arg3': 'three'})
# arg1 = 1
# arg2 = two
# arg3 = three

# func_default(**{'arg1': 'one', 'arg4': 'four'})
# TypeError: func_default() got an unexpected keyword argument 'arg4'

ਵੇਰੀਏਬਲ-ਲੰਬਾਈ ਆਰਗੂਮੈਂਟਾਂ ਵਾਲੇ ਫੰਕਸ਼ਨਾਂ ਲਈ

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

def func_kwargs(arg1, **kwargs):
    print('arg1 =', arg1)
    print('kwargs =', kwargs)

func_kwargs(**{'arg1': 'one', 'arg2': 'two', 'arg3': 'three'})
# arg1 = one
# kwargs = {'arg2': 'two', 'arg3': 'three'}

func_kwargs(**{'arg1': 'one', 'arg2': 'two', 'arg3': 'three', 'arg4': 'four'})
# arg1 = one
# kwargs = {'arg2': 'two', 'arg3': 'three', 'arg4': 'four'}

func_kwargs(**{'arg1': 'one', 'arg3': 'three'})
# arg1 = one
# kwargs = {'arg3': 'three'}