खालील फंक्शन आर्ग्युमेंट्स कदाचित सर्वात सामान्य आहेत जे तुम्ही पायथन कोड पाहता तेव्हा तुम्हाला स्टंप करतात आणि म्हणतात, “हे काय आहे?
*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:एक शब्दकोश म्हणून एकाधिक कीवर्ड वितर्क स्वीकारते
कीवर्ड वितर्कांची अनियंत्रित संख्या ** 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
