નીચેની ફંક્શન દલીલો કદાચ સૌથી સામાન્ય છે જે તમને પાયથોન કોડ જોતા કહે છે કે “આ શું છે?
*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
