Python语法学习记录（15）：*args **kwargs

介绍

*args：表示普通的参数，也即位置参数（positional arguments），由元组存储
**kwargs：key word args，则表示关键字参数（keyword arguments），由字典存储

def foo(*args, **kwargs):
    print('args = ', args)
    print('kwargs = ', kwargs)

if __name__ == '__main__':
    foo(1,2,3,4)
#>>args =  (1, 2, 3, 4)
#>>kwargs =  {}
    foo(a=1,b=2,c=3)
#>>args =  ()
#>>kwargs =  {'b': 2, 'c': 3, 'a': 1}
    foo(1,2,3,4, a=1,b=2,c=3)
#>>args =  (1, 2, 3, 4)
#>>kwargs =  {'b': 2, 'c': 3, 'a': 1}
    foo('a', 1, None, a=1, b='2', c=3)
#>>args =  ('a', 1, None)
#>>kwargs =  {'b': '2', 'c': 3, 'a': 1}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

*args：位置参数，将参数组织成元组

def print_params(*args):
    print(args)
print_params('Testing')
#>>('Testing', )
print_params(1, 2, 3)
#>>(1, 2, 3)
1
2
3
4
5
6

与普通参数的组合使用：

def print_params(title, *args):
    print(title)
    print(args)
print_params('Params', 1, 2, 3)
#>> Params
#>> (1, 2, 3)
1
2
3
4
5
6

**kw：关键字参数，将参数组织成字典

def print_params(x, y, z=3, *parms, **kw):
    print(x, y, z)
    print(parms)
    print(kw)
print_params(1, 2, 3, 5, 6, 7, foo=1, bar=2)
#>> 1 2 3
#>> (5, 6, 7)
#>> {'foo':1, 'bar':2}
1
2
3
4
5
6
7
8

我们可以使用这种方式创建字典：

def create_dict(**kw):
    return kw
1
2

参数收集的逆过程

def add(x, y):
    a = x+y
    print(a) 
    return a
params = (1, 2)
add(*params)
#>> 3
1
2
3
4
5
6
7

同样适用于 **KW（关键字参数）

* 的另一妙用

# 将可迭代对象中的元素进行解析
def foo(*x):
    print(x)
foo(i for i in range(10))
#>> (<generator object <genexpr> at 0x00000000035B4168>,)
# 一个迭代器对象构成的 tuple
foo([i for i in range(10)])
#>> ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9],)
foo(*(i for i in range(10))) 
#>> (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
foo(*[i for i in range(10)])
#>> (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
1
2
3
4
5
6
7
8
9
10
11
12

解决一些问题

如何传递进只接受 3 个参数的函数多于 4 个的参数：

方式之一：

def fun(a, b, c):
    print (c)
fun(1, 2, (3, 4))
#>> (3, 4)
1
2
3
4

方式之二：

def fun(a, b, *c):
    print (c[0])
fun(1, 2, 3, 4)
#>> 3
1
2
3
4