这种函数是便于在别人调用的时候，如果没有传入参数的时候，采用的默认值
创新互联是一家专业提供泰安企业网站建设,专注与成都网站制作、成都做网站、H5建站、小程序制作等业务。10年已为泰安众多企业、政府机构等服务。创新互联专业网站设计公司优惠进行中。
现在你有add（a=1,b=2）的函数
我直接print add()
就可以直接输出3了
一、前言
在python中，函数参数的定义和传递有以下几种方式：
语法
意义
def func(name)
普通参数，可以根据位置匹配，也可以根据key来匹配
def func(name=value)
默认参数，当参数没有传递时，使用默认值
def func(*iteratable)
将所有剩下的未匹配的参数收集至一个tuple中
def func(**dictionary)
将剩下未匹配的参数收集值一个dict中
def func(*, name)
必须使用key来匹配参数
def func(*other, name)
必须使用key来匹配参数
func(value)
函数调用，参数值按传递的参数顺序匹配
func(name=value)
函数调用，参数值根据key来匹配
func(*iteratable)
函数调用，将iteratable容器中的参数展开，按位置匹配对应的函数参数
func(**dictionary)
函数调用，将dict中的参数展开，按key值来匹配对应的函数参数
在python中，参数可以按照顺序传递，在调用函数时，参数的值按照传递的顺序，从左到右依次匹配。并且还可以给参数传递默认值，这都很好理解，因为在C、C++、Java等许多语言中，函数的参数传递都是按照这种方法来传递的。
但python的参数定义和传递除了按照顺序传递以及可以给默认值外，它还有其它的一些特点，在进一步讲解之前，首先说明python中函数调用中参数匹配的顺序：
按照顺序，给没有key的参数赋值，意味着传递参数时，需按顺序匹配的参数必须出现在按key匹配的参数之前；
给按照key匹配的参数赋值；
将多余的按照顺序匹配但未匹配的参数值归入*name的tuple中；
将多余未匹配上的按照key进行匹配的参数值归入**name的dict对象中；
将为匹配上的且具有默认值的参数赋默认值
二、按key匹配参数
对于C、C++这种语言，在调用函数时，系统会首先将函数地址压入堆栈，其次按参数的从右往左的顺序，一次压入堆栈。因此，C、C++这种语言它们只支持按顺序匹配形参。而python的做法不同，参数除了可以按顺序匹配，还可以按照参数名称来匹配。如：
def func(name, age):
print(name, age)
对于这个函数，以下的调用时等价的：
func('rechar', 27) #按顺序匹配
func(name = 'rechar', age = 27) #按参数名称匹配，在运行时告诉系统参数name的值为‘rechar’，age的值为27
func(age = 27, name = 'rechar') #按参数名称匹配
func('rechar', age = 27) #name是按顺序匹配，age按名称匹配
在python中，当按照参数名称进行匹配参数是，参数传递的顺序是可以任意的，不要求按照函数定义中参数的顺序进行传递。在使用名称匹配时，如果需要混合使用按顺序匹配规则，则按顺序匹配的参数必须出现在按key匹配的参数前，否则会报错：
func(name = 'rechar', 27)
以上调用会报如下错误：
三、函数定义中的”*name“
python在给按顺序匹配和按key匹配的参数赋完值后，如果发现调用者传入的参数仍有未匹配上的会发生什么情况呢？看一下下面的例子：
func('rechar', 27, 32)
运行时我们看到如下错误：
Traceback (most recent call last):
File "E:\tmp\tt.py", line 5, in module
func('rechar', 27, 32)
TypeError: func() takes 2 positional arguments but 3 were given
哦，python会抱怨我们传递的参数太多了。那如果确实在一些情况下，我们无法保证传递的参数数量一定和函数需要的参数数相等怎么办呢？这是就是*iterable这种参数该登场的时候了，假如在定义函数定义是，我们增加了一个参数，这个参数以一个”*“开始，那么这个参数实际上是一个tuple类型。假如传递的参数比需要的多，那那些多余的参数会被放入这个tuple中。例如，
def func(name, age, *other):
print(name, age, other)
那么,
func('rechar', 27, 32)
这个调用的输出如下：
rechar 27 (32,)
四、函数定义中的”**name“
python在将所有未匹配上的非按名称匹配的参数装入参数中的tuple之后，假如还有未匹配上的按名称匹配的参数那情况会怎样呢？首先来看一下下面的示例：
def func(name, age):
print(name, age)
func(name = 'rechar', age = 27, pay='1800')
执行时，python又抱怨了：
Traceback (most recent call last):
File "E:\tmp\tt.py", line 5, in module
func(name = 'rechar', age = 27, pay='1800')
TypeError: func() got an unexpected keyword argument 'pay'
它说func这个函数没有名称为”pay“的参数，这种情况或许出现在我们函数重构之后，原来函数时有这个参数的。而这个函数调用可能在别处没有被修改。假设即使给了”pay“这个参数，程序的正确性不受影响，没错，这就是”**name“参数的用武之地了。
假如在函数定义中，给函数增加一个以”**“开头的参数，那么这个参数实际上是一个dict对象，它会将参数调用中所有没有被匹配的按名称传递的参数都放入这个dict中。例如，
def func(name, age,**other):
print(name, age, other)
func(name = 'rechar', age = 27, pay='1800')
那么运行结果输出，
rechar 27 {'pay': '1800'}
看到了吧，这里的other就将没有匹配的”pay=‘1800’“收入囊中了。
五、规定调用必须按名称匹配
当我们在定义函数时，如果第一个参数就是”*name“参数，那么可想而知，我们无法使用按顺序匹配的方式传递，因为所有的按顺序传递的参数值最终的归宿都会是这里的tuple当中。而为了给后续的参数传递值，我们只能使用按名称匹配的方法。
六、”**“参数只能出现在最后一个形参之后
想想为什么?其实很好理解，因为出现在”**“形参之后的形参，无论使用按顺序传递还是按名称传递，最终都无法到达参数值真正应该需要到的地方。所以python规定，如果需要”**“参数，那它必须是最后一个形参。否则python会报语法错误。
七、函数调用中的”*“
在表格中我们看到了有func(*iteratable)的调用，这个调用的意思是，iteratable必须是一个可迭代的容器，比如list、tuple；作为参数传递值，它最终传递到函数时，不是以一个整体出现，而是将其中的元素按照顺序传递的方式，一次赋值给函数的形参。例如，
li = ['rechar', 27]
func(*li)
这个函数调用与
func('rechar', 27)
是等价的。
八、函数调用中的”**“
知道”*“在函数调用中的效果之后，也就很好理解”**“的作用了。它是将传递进来的dict对象分解，每一个元素对应一个按名称传递的参数，根据其中的key对参数进行赋值。
python 的函数参数类型分为4种：
1.位置参数：调用函数时根据函数定义的参数位置来传递参数，位置参数也可以叫做必要参数，函数调用时必须要传的参数。
当参数满足函数必要参数传参的条件，函数能够正常执行：
add(1,2) #两个参数的顺序必须一一对应，且少一个参数都不可以
当我们运行上面的程序,输出:
当函数需要两个必要参数，但是调用函数只给了一个参数时，程序会抛出异常
add(1)
当我们运行上面的程序,输出：
当函数需要两个必要参数，但是调用函数只给了三个参数时，程序会抛出异常
add(1,2,3)
当我们运行上面的程序,输出
2.关键字参数：用于函数调用，通过“键-值”形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。
add(1,2) # 这种方式传参，必须按顺序传参：x对应1，y对应:2
add(y=2,x=1) #以关健字方式传入参数（可以不按顺序）
正确的调用方式
add(x=1, y=2)
add(y=2, x=1)
add(1, y=2)
以上调用方式都是允许的，能够正常执行
错误的调用方式
add(x=1, 2)
add(y=2, 1)
以上调用都会抛出SyntaxError 异常
上面例子可以看出：有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序的
3.默认参数：用于定义函数，为参数提供默认值，调用函数时可传可不传该默认参数的值，所有位置参数必须出现在默认参数前，包括函数定义和调用，有多个默认参数时，调用的时候，既可以按顺序提供默认参数，也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上
默认参数的函数定义
上面示例第一个是正确的定义位置参数的方式，第二个是错误的，因为位置参数在前，默认参数在后
def add1(x=1,y) 的定义会抛出如下异常
默认参数的函数调用
注意：定义默认参数默认参数最好不要定义为可变对象，容易掉坑
不可变对象：该对象所指向的内存中的值不能被改变，int,string,float,tuple
可变对象，该对象所指向的内存中的值可以被改变，dict,list
这里只要理解一下这个概念就行或者自行百度，后续会写相关的专题文章讲解
举一个简单示例
4.可变参数区别:定义函数时，有时候我们不确定调用的时候会多少个参数,j就可以使用可变参数
可变参数主要有两类：
*args: (positional argument) 允许任意数量的可选位置参数(参数),将被分配给一个元组, 参数名前带*，args只是约定俗成的变量名，可以替换其他名称
**kwargs：(keyword argument) 允许任意数量的可选关键字参数，,将被分配给一个字典，参数名前带**，kwargs只是约定俗成的变量名，可以替换其他名称
*args 的用法
args 是用来传递一个非键值对的可变数量的参数列表给函数
语法是使用 符号的数量可变的参数; 按照惯例,通常是使用arg这个单词，args相当于一个变量名，可以自己定义的
在上面的程序中,我们使用* args作为一个可变长度参数列表传递给add()函数。 在函数中,我们有一个循环实现传递的参数计算和输出结果。
还可以直接传递列表或者数组的方式传递参数,以数组或者列表方式传递参数名前面加（*） 号
理解* * kwargs
**kwargs 允许你将不定长度的键值对, 作为参数传递给函数，这些关键字参数在函数内部自动组装为一个dict
下篇详细讲解 *args, **kwargs 的参数传递和使用敬请关注
上一期我们学习参数传递怎么传递，也了解了参数的几种类型。
首先，我们再来回顾一下，形参和实参:
形参是在定义函数时定义的，放在函数名后面的圆括号里,可为空
实参是调用函数时为形参传入具体的参数值
简单总结一下，谁调用函数，谁就负责传入参数。
好呐，本期我们来详细学习函数几种参数类型，大纲如下：
python函数的参数名是无意义的，Python允许在调用函数时通过通过名字来传入参数值。
位置参数：按照形参位置传入的参数
调用函数时，实参默认按位置顺序传递的。同时实参个数也要和形参匹配
举一个小栗子
如果实参的个数与形参不匹配时，调用函数运行就会报错
Python中，形参与调用函数紧密联系在一起的。
关键字参数：调用函数时，使形参名称来传递参数，形式为“形参名=实参”
关键字参数，又叫命名参数，传递时无需考虑参数位置和顺序
举一个小栗子
默认参数：定义函数时，我们可以为形参提前设置具体的值。
在定义函数时，默认参数要放到位置等其他参数后面
在调用函数时，默认参数是可选的。如果传入新值，则会覆盖默认值
举一个小栗子
注意，默认值不能位于位置参数前面，否则程序会报错误
不定长参数又名可变参数。
不定长参数指的是可变数量的参数，分两种情况：
如果不定长参数后面，可以新增参数吗？
我们通过例子来看,会发生什么？
运行上面的程序，Python解释器会报错
原因是，形参a已经是不定长参数，我们调用的test(2,3,4)传入的三个实参,系统自动把它们属于形参a的值，形参b 和形参c就等于没有值传入，这时候系统就认为，调用函数的对象，参数没有传够。
为了解决这一报错，python引入了 强制命名参数
规定，调用不定参数后面有跟位置参数的函数时，传入给位置参数时，必须要强制命名参进行传参。
逆向参数收集针对的对象传入函数的实参
调用函数时，如果实参是元组，列表或者字典，通过在实参前面加入星号，可以自动把元素进行隔开，然后再转入给函数进行处理
举一个小栗子
本期，我们详细学习了参数几种类型，为后面我们学习函数，打好基础。
实践是检验真理的过程，大家多动手练习练习，会有不一样的奇妙旅程~
好呐，以上是本期内容，欢迎大佬们评论区指正~
#Python 2.5
#这个可以用修饰器来完成
#但是一般不会限制参数类型
#给你个思路:
def argfilter(*types):
def deco(func):
#这是修饰器
def newfunc(*args):
#新的函数
if len(types)==len(args):
correct = True
for i in range(len(args)):
if not isinstance(args[i], types[i]):
#判断类型
correct = False
if correct:
return func(*args)
#返回原函数值
else:
raise TypeError
else:
raise TypeError
return newfunc
#由修饰器返回新的函数
return deco
#返回作为修饰器的函数
@argfilter(int, str)
#指定参数类型
def func(i, s):
#定义被修饰的函数
print i, s
#之后你想限制类型的话, 就这样:
#@argfilter(第一个参数的类名, 第二个参数的类名, ..., 第N个参数的类名)
#def yourfunc(第一个参数, 第一个参数, ..., 第N个参数):
#
...
#
#相当于:
#def yourfunc(第一个参数, 第一个参数, ..., 第N个参数):
#
...
#yourfunc = argfilter(第一个参数的类名, 第二个参数的类名, ..., 第N个参数的类名)(yourfunc)
在调用函数时，通常会传递参数，函数内部的代码保持不变，针对 不同的参数处理不同的数据。
有位置传参、关键字传参、默认值参数、多值参数等。
1、参数传递
形参和实参：
形参：定义 函数时的 参数变量
实参：调用 函数时，使用的参数变量
参数传递的过程，就是 把实参的引用 传递给 形参 ，使用实参的值来执行函数体的过程。
在 Python 中，函数的 实参/返回值 都是是靠 引用 来传递来的
2、位置实参
按照参数位置，依次传递参数，这是最普通的方式。

重庆分公司
重庆分公司
