पायथन में चर लंबाई तर्क (*args, **kwargs) का उपयोग कैसे करें

जब आप पायथन कोड को देखते हैं और कहते हैं, “यह क्या है?

• *args
• **kwargs

फ़ंक्शन परिभाषा में तर्क के लिए तारांकन जोड़कर किसी भी संख्या में तर्क (चर-लंबाई तर्क) निर्दिष्ट किए जा सकते हैं

• *
• **

*args,**kwargs नाम अक्सर एक सम्मेलन के रूप में उपयोग किए जाते हैं। हालांकि, अन्य नाम तब तक स्वीकार्य हैं जब तक * और ** शुरुआत में हों। निम्नलिखित नमूना कोड *args,**kwargs नामों का उपयोग करता है।

निम्नलिखित विवरण नीचे वर्णित हैं।

• *args:टपल के रूप में कई तर्क स्वीकार करता है
• **kwargs:एक शब्दकोश के रूप में कई कीवर्ड तर्क स्वीकार करता है

*args:टपल के रूप में कई तर्क स्वीकार करता है

तर्कों की मनमानी संख्या को * के साथ तर्कों को परिभाषित करके निर्दिष्ट किया जा सकता है, जैसा कि *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

फ़ंक्शन में टुपल के रूप में एकाधिक तर्क प्राप्त होते हैं। उदाहरण में, योग () फ़ंक्शन को योग की गणना करने के लिए एक टपल पास किया जाता है।

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

इसे स्थिति तर्क के साथ भी जोड़ा जा सकता है।

स्थितीय तर्क के बाद (दाईं ओर) निर्दिष्ट मान को टपल के रूप में args में पास किया जाता है। यदि केवल एक स्थितीय तर्क है, तो यह एक खाली टपल है।

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}

** के साथ चिह्नित तर्क केवल तर्क के अंत में परिभाषित किए जा सकते हैं। ** के साथ चिह्नित तर्क के बाद किसी अन्य तर्क को परिभाषित करने के परिणामस्वरूप SyntaxError त्रुटि होगी।

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

# SyntaxError: invalid syntax