简单讲解
首先我们可以定一个简单的函数, 函数内部只考虑required_arg这一个形参(位置参数)

def exmaple(required_arg):
   print required_arg
exmaple("Hello, World!")
>> Hello, World!

那么，如果我们调用函数式传入了不止一个位置参数会出现什么情况？当然是会报错！

*arg和**kwarg 可以帮助我们处理上面这种情况，允许我们在调用函数的时候传入多个实参

def exmaple2(required_arg, *arg, **kwarg):
   if arg:
       print "arg: ", arg
   if kwarg:
       print "kwarg: ", kwarg
exmaple2("Hi", 1, 2, 3, keyword1 = "bar", keyword2 = "foo")
>> arg:  (1, 2, 3)
>> kwarg:  {'keyword2': 'foo', 'keyword1': 'bar'}

从上面的例子可以看到，当我传入了更多实参的时候

*arg会把多出来的位置参数转化为tuple

**kwarg会把关键字参数转化为dict

正文

  • 本文主要内容：
  1. 可变参数的定义
  2. 理解参数传递(*)星号
  3. *args 非键值可变参数的定义
  4. 理解参数传递(**)双星号
  5. **kwargs 键值可变参数的定义
  6. 可变参数的混合调用和定义

1.可变参数定义

定义函数时，有时候我们不确定调用的时候会多少个参数,就可以使用可变参数

def func(required_arg, default_arg=None, *args, **kwargs):
    pass
    #  required_arg 必传位置参数
    #  default_arg 默认参数
    # *args 非键值可变参数
    # **kwargs 键值可变参数

上面是Python得一个典型的函数定义，简单明了的表述了python的四种参数定义方式

  • required_arg 必传位置参数
  • default_arg 默认参数
  • *args 非键值可变参数
  • **kwargs 键值可变参数
注意：这几种参数是有顺序的，位置参数 > 默认参数>非键值可变参数>键值可变参数

今天主要介绍可变参数：
Python有一个特殊的语法,(单星号)(双星号),允许您将数量可变的参数传递给函数。 约定俗成的方式通常写 args 和 kwargs , args 和 kwargs 只是变量名，你可以写 vars 和 *vars实现相同的结果。

*args是用来传递一个非键值变长参数列表功能。
**kwargs通常用来传递关键字变长参数。

2. 理解参数传递(*)星号

>>> def add(x, y):
...     print("x:",x)
...     print("y:",y)
...     print("sum:", x+y)

上面定义一个简单的函数add，我们通常的调用方式

>>> add(1, 2)
x: 1
y: 2
sum: 3
>>> add(x=1, y=2)
x: 1
y: 2
sum: 3

当面我们多传或者少传参数程序就会抛出异常

>>> add(1)
  Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  TypeError: add() missing 1 required positional argument: 'y'
>>> add(1,2,3)
  Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  TypeError: add() takes 2 positional arguments but 3 were given

如果我们想通过1个变量传入多个参数怎么传？

>>> nums = (1,2)
>>> add(nums)
  Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  TypeError: add() missing 1 required positional argument: 'y'

我们把参数值封装到一个tuple 中，然后直接传递到add 中程序抛出了异常参数缺失，那要如何传参，可以使用*号

>>> nums = (1,2)
>>> add(*nums)
x: 1
y: 2
sum: 3

>>> nums = (1,2,3)
>>> add(*nums)
  Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  TypeError: add() takes 2 positional arguments but 3 were given

通过上面执行结果可以做到，只要在nums前加上,并且nums 的数量跟参数一致就可以调用成功，这是什么原因？
这里有一个知识点叫做序列化解包，在传递元组时，让元组的每一个元素对应一个位置参数，当nums 传递到函数里面时，程序会自动解包映射到位置参数上

3. *args 非键值可变参数的定义

我们在定义函数时，发现不能确认非键值参数的个数的时候，我们就可以定义为可变非键值参数

def add(*args): 
...     sum = 0
...     for arg in args: #args是个元组
...             print(arg)
...             sum += arg
...     print("sum:", sum)

我们通过*args 代表接收一个可变参数列表，那如何调用可变参数列表的函数呢

>>> add() #不传参数
sum: 0
>>> add(1,2,3)#通过位置参数传递
1
2
3
sum: 6
>>> nums = (1,2,3)#通过元祖或者列表 加* 传递
>>> add(*nums)
1
2
3
sum: 6

从上面的调用方式
args 定义的函数，可以传0个或者-个以上参数，可以通过位置参数传递，也可以传递

位置参数和可变参数*args 的解包关系

def add(num, *args): 
...     print("num:", num)
...     sum = 0
...     for arg in args: #args是个元组
...             print(arg)
...             sum += arg
...     print("sum:", sum)

当我们不传参数的时候，程序会报错，因为第一个是必传位置参数，所以不传会抛出异常

>>> add()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: add() missing 1 required positional argument: 'num'

当我们传递一个参数的时候，程序正常执行，num 获取到传入的参数值，args 没有取到值

>>> add(1)
num: 1
sum: 0

当我们传递三个参数的时候，程序正常执行，num 获取到第一个参数值，args 取到第一个以后参数

>>> add(1, 2)
num: 1
2
sum: 2

当我们传递一个元祖的时候，程序正常执行，num 获取到第一个参数值，args 取到第一个以后参数

>>> add(1, 2, 3)
num: 1
2
3
sum: 5

由上可知，在使用args 定义函数时候，如果可变参数（args）之前有位置参数，解包参数会优先赋值给位置参数，剩余的变量赋值给可变参数

理解参数传递(**)双星号

>>> def fun(x, y, z):
...     print("x:", x)
...     print("y:", y)
...     print("z:", z)
... 
>>> fun(1,2,3)
x: 1
y: 2
z: 3
>>> fun(x=1,y=2,z=3)
x: 1
y: 2
z: 3
>>> fun(1,y=2,z=3)
x: 1
y: 2
z: 3

调用函数func 我们可以通过以上方式传参，我们还能有其他方式吗？有，那就是通过**

>>> nums = {"x":1,"y":2, "z":3}
>>> fun(**nums)
x: 1
y: 2
z: 3
>>> nums = {"y":2, "z":3}
>>> fun(1, **nums)
x: 1
y: 2
z: 3

我们可以把参数封装成字典，然后通过**nums 的方式传给函数func，实现原理是啥？
* 是解包赋值给位置参数
** 是解包赋值给关键词参数（关键词参数参考前文）

**kwargs 键值可变参数的定义

用”**kwargs”定义函数,kwargs接收除常规参数列表以外的键值参数字典
如果我们需要传递键值可变参数就如下定义函数

def func(**kwargs):
>>> def func(**kwargs):
...     for key, value in kwargs.items(): #kwargs 是一个字典
...             print("key:", key, " value:", value)

我们通过**kwargs代表接收一个可变参数字典，那如何调用可变参数字典的函数呢

>>> func(a=1,b=2)
key: a  value: 1
key: b  value: 2
>>> nums = {"a": 1, "b": 2}
>>> func(**nums)
key: a  value: 1
key: b  value: 2

从上面的调用方式
**kwargs 定义的函数，可以通过关键词参数传递，也可以**字典传递

6. 可变参数的混合调用和定义

位置参数、默认参数、可变参数的混合使用，基本原则是：先位置参数，默认参数， 非键值可变参数（args），键值可变参数(kwargs)

def func(required_arg, default_arg=None, *args, **kwargs):
    pass
    #  required_arg 必传位置参数
    #  default_arg 默认参数
    # *args 非键值可变参数
    # **kwargs 键值可变参数

args和*kwargs 的区别

>>> def func(*args, **kwargs):
...     print("args:", args)
...     print("kwargs", kwargs)
>>> func(1,2)
args: (1, 2)
kwargs {}
>>> func(a=1, b=2)
args: ()
kwargs {'a': 1, 'b': 2}
>>> func(1,2,a=1, b=2)
args: (1, 2)
kwargs {'a': 1, 'b': 2}

可以看到，*args 表示任何多个非键值参数，它是一个tuple；**kwargs 表示关键字参数，它是一个dict。并且同时使用*args和**kwargs时，必须*args参数列要在**kwargs前，像func(a=1, b='2',1,2 )这样调用的话，会提示语法错误“SyntaxError: non-keyword arg after keyword arg”

*args与位置参数和默认参数混用

args与位置参数和默认参数混用:args要放到位置参数后

>>> def func(*args, **kwargs):
...     print("args:", args)
...     print("kwargs", kwargs)

**kwargs与位置参数和默认参数混用

**kwargs 要放在默认参数之后

正确定义
def func(a,  b=1,**kwargs):
...     print("a:", a)
...     print("b:", b)
...     print("args:", args)
错误定义
def func(a, **kwargs， b=1):
...     print("a:", a)
...     print("b:", b)
...     print("args:", args)
... 
SyntaxError: invalid syntax

总结

了解函数4种参数传递方式，位置参数，关键词参数，默认参数，可变参数
理解*（单星号），**（双星号）的传参方式
* args和** kwargs是特殊关键字函数可以将可变长度参数。
* args通过数量可变的non-keyworded参数列表和列表的操作可以执行。
* * kwargs通过变量数量的关键字参数字典功能字典可以执行的操作。
注意：不同的类型的参数定义和传递都是有顺序要求的