तारांकन पैरामीटर के साथ अंतर कॉल फ़ंक्शन और बिना

Question

मुझे पता है कि पाइथन में फ़ंक्शन परिभाषा में तारांकन का अर्थ क्या है।

def foo(*args, **kwargs): 
    first_func(args, kwargs) 
    second_func(*args, **kwargs) 

पहले और दूसरे समारोह कॉल बीच क्या अंतर है:

मैं अक्सर, हालांकि, कार्यों के लिए कॉल के लिए तारांकनों जैसे मानकों के साथ देखते हैं?

Answer 1

arg = [1,2,3]

func(*arg) == func(1,2,3) चर (या वहाँ अनुक्रम प्रकार) सूची से बाहर आने के मानकों

func(arg) == रूप func([1,2,3]) एक सूची

kwargs = dict(a=1,b=2,c=3)

में चला जाता है func(kwargs) == func({'a':1, 'b':2, 'c':3}) एक dict नामित पैरामीटर के रूप में में

func(**kwargs) == func(a=1,b=2,c=3) (कुंजी, मूल्य) dict (या मैपिंग प्रकार) से बाहर आने के लिए चला जाता है

Answer 2

अंतर यह है कि तर्कों को बुलाए गए कार्यों में कैसे पारित किया जाता है। जब आप * का उपयोग करते हैं, तो तर्क अनपॅक किए जाते हैं (यदि वे एक सूची या टुपल हैं) — अन्यथा, वे बस इस तरह से पास हो जाते हैं।

यहाँ अंतर का एक उदाहरण है:

>>> def add(a, b): 
... print a + b 
... 
>>> add(*[2,3]) 
5 
>>> add([2,3]) 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: add() takes exactly 2 arguments (1 given) 
>>> add(4, 5) 
9 

जब मैं * साथ तर्क पहले से जुड़ा हुआ है, यह वास्तव में दो अलग तर्क है, जो a और b रूप add में पारित किए गए में सूची अनपैक किया। इसके बिना, यह केवल एक तर्क के रूप में सूची में पारित किया।

शब्दकोशों और ** के लिए भी यही मामला है, सिवाय इसके कि वे आदेशित तर्कों के बजाए नामांकित तर्क के रूप में पास किए गए हैं।

>>> def show_two_stars(first, second='second', third='third'): 
... print "first: " + str(first) 
... print "second: " + str(second) 
... print "third: " + str(third) 
>>> show_two_stars('a', 'b', 'c') 
first: a 
second: b 
third: c 
>>> show_two_stars(**{'second': 'hey', 'first': 'you'}) 
first: you 
second: hey 
third: third 
>>> show_two_stars({'second': 'hey', 'first': 'you'}) 
first: {'second': 'hey', 'first': 'you'} 
second: second 
third: third 

Answer 3

def fun1(*args): 
    """ This function accepts a non keyworded variable length argument as a parameter. 
    """ 
    print args   
    print len(args) 


>>> a = [] 

>>> fun1(a) 
([],) 
1 
# This clearly shows that, the empty list itself is passed as a first argument. Since *args now contains one empty list as its first argument, so the length is 1 
>>> fun1(*a) 
() 
0 
# Here the empty list is unwrapped (elements are brought out as separate variable length arguments) and passed to the function. Since there is no element inside, the length of *args is 0 
>>>