" *args " & " **kwargs " in Python

Python中的 “ *args ” 和 “ **kwargs ”

Posted by Aaron on December 7, 2017

“Hello world.”

前段时间偶然发现自己对 *args 和 **kwargs 还存在一些困惑,而网络上的知识点比较零碎,身边几本书上写的又各有侧重。这里把自己整理的一些笔记贴出来,相信能帮到遇到同样问题的小伙伴。

手机上看到话code太长是可以左右滑动的。

1 基本概念

Python支持可变参数,最简单的方法莫过于使用默认参数。

def test_defargs(one, two=2):    # 参数one没有默认值,two的默认值为2
   print('Required argument: ', one)
   print('Optional argument: ', two)

test_defargs(1)
'''
Required argument: 1
Optional argument: 2
'''

test_defargs(1, 3)
'''
Required argument: 1
Optional argument: 3
'''

另外一种达到可变参数 (Variable Argument) 的方法: 使用 *args**kwargs 语法。 *args 是可变的位置参数(positional arguments)列表, **kwargs 是可变的关键词参数(keyword arguments)列表。 并且规定位置参数必须位于关键词参数之前,即 *args 必须位于 **kwargs 之前。 ***

1.1 位置参数 (Positional Arguments)

def print_hello(name, sex):
    sex_dict = {1: '先生', 2: '女士'}    # key: value
    print('hello %s %s, welcome to Python world!' %(name, sex_dict.get(sex, '先生')))    # if no such a key, print '先生'

print(print_hello('Chen', 2))    # 位置参数要求先后顺序,对应name和sex
print(print_hello('Chen', 3))    # 两个参数的顺序必须一一对应,且少一个参数都不可以
'''
hello Chen 女士, welcome to Python world!
hello Chen 先生, welcome to Python world!
'''

1.2 关键字参数 (Keyword Arguments)

用于函数调用,通过“键–值”形式加以指定。 使用关键词参数可以让函数更加清晰、容易使用,同时也清除了参数的顺序需求。

以下是用关键字参数正确调用函数的实例

print(print_hello('Chen', sex=1))    # 有位置参数时,位置参数必须在关键字参数的前面
    # print(print_hello(1, name='Chen'))    # python 3.X中这种写法也是错误的
print(print_hello(name='Chen', sex=1))    # 关键字参数之间不存在先后顺序的
print(print_hello(sex=1, name='Chen'))

以下是错误的调用方式

# print_hello(name='Chen', 1)    # 有位置参数时,位置参数必须在关键字参数的前面
# print_hello(sex=1, 'Chen')

1.3 默认参数

使用关键词参数时,可为参数提供默认值,调用函数时可传可不传该默认参数的值(注意:所有位置参数必须出现在默认参数前,包括函数定义和调用)

正确的默认参数定义方式 –> 位置参数在前,默认参数在后

def print_hello2(name, sex=1):    # 默认sex=1
    sex_dict = {1: '先生', 2: '女士'}    # key: value
    print('hello %s %s, welcome to circus!' %(name, sex_dict.get(sex, '先生')))

# 错误的定义方式
# def print_hello(sex=1, name):

# 调用时不传sex的值,则使用默认值1
print(print_hello2('Chen'))
'''
hello Chen 先生, welcome to circus!
'''

# 调用时传入sex的值,并指定为2。无视原来的sex=1,仅本次生效,不会改变函数sex的默认值
print(print_hello2('Liu', sex=2))
'''
hello Liu 女士, welcome to circus!
'''

2 收集参数(Packing)

被收集到一起的位置参数或关键词参数

有些时候,我们在定义参数时不确定会传递多少个参数(或者不传递),甚至我们想要根据实际情况传入任意个参数,这个时候 packing 就派上了用场。

def print_args(*args):
	print(args)

print_args(1)
print_args(1, 2, 3)
'''
(1,)
(1, 2, 3)
'''

可以看到,结果是作为一个元组(tuple)打印出来的,因为仅传入1时,输出的括号里面有一个逗号。实际上,*args 前的 * 可以理解为将我们需要传入的所有值放置在了同一个元组里面,这就是收集 (packing) 的过程。

2.1 位置参数的收集传递 —— *packing

收集参数可以和位置参数一起使用吗?试试看呗

def print_args2(num, *args):
	print(num)
	print(args)

print_args2(1)
print_args2(1, 2, 3)
'''
1    print(num)
()    print(args) --> 一个空元组
1    print(num)
(2, 3)    print(args) --> 剩余的参数组成的元组!
'''

那么这么说来 * 的意思就是“把剩余的所有参数收集 packing 起来”!

2.2 关键词参数的收集传递—— **packing

packing可以处理关键词参数吗?

def print_kargs(**kargs):
	print(kargs)

print_kargs(x=1, y=2, z=3)
'''
{'z': 3, 'y': 2, 'x': 1}
'''

Hey! 注意到*花括号 {} **了吗?!对,结果输出了一个字典(dic),是的,双星号 ** 收集了所有关键词参数。 **

3 分割参数(Unpacking)

* 和 ** 也可以在函数调用过程中使用,称之为分割 (unpacking)

3.1 在传递元组时,让元组的每一个元素对应一个位置参数

def print_hello(name, sex):
    print(name, sex)

args = ('Chen', '男')
print_hello(*args)
'''
Chen 男
'''

3.2 在传递词典字典时,让词典的每个键值对作为一个关键字参数传递给函数

def print_info(**kargs):
    print(kargs)

kargs = {'name': 'Chen', 'sex': '男', 'time': '13'}
print_info(**kargs)
'''
{'name': 'Chen', 'sex', u'男'}
'''

4 各类参数混合使用

基本原则是:先位置参数,默认参数,收集位置参数,收集关键字参数(定义和调用都应遵循)

def func(name, age, sex=1, *args, **kargs):
    print(name, age, sex, args, kargs)


func('Chen', 25, 2, 'Geo', 'SR', level=2)
'''
Chen 25 2 ('Geo', 'SR') {'level': 2}
'''

总结一下就是,星号 * 只有在定义需要使用不定数目的参数的函数,或者调用“分割”字典和序列时才有必要添加。 ***

4.1 EXAMPLE 1 - Tell a story

def story1(**kwargs):
    return 'Once upon a time, there was a %(job)s called %(name)s.' % kwargs

def story2(**kwargs):
    return 'In the year of our lord %(year)d, there once lived a %(job)s of a royal line.' % kwargs

print(story1(name='Robin', job='brave knight'))
print(story1(job='king', name='Charlie'))
'''
Once upon a time, there was a brave knight called Robin.
Once upon a time, there was a king called Charlie.
'''

kwargs = {'name': 'Abel', 'job': 'bard'}
print(story1(**kwargs))
'''
Once upon a time, there was a bard called Abel.
'''

kwargs.pop('job')    # delete key['job'] --> kwargs = {'name': 'Abel',}
print(story1(job='witch', **kwargs))    # redefine key['job']
'''
Once upon a time, there was a witch called Abel.
'''

print(story2(year=1239, job='prince'))
print(story2(job='princess', year=1239))
'''
In the year of our lord 1239, there once lived a prince of a royal line.
In the year of our lord 1239, there once lived a princess of a royal line.
'''

4.2 EXAMPLE 2 - x to the yth power

def power(x, y, *args):
    if args:
        print('Received redundant parameters:', args)
    return pow(x, y)

print(power(2, 3))    # 2 to the 3rd power
print(power(3, 2))    # 3 to the 2nd power
print(power(x=2, y=3))    # 2 to the 3rd power
print(power(y=3, x=2))    # no order for keyword arguments
'''
8
9
8
8
'''

args = (5,) * 2    # '(5,) * 2': copy elements in the tuple 2 times. The outcome is (5, 5)
print(power(*args))    # 5 to the 5th power
'''
3125
'''

print(power(2, 5, 'Keep on trying'))
'''
Received redundant parameters: ('Keep on trying',)
32    # 2 to the 5th power
'''

4.3 EXAMPLE 3 - Bulid a function to realize range() for step>0

def interval(start=0, stop=None, step=1):
    if stop is None:
        start, stop = 0, start
    result = []
    i = start
    while i < stop:
        result.append(i)
        i += step
    return result

print(interval(10))
'''
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
'''

print(interval(1, 6))
'''
[1, 2, 3, 4, 5]
'''

print(interval(3, 15, 3))
[3, 6, 9, 12]

POSTSCRIPT

在Python 3.X当中加入了”部分剩余参数“的概念了。 例如:

a, \*b ,c = range(5)

中间的 *b 实际上是收集到了3个参数。 下面这个例子更加直观:

def func1(x, y, *args, z=1):    # z=1 在函数参数中最后定义
    print(x, y, args, z)


func1(1, 2, 3, 4, 5)
'''
1 2 (3, 4, 5) 1
'''

Python 3.X 当中,默认参数 z=1 在函数参数中最后定义,Python 就会知道除了 传给 x 和 y, 以及 z=1 的部分,其他的剩余参数 (3, 4, 5) 都是传入到 *args 当中。 默认参数 z=1 不是在函数参数中最后定义时,情况又是怎样?

def func2(x, y, z=1, *args):
    print(x, y, z, args)


func2(1, 2, 3, 4, 5)
'''
1 2 3 (4, 5)
'''

3传入到 z ,而 args=(4, 5)

Python 2.X 并没有这一特性,所以 Python 2.X 的 z=1 必须在*args和**kwargs这种剩余参数收集之前。

~结束啦~