Difference Call Function With Asterisk Parameter And Without

I know what the meaning of an asterisk is in a function definition in Python. I often, though, see asterisks for calls to functions with parameters like: def foo(*args, **kwargs):

Solution 1:

Let args = [1,2,3]:

func(*args) == func(1,2,3) - variables are unpacked out of list (or any other sequence type) as parameters

func(args) == func([1,2,3]) - the list is passed

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

func(kwargs) == func({'a':1, 'b':2, 'c':3}) - the dict is passed

func(*kwargs) == func(('a','b','c')) - tuple of the dict's keys (in random order)

func(**kwargs) == func(a=1,b=2,c=3) - (key, value) are unpacked out of the dict (or any other mapping type) as named parameters

Solution 2:

The difference is how the arguments are passed into the called functions. When you use the *, the arguments are unpacked (if they're a list or tuple)—otherwise, they're simply passed in as is.

Here's an example of the difference:

>>>defadd(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

When I prefixed the argument with *, it actually unpacked the list into two separate arguments, which were passed into add as a and b. Without it, it simply passed in the list as a single argument.

The same is the case for dictionaries and **, except they're passed in as named arguments rather than ordered arguments.

>>>defshow_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

Solution 3:

deffun1(*args):
    """ This function accepts a non keyworded variable length argument as a parameter.
    """print args        
    printlen(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
>>>