7. *args和**kwargs

7.1. *args

*args 用来将 不定数量 的参数打包成 tuple 给函数体使用。

例一：

def foo(x, *args):
  print "x:", x
  for k in range(len(args)):
    print "args[{}]:".format(k), args[k]

>>> foo(1, 100, '200k', 300)
x: 1
args[0]: 100
args[1]: 200k
args[2]: 300

>>> args = [1,2,'abc']
>>> foo('A', *args)
x: A
args[0]: 1
args[1]: 2
args[2]: abc

>>> foo('A', args) ## 注：此时把args当做一个参数，参数类型为列表
x: A
args[0]: [1, 2, 'abc']

例二：

def foo(x, var1, var2, var3):
  print "x:", x
  print "var1:", var1
  print "var2:", var2
  print "var3:", var3

>>> args = [1,2,'A'] # list
>>> foo(1, args)
TypeError: foo() takes exactly 4 arguments (2 given)
>>> foo(1, *args)
x: 1
var1: 1
var2: 2
var3: A

>>> args = (1,2,'A') # tuple
>>> foo(1, args)
TypeError: foo() takes exactly 4 arguments (2 given)
>>> foo(1, *args)
x: 1
var1: 1
var2: 2
var3: A

7.2. **kwargs

**kwargs 打包 不定数量 的键值对参数成 dict 给函数体使用。

例一：

def foo(**kwargs):
  for key, val in kwargs.items():
    print "{} : {}".format(key, val)

>>> foo(var1=1, var2='a', var3=[1,2,3])
var1 : 1
var3 : [1, 2, 3]
var2 : a

例二：

def foo(x, var1=2, var2='a'):
  print "x:", x
  print "var1:", var1
  print "var2:", var2

>>> dict_input = {"var1": 10, "var2": "A"}
>>> foo(1, dict_input)
x: 1
var1: {'var1': 10, 'var2': 'A'}
var2: a

>>> foo(1, **dict_input)
x: 1
var1: 10
var2: A

7.3. arg，*args，**kwargs

位置参数、*args、**kwargs三者的顺序必须是（arg，*args，**kwargs）。

def foo(arg, *args, **kwargs):
  print "arg:", arg
  print "args:", args
  print "kwargs:", kwargs

>>> foo(1, 2, 3, 4, x=1, y='b')
arg: 1
args: (2, 3, 4)
kwargs: {'y': 'b', 'x': 1}

>>> foo(1, x=1, y='b', 2, 3, 4)
SyntaxError: non-keyword arg after keyword arg

位置参数、默认参数、**kwargs三者的顺序必须是（位置参数，默认参数，**kwargs）。

def foo(x, y=1, **kwargs): ## 不能出现 (x=1,y,**kwargs)
  print "x:", x
  print "y:", y
  print "kwargs:", kwargs

>>> foo(4, var1=1, var2='b')
x: 4
y: 1
kwargs: {'var1': 1, 'var2': 'b'}

7.4. 仅限位置参数

在函数定义中， / 表示在它之前的形参是仅限位置形参（Positional-Only Argument），仅限位置形参没有外部可用的名称。在调用接受仅限位置形参的函数时，参数只会基于它们的位置被映射到形参。在 / 之后的参数可以是位置参数，也可以是键值对参数。

>>> def foo(a, /, b):
...     print(a, b)
...
>>> foo(1, 3)
1 3
>>> foo(1, b=3)
1 3
>>> foo(a=1, b=3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() got some positional-only arguments passed as keyword arguments: 'a'

>>> def foo(a, b):
...     print(a, b)
...
>>> foo(1, 2)
1 2
>>> foo(a=1, b=2)
1 2

7.5. 命名关键字参数

Python3 的命名关键字参数（Keyword-Only Argument），以独立的 * 为标记，强制用户在调用函数的时候必须写出 * 之后的参数名。

>>> def foo(a, *, b=0, c):
...     print(a, b, c)
...
>>> foo(1,2,3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() takes 1 positional argument but 3 were given
>>> foo(1,c=2,b=3)
1 3 2
>>> foo(1, c=2)
1 0 2
>>> foo(1, b=2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() missing 1 required keyword-only argument: 'c'

7.6. 默认参数与可变类型

默认参数是在函数定义的时候就被计算的，默认参数值存储在函数的 __defaults__ 属性中，每次调用函数都是从这个属性中读取默认参数值。

当默认参数值是可变类型的时候，这个默认值可能会因为函数调用而改变。

>>> def foo(n, l=[]):
...     l.append(n)
...     return l
...
>>> foo.__defaults__
([],)
>>> foo(1)
[1]
>>> foo(2)
[1, 2]
>>> foo.__defaults__
([1, 2],)

为了避免这种预期之外的结果，可以使用 None 作为默认参数值，在函数体中增加一个判断。

>>> def bar(n, l=None):
...     if l is None: l = []
...     l.append(n)
...     return l
...
>>> bar.__defaults__
(None,)
>>> bar(1)
[1]
>>> bar(2)
[2]
>>> bar.__defaults__
(None,)

7.7. 参考资料

大话Python中*args和**kargs的使用

https://www.cnblogs.com/shitaotao/p/7609990.html

python函数——形参中的：*args和**kwargs

https://www.cnblogs.com/xuyuanyuan123/p/6674645.html

函数的参数

https://www.liaoxuefeng.com/wiki/1016959663602400/1017261630425888