二、关键字参数
用于函数调用，通过“键-值”形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。
# 以下是用关键字参数正确调用函数的实例
# print_hello('tanggu', sex=1)
# print_hello(1, name='tanggu')
# print_hello(name='tanggu', sex=1)
# print_hello(sex=1, name='tanggu')
# 以下是错误的调用方式
# print_hello(name='tanggu', 1)
# print_hello(sex=1, 'tanggu')
通过上面的代码，我们可以发现：有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序的
y = 2
非关键字可变长参数（元组）
在定义函数时，我们有时候并不知道调用的时候会传递多少个参数。这时候，包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会非常有用。
下面是包裹位置传递的例子：
def func(*name):
print (type(name))
print (name)
func(1,4,6)
func(5,6,7,1,2,3)
#两次调用，尽管参数个数不同，都基于同一个func定义。在func的参数表中，所有的参数被name收集，根据位置合并成一个元组(tuple)，这就是包裹位置传递。
#name是包裹位置传递所用的元组名，在定义func时，在name前加*号。
包裹关键字传递
例子：
def func(**dict):
print type(dict)
print dict
func(a=1,b=9)
func(m=2,n=1,c=11)
#与上面一个例子类似，dict是一个字典，收集所有的关键字，传递给函数func。
#参数dict是包裹关键字传递所用的字典，在dict前加**。包裹传递的关键在于定义函数时，在相应元组或字典前加*或**。
python函数的参数使用
python函数的参数类似于C++中的形参，传递的只是参数的拷贝。
而函数的默认参数也会被保存为一个变量，并且是全局静态变量。
六、位置参数、默认参数、可变参数的混合使用
基本原则是：先位置参数，默认参数，包裹位置，包裹关键字(定义和调用都应遵循)
def func(name, age, sex=1, *args, **kargs):
print name, age, sex, args, kargs
# func('tanggu', 25, 2, 'music', 'sport', class=2)
# tanggu 25 1 ('music', 'sport') {'class'=2}
Python中 *args 和 **kwargs
的区别
先来看个例子：
def foo(*args, **kwargs):
print 'args = ', args
print 'kwargs = ', kwargs
print '---------------------------------------'
if __name__ == '__main__':
foo(1,2,3,4)
foo(a=1,b=2,c=3)
foo(1,2,3,4, a=1,b=2,c=3)
foo('a', 1, None, a=1, b='2', c=3)
输出结果如下：
args = (1, 2, 3, 4)
kwargs = {}
---------------------------------------
args = ()
kwargs = {'a': 1, 'c': 3, 'b': 2}
---------------------------------------
args = (1, 2, 3, 4)
kwargs = {'a': 1, 'c': 3, 'b': 2}
---------------------------------------
args = ('a', 1, None)
kwargs = {'a': 1, 'c': 3, 'b': '2'}
可以看到，这两个是Python中的可变参数。*args 表示任何多个无名参数，它是一个tuple；**kwargs 表示关键字参数，它是一个dict。并且同时使用*args和**kwargs时，必须*args参数列要在**kwargs前，像foo(a=1, b='2', c=3, a', 1, None, )这样调用的话，会提示语法错误“SyntaxError: non-keyword arg after keyword arg”。
知道*args和`**kwarg是什么了吧。还有一个很漂亮的用法，就是创建字典：
def kw_dict(**kwargs):
return kwargs
print kw_dict(a=1,b=2,c=3) == {'a':1, 'b':2, 'c':3}
其实python中就带有dict类，使用dict(a=1,b=2,c=3)即可创建一个字典了。
[‘END’, ‘END’]
可变长度的参数
python进阶教程之函数参数的多种传递方法，python进阶教程
我们已经接触过函数(function)的参数(arguments)传递。当时我们根据位置，传递对应的参数。我们将接触更多的参数传递方式。
回忆一下位置传递：
复制代码 代码如下:
def f(a,b,c):
return a+b+c
print(f(1,2,3))
在调用f时，1，2，3根据位置分别传递给了a,b,c。
关键字传递
有些情况下，用位置传递会感觉比较死板。关键字(keyword)传递是根据每个参数的名字传递参数。关键字并不用遵守位置的对应关系。依然沿用上面f的定义，更改调用方式：
复制代码 代码如下:
print(f(c=3,b=2,a=1))
关键字传递可以和位置传递混用。但位置参数要出现在关键字参数之前：
复制代码 代码如下:
print(f(1,c=3,b=2))
参数默认值
在定义函数的时候，使用形如a=19的方式，可以给参数赋予默认值(default)。如果该参数最终没有被传递值，将使用该默认值。
复制代码 代码如下:
云顶娱乐平台：python:函数说明。def f(a,b,c=10):
return a+b+c
print(f(3,2))
print(f(3,2,1))
在第一次调用函数f时， 我们并没有足够的值，c没有被赋值，c将使用默认值10.
第二次调用函数的时候，c被赋值为1，不再使用默认值。
包裹传递
在定义函数时，我们有时候并不知道调用的时候会传递多少个参数。这时候，包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会非常有用。
下面是包裹位置传递的例子：
复制代码 代码如下:
def func(*name):
print type(name)
print name
func(1,4,6)
func(5,6,7,1,2,3)
两次调用，尽管参数个数不同，都基于同一个func定义。在func的参数表中，所有的参数被name收集，根据位置合并成一个元组(tuple)，这就是包裹位置传递。
为了提醒Python参数，name是包裹位置传递所用的元组名，在定义func时，在name前加*号。
下面是包裹关键字传递的例子：
复制代码 代码如下:
def func(**dict):
print type(dict)
print dict
func(a=1,b=9)
func(m=2,n=1,c=11)
与上面一个例子类似，dict是一个字典，收集所有的关键字，传递给函数func。为了提醒Python，参数dict是包裹关键字传递所用的字典，在dict前加**。
包裹传递的关键在于定义函数时，在相应元组或字典前加*或**。
解包裹
*和**，也可以在调用的时候使用，即解包裹(unpacking), 下面为例：
复制代码 代码如下:
def func(a,b,c):
print a,b,c
args = (1,3,4)
func(*args)
在这个例子中，所谓的解包裹，就是在传递tuple时，让tuple的每一个元素对应一个位置参数。在调用func时使用*，是为了提醒Python：我想要把args拆成分散的三个元素，分别传递给a,b,c。（设想一下在调用func时，args前面没有*会是什么后果？）
相应的，也存在对词典的解包裹，使用相同的func定义，然后：
复制代码 代码如下:
dict = {‘a’:1,’b’:2,’c’:3}
func(**dict)
在传递词典dict时，让词典的每个键值对作为一个关键字传递给func。
混合
在定义或者调用参数时，参数的几种传递方式可以混合。但在过程中要小心前后顺序。基本原则是，先位置，再关键字，再包裹位置，再包裹关键字，并且根据上面所说的原理细细分辨。
注意：请注意定义时和调用时的区分。包裹和解包裹并不是相反操作，是两个相对独立的过程。
总结
关键字，默认值，
包裹位置，包裹关键字
解包裹
2、包裹关键字传递
def func(**kargs):
....
# func(a=1)
# func(a=1, b=2, c=3)
kargs是一个字典(dict)，收集所有关键字参数
0
位置传递
例子：
def f(a,b,c):
return a+b+c
print(f(1,2,3))
#在调用f时，1，2，3根据位置分别传递给了a,b,c。
python的参数传递问题
楼主的理解没有问题啊 .
python中函数的实参传递规则是:
标注了参数名的就要按参数名传递，打乱顺序的情况下一定要加参数名，否则会混乱的。
没有缺省的实参情况下就会依次传递，如果不够的话，后面的会自动去取自己的缺省值。
如果实参的数量比形参要多的话，就要用到带*号的参数名了。
我们已经接触过函数(function)的参数(arguments)传递。当时我们根据位置，传递对应的…
**kwargs与位置参数和默认参数混用：
def foo(x,a = 4,**kwargs): #混合使用参数
print(x)
print(a)
print(kwargs)
foo(1,y=2,z=3) #使用默认参数
1 #输出
4
{‘y’: 2, ‘z’: 3}
foo(1,5,y=2,z=3) #修改默认参数
1
5
{‘y’: 2, ‘z’: 3}
print ‘y =’, y
总结
关键字，默认值，
包裹位置，包裹关键字
解包裹
1、包裹位置传递
def func(*args):
....
# func()
# func(a)
# func(a, b, c)
我们传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是包裹位置传递。
7
正文
我们已经接触过函数，函数是可以被引用的（访问或者以其他变量作为其别名），也作为参数传入函数，以及作为列表和字典等等容器对象的元素(function)的参数(arguments)传递。
传递函数
形式参数
位置参数
默认参数
关键字变量参数
*args：
重点在*，后面的args相当于一个变量名，可以自己定义的。它的本质就是将标准调用剩下的值集中转变为元组。
#*args的运用
def foo (x,*args):
print(x)
print(args)
foo(1,2,3,4,5,6,6,'a','b') #调用函数
输出：
1—–>x
(2, 3, 4, 5, 6, 6, ‘a’, ‘b’)—–>*args
#从形参的角度
def foo(*args): # foo(x,y,z)参数个数可以至多个
print(args)
foo(1, 2, 3) # 没有个数限制
(1, 2, 3) #输出结果
#*args=*(1,2,3)
从实参的角度
def bar(x,y,z):
print(x)
print(y)
print(z)
# bar(*(1,2,3,4)) #会报错只需要3个值，但给定的实参有4个值，不能一一对应
bar(*(1,2,3)) #实参一一对应
1
2
3
>>> func(*a, **b)
形式参数
2、在传递词典字典时，让词典的每个键值对作为一个关键字参数传递给函数
def print_hello(kargs):
print kargs
# kargs = {'name': 'tanggu', 'sex', u'男'}
# print_hello(**kargs)
# {'name': 'tanggu', 'sex', u'男'}
再来看看为什么默认参数应该使用不可变对象。
会包也要解包
超复杂混合参数混用记：
从形参角度：
def foo(x,*args,a=4,**kwargs): #使用默认参数时，注意默认参数的位置要在args之后kwargs之前
print(x)
print(a)
print(args)
print(kwargs)
foo(1,5,6,7,8,y=2,z=3) #调用函数，不修改默认参数
1 #x的值
4 #a的值
(5, 6, 7, 8) #*args的值
{'y': 2, 'z': 3} ##kwargs的值
def foo(x,a=4,*args,**kwargs): ##注意：当需要修改默认参数时，要调整默认参数的位置，要放在args之前即可，但不可放在开头。
print(x)
print(a)
print(args)
print(kwargs)
foo(1,9,5,6,7,8,y=2,z=3) #调用函数，修改默认参数a为9
1 #x的值
9 #被修改后a的值
(5, 6, 7, 8) #args的值
{'y': 2, 'z': 3} #kwargs的值
从实参角度：
def foo(x,*args,a=4,**kwargs): #使用默认参数时，注意默认参数的位置要在args之后kwargs之前
print(x)
print(a)
print(args)
print(kwargs)
foo(1,*(5,6,7,8),**{"y":2,"z":3}) #调用函数，不改默认参数
1 #x的值
4 #默认a的值
(5, 6, 7, 8) #args的值
{'y': 2, 'z': 3} #kwargs的值
-------------分割线----------------------
def foo(x,a=4,*args,**kwargs): #注意：当需要修改默认参数时，要调整默认参数的位置，要放在args之前，但不可放在开头
print(x)
print(a)
print(args)
print(kwargs)
foo(1,9,10,*(5,6,7,8),**{"y":2,"z":3}) #调用函数，修改默认参数a为9
1 #x的值
9 #修改默认参数a后的值
(10, 5, 6, 7, 8) #args的值
{'y': 2, 'z': 3} #kwargs的值
小结：
位置参数：
调用函数时所传参数的位置必须与定义函数时参数的位置相同
关键字参数：
使用关键字参数会指定参数值赋给哪个形参，调用时所传参数的位置可以任意
*位置参数：可接受任意数量的位置参数(元组)；只能作为最后一个位置参数出现，其后参数均为关键字参数
**关键字参数：可接受任意数量的关键字参数(字典)；只能作为最后一个参数出现
默认参数：默认参数的赋值只会在函数定义的时候绑定一次，默认值不会再被修改
在实际的使用中，我们经常会同时用到必选参数、默认参数、可变参数和关键字参数或其中的某些。但是，需要注意的是，它们在使用的时候是有顺序的，依次是必选参数、默认参数、可变参数和关键字参数。
前言
系列文章：[传送门]
继续干起来！！
1、在传递元组时，让元组的每一个元素对应一个位置参数
def print_hello(name, sex):
print name, sex
# args = ('tanggu', '男')
# print_hello(*args)
# tanggu 男
>>> b = (4, 5, 6)
关键字传递
用位置传递会感觉比较死板。关键字(keyword)传递是根据每个参数的名字传递参数。关键字并不用遵守位置的对应关系。
例子：
print(f(c=3,b=2,a=1))
关键字传递可以和位置传递混用。但位置参数要出现在关键字参数之前：
print(f(1,c=3,b=2))
#必须存在唯一的必须参数
一、位置参数
调用函数时根据函数定义的参数位置来传递参数。
#!/usr/bin/env python
# coding=utf-8
def print_hello(name, sex):
sex_dict = {1: u'先生', 2: u'女士'}
print 'hello %s %s, welcome to python world!' %(name, sex_dict.get(sex, u'先生'))
# 两个参数的顺序必须一一对应，且少一个参数都不可以
# print_hello('tanggu', 1)
24
参数默认值
在定义函数的时候，使用形如a=19的方式，可以给参数赋予默认值(default)。如果该参数最终没有被传递值，将使用该默认值。
def f(a,b,c=10):
return a+b+c
print(f(3,2))
print(f(3,2,1))
#在第一次调用函数f时，
我们并没有足够的值，c没有被赋值，c将使用默认值10.
#第二次调用函数的时候，c被赋值为1，不再使用默认值。
三、默认参数
用于定义函数，为参数提供默认值，调用函数时可传可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）
# 正确的默认参数定义方式--> 位置参数在前，默认参数在后
def print_hello(name, sex=1):
....
# 错误的定义方式
def print_hello(sex=1, name):
....
# 调用时不传sex的值，则使用默认值1
# print_hello('tanggu')
# 调用时传入sex的值，并指定为2
# print_hello('tanggu', 2)
8
感谢及资源共享
路上走来一步一个脚印，希望大家和我一起。
感谢读者！很喜欢你们给我的支持。如果支持，点个赞。
知识来源：
系列文章： [传送门] 继续干起来！！ 正文
我们已经接触过函数，函数是可以被引用的（访问或者以其他变量作为其别名），也作为参…
四、可变参数
定义函数时，有时候我们不确定调用的时候会传递多少个参数(不传参也可以)。此时，可用包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便。
8
解包裹
*和**，也可以在调用的时候使用，即解包裹(unpacking), 下面为例：
def func(a,b,c):
print a,b,c
args = (1,3,4)
func(*args)
#所谓的解包裹，就是在传递tuple时，让tuple的每一个元素对应一个位置参数。在调用func时使用*，是为了提醒Python：我想要把args拆成分散的三个元素，分别传递给a,b,c。（设想一下在调用func时，args前面没有*会是什么后果？）
相应的，也存在对词典的解包裹，使用相同的func定义，然后：
dict = {'a':1,'b':2,'c':3}
func(**dict)
#在传递词典dict时，让词典的每个键值对作为一个关键字传递给func。
五、解包裹参数
*和**，也可以在函数调用的时候使用，称之为解包裹(unpacking)
Python: 函数参数魔法
*args与位置参数和默认参数混用：（输出元组）
#*args与位置参数和默认参数混用:*args要放到位置参数后面，默认参数要放最后。
def foo(x,*args,y = 1):
print(x)
print(y)
print(args)
foo(1,2,3,4,5,6,7,8,9,10,y=10000) #调用函数
1------->x=1
10000-------->y=10000
(2, 3, 4, 5, 6, 7, 8, 9, 10)----->args的值变成元组
**kwargs（输出字典）
重点在**，后面的kwargs相当于一个变量名，可以自己定义的。它的本质就是将关键字调用剩下的值集中转变为字典。
def foo(x,**kwargs): #kwargs = {'y':1,'z': 2}
print(x)
print(kwargs)
foo(1,y=1,z=2) #调用函数
# 1-->x的值
# {'y': 1, 'z': 2} #kwargs的值，转为了一个字典
从不同角度看**kwargs：
def foo(**kwargs): #foo(x=1,y=2,z=3)参数个数可以一个至多个
print(kwargs)
foo(x=1,y=2,z=3) #调用函数，没有个数限制
{'x': 1, 'y': 2, 'z': 3} ----->输出字典
--------------分割线-------------------------
def foo(x,y,z):
print(x)
print(y)
print(z)
# foo(**{'x' : 1,'y' : 2, 'z' : 3,"a":4 })#TypeError: foo() got an unexpected keyword argument 'a',报错原因是函数foo只有3个值(x,y,z)
foo(**{'x' : 1,'y' : 2, 'z' : 3}) #三个值正好匹配
1#输出结果
2
3
3
3
8
*args 和 **kwargs 是 Python 的惯用写法。
11
默认参数是指在定义函数的时候提供一些默认值，如果在调用函数的时候没有传递该参数，则自动使用默认值，否则使用传递时该参数的值。
…
1
9
… print x + y + z
print ‘z =’, z
[1, 2, 3, ‘END’]
5
>>> add(dict1[‘x’], dict1[‘y’], dict1[‘z’]) #
这样传参很累赘
z = 3
>>> a = [1, 2]
4
>>> def add(**kwargs):
2
… return x + y + z
5
必选参数
1
y = 2
{}
5
3
26
21
y = 2
>>>
28
SyntaxError: non-default argument follows default argument
y = 2
z = 3
z = 4
4
1
6
3
4
>>> def add(x, y, z=1): # x, y 是必选参数，z
是默认参数，默认值是 1
Traceback (most recent call last):
6
{‘x’: 1}
print ‘x =’, x
13
25
6
5
8
11
y = 2
3
5
1
我们看一个例子：
3
z = 3
参数组合在使用的时候是有顺序的，依次是必选参数、默认参数、可变参数和关键字参数。
12
SyntaxError: non-default argument follows default argument
2
12
7
>>> a = (1, 2, 3)
>>> add() # 传递 0 个参数
14
10
>>> def add(*numbers): # 函数参数是可变参数
9
…
>>> def add(x, y, z): # 有 3 个必选参数
9
6
7
… return x + y + z
>>> add(**dict1) # 使用 **dict1
来传参，等价于上面的做法
x = 1
print ‘args =’, args
…
可变参数
>>> dict1 = {‘z’: 3, ‘x’: 1, ‘y’: 6}
再看一个例子：
3
File “”, line 1
… return x + y + z
11
默认参数
10
z = 3
>>> a = [1, 2, 3, 4]
>>> dict2 = {‘x’: 2, ‘y’: 6}
File “”, line 1
5
kwargs = {}
10
print ‘kwargs =’, kwargs
… return sum
Traceback (most recent call last):
7
args = (4, 5)
再看一个例子：
7
args = ()
6
4
应该使用不可变对象作为函数的默认参数。
6
默认参数要放在所有必选参数的后面。
2
默认参数
必选参数
3
>>> def func(x, y, z=0, *args, **kwargs):
4
>>> add_to_list() #
没有传递参数，使用默认值，竟出现两个 ‘END’
return kwargs
让我们看看例子：
在调用函数时，我们可以给该函数传递任意个参数，包括 0 个参数：
12
args = (4, 5, 6)
3
2
… return x + y + z
5
11
7
y = 2
看看例子就明白了：
8
1
4
>>> sum() # 没有参数
5
File “”, line 1, in
x = 1
7
11
6
1
比如，下面对默认参数的使用是错误的：
>>> add_to_list([1, 2, 3]) # 没啥问题
11
args = ()
…
1
2
… L.append(‘END’)
函数的参数 – 廖雪峰的官方网站
2
15
… print x + y
2
16
1
在上面的代码中，numbers 就是一个可变参数，参数前面有一个 *
号，表示是可变的。在函数内部，参数 numbers 接收到的是一个 tuple。
9
2
6
… sum = 0
>>> add(x=1) # x=1 => kwargs={‘x’: 1}
10
3
可变参数
8
看看例子：
原来，L 指向了可变对象 []，当你调用函数时，L
的内容发生了改变，默认参数的内容也会跟着变，也就是，当你第一次调用时，L
的初始值是 []，当你第二次调用时，L 的初始值是 [‘END’]，等等。
>>> add(1, 2) # 传递 2 个参数
7
0
17
5
3
… sum += i
1
5
8
4
… return sum
1
10
numbers: ()
… sum = 0
13
>>> add() # 没有参数，kwargs 为空字典
[‘END’, ‘END’, ‘END’]
关键字参数
2
>>> def add_to_list(L=[]):
可以看到，默认参数使用起来也很简单，但有两点需要注意的是：
>>> add(1, 2, 3) # 传递 3 个参数
9
>>> func(1, 2, 3) # x=1, y=2, z=3
默认参数要放在所有必选参数的后面
6
kwargs = {}
8
>>> func(1, 2) # 至少提供两个参数，因为 x,
y 是必选参数
22
TypeError: add() takes exactly 2 arguments (0 given)
比如，定义一个包含上述四种参数的函数：
默认参数应该使用不可变对象
numbers: (1,)
1
TypeError: add() takes exactly 2 arguments (1 given)
5
和可变参数类似，我们也可以使用 **kwargs 的形式来调用函数，比如：
我们来看看使用：
4
2
在调用函数的时候，Python
会自动按照参数位置和参数名把对应的参数传进去。让我们看看：
>>> add(1, 2) # 没有传递 z，自动使用 z=1，即
1+2+1
1
>>> sum(**dict2) # 相当于 sum(x=2, y=6)
3
10
3
18
8
上面的 * 表示任意参数，实际上，它还有另外一个用法：用来给函数传递参数。
2
[‘END’]
9
9
函数参数
>>> add_to_list() #
没有传递参数，使用默认值，也没啥问题
File “”, line 1, in
27
4
4
… sum += i
kwargs = {}
13
3
>>> func(1, 2, 4, u=6, v=7) # args = (), kwargs = {‘u’:
6, ‘v’: 7}
12
6
6
6
numbers: (1, 2, 3)
15
[‘a’, ‘b’, ‘c’, ‘END’]
>>> dict1 = {‘x’: 1}
… for i in numbers:
为啥呢？我们在调用函数的时候没有传递参数，那么就默认使用
L=[]，经过处理，L 应该只有一个元素，怎么会出现调用函数两次，L
就有两个元素呢？
3
x = 1
{‘y’: 2, ‘x’: 1}
>>> def add(x, y, z):
30
kwargs = {‘u’: 6, ‘v’: 7}
>>> add(*a) # 使用 *a 给函数传递参数
>>> func(1, 2, 3, 4, 5, 6) # x=1, y=2, z=3, args=(4,
5, 6), kwargs={}
4
>>> def add(x=1, y, z): # x
是默认参数，必须放在所有必选参数的后面
… print ‘numbers:’, numbers
kwargs = {‘u’: 6, ‘v’: 7}
10
1
6
29
kwargs = {‘u’: 6, ‘v’: 7}
5
args = ()
10
>>> add(1) # 只传了一个，也不行
args = ()
1
4
6
… return sum
>>> a = [1, 2, 3]
args 和 *kwargs · Python进阶
5
参考资料
x = 1
>>> add(1, 2, 3) # 1+2+3
7
2
10
3
在上面的代码中，kwargs 就是一个关键字参数，它前面有两个 * 号。kwargs
可以接收不定长度的键值对，在函数内部，它会表示成一个 dict。
19
2
2
6
>>> sum(**dict1) # 相当于 sum(x=1)
>>> add(*a) # 使用 *a，相当于上面的做法
关键字参数
>>> add() # 啥都没传，不行
7
…
>>> def sum(**kwargs): # 函数参数是关键字参数
… for i in numbers:
在上面的函数中，L 是一个默认参数，默认值是 []，表示空列表。
8
可变参数允许你将不定数量的参数传递给函数，而关键字参数则允许你将不定长度的键值对,
作为参数传递给一个函数。
11
>>> def add(x, y=1, z): # y
是默认参数，必须放在所有必选参数的后面
numbers: (1, 2)
小结
在某些情况下，我们在定义函数的时候，无法预估函数应该制定多少个参数，这时我们就可以使用可变参数了，也就是，函数的参数个数是不确定的。
6
23
5
2
10
>>> add(1, 2) # 数量一致，通过
8
所以，为了避免不必要的错误，我们应该使用不可变对象作为函数的默认参数。
3
6
x = 1
4
… for k, v in kwargs.items():
10
12
1
>>> def add(*numbers):
7
… sum += v
>>> add(*b) # 对元组一样适用
>>> add_to_list() # 糟糕了，三个 ‘END’
2016-12-01
参数组合
>>> def add(x, y): # x, y 是必选参数
6
>>> add(*a)
… return L
>>> add(x=1, y=2) # x=1, y=2 => kwargs={‘y’: 2, ‘x’: 1}
7
必选参数可以说是最常见的了，顾名思义，必选参数就是在调用函数的时候要传入数量一致的参数，比如：
4
>>> add_to_list([‘a’, ‘b’, ‘c’]) # 没啥问题
…
1
>>> b = {‘u’: 6, ‘v’: 7}
>>> func(1, 2, 3, 4, 5, u=6, v=7) # args = (4, 5), kwargs =
{‘u’: 6, ‘v’: 7}
>>> add(a[0], a[1], a[2]) # 这样传递参数很累赘
9
*args 表示可变参数，**kwargs 表示关键字参数。
…
看看例子：
8
z = 0
3
在 Python
中，定义函数和调用函数都很简单，但如何定义函数参数和传递函数参数，则涉及到一些套路了。总的来说，Python
的函数参数主要分为以下几种：
20
4
x = 1
>>> add(1) # 传递 1 个参数
1
… sum = 0
我们还可以通过下面的形式来传递参数：