[Python学习笔记-004] 可变参数*args和**kwargs

在Python中，可变参数的传递使用*args和**kwargs来实现，其中：

• *args表示任意个位置参数(positional argument)，被表示为一个只读的数组(tuple)；
• **kwargs表示任意个关键字参数(keyword argument)，被表示为一个字典(dict)。

例如：

>>> def foo(*args, **kwargs):
...     print("*args:		", args)
...     print("**kwargs:	", kwargs)
...
>>>
>>> foo()
*args:           ()
**kwargs:        {}
>>> foo(1)
*args:           (1,)
**kwargs:        {}
>>> foo(1, 2)
*args:           (1, 2)
**kwargs:        {}
>>>
>>> foo(a=1, b=2)
*args:           ()
**kwargs:        {'a': 1, 'b': 2}
>>>
>>> foo(1, 2, a=1, b=2, c=3)
*args:           (1, 2)
**kwargs:        {'a': 1, 'b': 2, 'c': 3}
>>>
>>> foo(1, 2, [3, 4, 5], a=1, b=2, c={'A':1, 'B':2, 'C':3})
*args:           (1, 2, [3, 4, 5])
**kwargs:        {'a': 1, 'b': 2, 'c': {'A': 1, 'B': 2, 'C': 3}}
>>>
>>> foo(1, a=1, 2, b=2, 3, c=3)
  File "<stdin>", line 1
SyntaxError: positional argument follows keyword argument
>>>

注意： 位置参数(*args)必须在关键字参数(**kwargs)的前面。

另外，*args和**kwargs都是可以无限次地向下传递的（这一点类似Bash里的"$@"），例如：

• foo_args.py

#!/usr/bin/python

from __future__ import print_function
import sys

def l2_foo(*args):
    print(">>L2:		*args =", args, "
")

def l1_foo(head, *args):
    print(" >L1: head =", head, "	*args =", args)
    l2_foo(*args)

def main(argc, argv):
    l1_foo(1)
    l1_foo(1, 2)
    l1_foo(1, 2, 3)

    return 0

if __name__ == '__main__':
    argv = sys.argv
    argc = len(argv)
    sys.exit(main(argc, argv))

注意L6, L9 和 L11:

 6  def l2_foo(*args):
..
 9  def l1_foo(head, *args):
..
11      l2_foo(*args)

• 运行foo_args.py

$ ./foo_args.py 
 >L1: head = 1  *args = ()
>>L2:           *args = () 

 >L1: head = 1  *args = (2,)
>>L2:           *args = (2,) 

 >L1: head = 1  *args = (2, 3)
>>L2:           *args = (2, 3) 

最后，给出一个使用*args的更有工程意义的例子：

• foo.py

#!/usr/bin/python
from __future__ import print_function
import sys

class Foo(object):
    def __init__(self, name, oid):
        self.name = name
        self.oid = oid

    def get_name(self):
        return self.name

    def set_name(self, name):
        self.name = name

    def get_info(self):
        return "name = %s, oid = %d" % (self.name, self.oid)

    def set_info(self, name, oid):
        self.name = name
        self.oid = oid

class Bar(object):
    def __init__(self, name, oid):
        self.foo = Foo(name, oid)

    def __op_foo(self, method, *args):
        func = getattr(self.foo, method)
        try:
            prop = func(*args)
            return prop
        except Exception as e:
            print(e)

    def foo_set_name(self, name):
        return self.__op_foo('set_name', name)

    def foo_get_name(self):
        return self.__op_foo('get_name')

    def foo_set_info(self, name, oid):
        return self.__op_foo('set_info', name, oid)

    def foo_get_info(self):
        return self.__op_foo('get_info')

    def get_oid(self):
        return self.foo.oid  # XXX: Ugly but simple for demo

def foo_arg0():
    b = Bar('Jack', 12345)
    s = b.foo_get_name()
    print("foo_arg0: name = %s, oid = %d" % (s, b.get_oid()))

def foo_arg1():
    b = Bar('Jack', 12345)
    o = b.foo_set_name('Lynn')
    print("foo_arg1: return", o)
    s = b.foo_get_name()
    print("foo_arg1: name = %s, oid = %d" % (s, b.get_oid()))

def foo_arg2():
    b = Bar('Jack', 12345)
    o = b.foo_set_info('Mary', 54321)
    print("foo_arg2: return", o)
    s = b.foo_get_info()
    print("foo_arg2: %s" % s)

def main(argc, argv):
    if argc != 2:
        sys.stderr.write("Usage: %s <func ID>
" % argv[0])
        return 1

    func_id = int(argv[1])
    exec('foo_arg%d()' % func_id)

    return 0

if __name__ == '__main__':
    argv = sys.argv
    argc = len(argv)
    sys.exit(main(argc, argv))

• 运行foo.py

$ ./foo.py 0
foo_arg0: name = Jack, oid = 12345
$ ./foo.py 1
foo_arg1: return None
foo_arg1: name = Lynn, oid = 12345
$ ./foo.py 2
foo_arg2: return None
foo_arg2: name = Mary, oid = 54321

小结：在函数的参数列表中，零个*表示普通的位置参数， 一个*表示元组(tuple)， 两个*表示字典(dict)。

'*' * 0:   arg : regular arg
'*' * 1:  *args: tuple (i.e. readonly list)
'*' * 2: **args: dict