使用参数，关键字参数，* args，** kwargs与Python函数混淆

Question

Given the below function and resulting calls to print_stuff() , can someone explain why there is unexpected behavior when calling the function without a keyword arg default but passing in a list to *args ?

I'm aware of the "gotcha" involving mutable/immutable keyword defaults, but I don't see that being relevant here.

Can someone clarify why this occurs, or any syntax/invocation error?

def print_stuff(arg, kwarg=None, *args):
    print "arg: %s" % arg

    if kwarg:
        print "kwarg: %s" % kwarg

    if args:
        for a in args:
            print "printing {} from args".format(a)

    print "===end==="

args_list = range(1, 3)
kwargs_list = {str(a):a for a in args_list}

print_stuff('hi', kwarg='some_kwarg') # works as intended

print_stuff('hi', 'some_kwarg', *range(1, 3)) # also works as intended

print_stuff('hi', *range(1, 3)) # first element of list unexpectedly passed in to keyword argument, even using the * notation

print_stuff('hi', kwarg='some_kwarg', *range(1, 3)) # TypeError: print_stuff() got multiple values for keyword argument 'kwarg'

Answer 1

kwarg is not a keyword-only argument; it's just a positional argument that has a default. Your call

print_stuff('hi', *range(1,3))

is exactly the same as

print_stuff('hi', 1, 2)

which assigns the first two arguments to the first two named parameters, and the remaining (ie, the third) is placed in the *args parameter.

Answer 2

Aside from having a default value for kwarg , print_stuff(arg, kwarg=None, *args) is no different to print_stuff(arg, kwarg, *args) - if there is a second positional argument, it is passed as the kwarg parameter (any subsequent positional arguments end up in args ).

Note that:

print_stuff('hi', *range(1, 3))

is evaluated as:

print_stuff('hi', 1, 2)

so the first argument goes to arg , the second goes to kwarg and the third to args[0] .

---

Then if we note that:

print_stuff('hi', kwarg='some_kwarg', *range(1, 3))

is equivalent to:

print_stuff('hi', *range(1, 3), kwarg='some_kwarg')

and therefore to:

print_stuff('hi', 1, 2, kwarg='some_kwarg')

you can perhaps see the problem - again 'hi' , 1 and 2 go to arg , kwarg and args[0] respectively but then another value for kwarg turns up unexpectedly.

---

If you want all positional arguments to be "soaked up" before kwarg is considered, change the function definition to:

def print_stuff(arg, *args, **kwargs):
    print "arg: %s" % arg
    kwarg = kwargs.get('kwarg')
    if kwarg is not None:  # note explicit test - what if kwarg == 0?
        print "kwarg: %s" % kwarg

    for a in args:  # no need to test here - loop doesn't run if no args
        print "printing {} from args".format(a)

    print "===end==="

In use:

>>> print_stuff('hi', *range(1, 3))
arg: hi
printing 1 from args
printing 2 from args
===end===
>>> print_stuff('hi', *range(1, 3), kwarg='some_kwarg')
arg: hi
kwarg: some_kwarg
printing 1 from args
printing 2 from args
===end===

Note that in 3.x you can have keyword-only arguments , ie the following is an alternative:

def print_stuff(arg, *args, kwarg=None):
    ...

Answer 3

One simple way to think of it is this:

When an argument is passed to a function, it gets added to a positional argument "queue" of sorts. Python will ignore keyword arguments and prioritize non-keyword arguments when assigning to this queue. All keyword arguments are assigned last in function calls. You can imagine this as Python "shifting around the order" of your arguments because its eager to fill positions first. So with a call like:

print_stuff('hi', kwarg='some_kwarg', *range(1,3))

Python will basically transform it into:

print_stuff('hi', 1, 2, kwarg='some_kwarg')

and then will get angry because you assign to kwarg twice.

***Note that this is not necessarily what actually happens, but it's a good way of thinking about it because you will be able to handle mistakes and can also explain why in a call like:

print_stuff('hi', *range(1,3))

the 1 gets passed to the 2nd positional argument kwarg, and the 2 gets passed to the 3rd argument args.

Answer 4

Simply i am writing a function to show how *args and **kwargs works

def test_function(normal_arg, *arg, **kwargs):
    print(locals())
    return

test_function("normal_arg-value", 
    "*arg1-value", "*arg2-value",
    karg1="karg1-value", karg2="karg2-value")

#output
{'arg1': 'arg1-value', 'arg': ('*arg1-value', '*arg2-value'), 'kwargs': {'karg2': 'karg2-value', 'karg1': 'karg1-value'}}

Hope this helps.

How unlimited of arguments can pass to a function

def test(*lis):
    print locals()

test(1,2,3)

#output
{'lis': (1, 2, 3)}

How unlimited named arguments can pass to a function

def test(**dicts):
    print locals()

test(arg1="value1", arg2="value2")

#output
{'dicts': {'arg1': 'value1', 'arg2': 'value2'}}

How a dictionary pass to a function as argument

def test(**dicts):
    print locals()

test(**{"arg1":"value1", "arg2": "value2"})

#output
{'dicts': {'arg1': 'value1', 'arg2': 'value2'}}

Hope this helps you