પાયથોનમાં ફંક્શન દલીલો તરીકે સૂચિઓ, ટ્યુપલ્સ અને શબ્દકોશોને વિસ્તૃત અને પસાર કરવા

પાયથોનમાં, યાદીઓ (એરે), ટ્યુપલ્સ અને શબ્દકોશોને વિસ્તૃત કરી શકાય છે (અનપેક્ડ) અને તેમના સંબંધિત ઘટકોને ફંક્શન દલીલો તરીકે એકસાથે પસાર કરી શકાય છે.

ફંક્શનને કૉલ કરતી વખતે, સૂચિઓ અને ટ્યુપલ્સ માટે * અને શબ્દકોશો માટે ** સાથે દલીલનો ઉલ્લેખ કરો. ફૂદડીની સંખ્યા નોંધો *.

નીચેની વિગતો અહીં વર્ણવેલ છે.

• સૂચિને વિસ્તૃત કરો (અનપૅક કરો) અથવા * (એક ફૂદડી) વડે ટપલ કરો
  • ડિફૉલ્ટ દલીલો સાથેના કાર્યો માટે
  • ચલ-લંબાઈની દલીલો સાથેના કાર્યો માટે
• ** (બે ફૂદડી) સાથે શબ્દકોશ વિસ્તૃત કરો (અનપૅક કરો)
  • ડિફૉલ્ટ દલીલો સાથેના કાર્યો માટે
  • ચલ-લંબાઈની દલીલો સાથેના કાર્યો માટે

ફંક્શનને વ્યાખ્યાયિત કરતી વખતે પાયથોન ફંક્શન્સ, ડિફૉલ્ટ દલીલો અને *,** સાથે ચલ લંબાઈ દલીલોના મૂળભૂત ઉપયોગ માટે નીચેનો લેખ જુઓ.

• સંબંધિત:પાયથોન ફંક્શન્સમાં ડિફોલ્ટ દલીલોનો ઉપયોગ કેવી રીતે કરવો અને નોંધ લેવી
• સંબંધિત:Python માં ચલ લંબાઈ દલીલોનો ઉપયોગ કેવી રીતે કરવો(*args,**kwargs)

સૂચિને વિસ્તૃત કરો (અનપૅક કરો) અથવા * (એક ફૂદડી) વડે ટપલ કરો

જ્યારે સૂચિ અથવા ટપલને * સાથે દલીલ તરીકે સ્પષ્ટ કરવામાં આવે છે, ત્યારે તે વિસ્તૃત થાય છે અને દરેક ઘટક અલગ દલીલ તરીકે પસાર થાય છે.

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'}