初识函数
为什么要用函数及函数的功能：
1、代码的组织结构不清晰，可读性差
2、遇到重复的功能只能重复编写实现代码，代码冗余
3、功能需要扩展时，需要找出所有实现该功能的地方修改之，无法统一管理且维护难度极大
综上所述，这就是在没有函数的情况下，编程会遇到的问题，而函数就是用来解决这些问题的；当在编程过程中对于
一些经常使用到的功能，就可以利用函数进行封装、调用，而不必重复的写相同的代码。简单的说具备某一功能的工具
就是程序中的函数，事先封装的过程就是函数的定义，然后再将函数调用过来。
函数使用必须遵循：先定义，再调用的原则。没有事先定义函数而直接调用，就相当于再引用一个不存在的变量名。（只要是在调用之前定义就没毛病）
定义阶段：在定义阶段只检测语法，不执行函数体代码。
调用阶段：根据函数名找到函数的内存地址。（函数名+（）就是在调用函数）
函数分类
1、内置函数
为了方便我们的开发，针对一些简单的功能，python解释器已经为我们定义好了的函数即内置函数。对于内置函数，我们可以拿来就用而无需事先定义，如len(),sum(),max()
ps：我们将会在最后详细介绍常用的内置函数。
2、自定义函数
很明显内置函数所能提供的功能是有限的，这就需要我们自己根据需求，事先定制好我们自己的函数来实现某种功能，以后，在遇到应用场景时，调用自定义的函数即可。
用一句不严谨的话说“函数即变量。”
自定义函数格式：
def 函数名(参数1,参数2,参数3,...):
'''注释'''
函数体
return 返回的值
#函数名要能反映其意义
定义函数的三种类型
1、有参函数：参数是函数体代码用来接收外部传入值的。
2、无参函数：当函数体的代码逻辑不需要函数的调用者掺入值的情况下，就无参。
3、空函数：函数体为pass
def func ( ) :
pass
占位作用，想好之后再写入功能
调用函数的三种形式：
1 语句形式：foo()
2 表达式形式：3*len('hello')
3 当中另外一个函数的参数：range(len('hello'))
函数返回值（return）
无return->None
return 1个值->返回1个值
return 逗号分隔多个值->元组（返回的就是多个值）
return注意点：
1、return返回值的值，没有类型限制。
2、return是函数结束的标志，函数内可以写多个return，但执行一次，函数立刻结束，并把return后的值作为本次调用的返回值。
函数参数
形参与实参
#形参即变量名，实参即变量值，函数调用时，将值绑定到变量名上，函数调用结束，解除绑定。
形参（形式参数），指的是在定义函数时，括号内定义的参数。
实参（实际参数），指的是在调用函数时，括号内传入的值，实参其实就是变量值。
注意：实参值（变量的值）与形参（变量名）的绑定关系只在函数调用时才会生效，调用完毕后
就结束。
具体应用
位置参数：位置即顺序，位置参数指的就是按从左到右的顺序依次定义的顺序
位置形参：必选参数
位置实参：按照位置给形参传值
注意：位置参数的特性是：在调用函数时必须为其传值，且多一个不行，少一个
也不行；位置实参会与形参一一对应。
关键字参数：在调用函数时，按照key=value的形式定义的实参，称为关键字参数。
相当于指名道姓地为形参传值，意味着即便是不按照顺序定义，仍然能够为指定的
参数传值。
在调用函数时，位置实参与关键字实参可以混合使用，但注意以下三点：
1、必须遵循形参的规则
foo(1,2=3,y=2)
foo(1,2=3)
2、不能为同一个形参重复传值
3、位置实参必须放到关键字实参的前面
默认参数：在定义阶段，已经为某个形参赋值，那么该形参就称为默认参数。注意：定义阶段已经有
值，意味着调用阶段可以不传值。
应用：对于经常变化的值，需将对应形参定义成位置形参
对于大多情况一样，需将对应形参定义默认形参
注意的问题：
1. 只在定义时赋值一次，也就是说默认参数的值在定义阶段就固定死了。
2. 默认参数的定义应该在位置形参右面
3. 默认参数通常应该定义成不可变类型（如果可变会不断在里面添加值）
可变长度参数：可变长度指的参数的个数可以不固定，实参有按位置定义的实参和按关键字定义的
实参，所以可变长的实参指的就是按照这两种形式定义的实参个数可以不固定，然而实参终究是要
给形参传值的。
而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地
存放它们，分别是*args，**kwargs。
*会将溢出的位置实参全部接收，然后保存成元组的形式赋值给args
===========*args===========
def foo(x,y,*args):
print(x,y)
print(args)
foo(1,2,3,4,5)
def foo(x,y,*args):
print(x,y)
print(args)
foo(1,2,*[3,4,5])
def foo(x,y,z):
print(x,y,z)
foo(*[1,2,3])
一旦碰到实参加*，就把该实参的值打散
**会将溢出的关键字实参全部接收，然后保存成字典的形式赋值给kwargs
===========**kwargs===========
def foo(x,y,**kwargs):
print(x,y)
print(kwargs)
foo(1,y=2,a=1,b=2,c=3)
def foo(x,y,**kwargs):
print(x,y)
print(kwargs)
foo(1,y=2,**{'a':1,'b':2,'c':3})
def foo(x,y,z):
print(x,y,z)
foo(**{'z':1,'x':2,'y':3})
并且*args+**kwargs可以混合使用
===========*args+**kwargs===========
def foo(x,y):
print(x,y)
def wrapper(*args,**kwargs):
print('====>')
foo(*args,**kwargs)
命名关键字参数：*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递
可以保证，传入的参数中一定包含某些关键字
def foo(x,y,*args,a=1,b,**kwargs):
print(x,y)
print(args)
print(a)
print(b)
print(kwargs)
foo(1,2,3,4,5,b=3,c=4,d=5)
结果：
2
(3, 4, 5)
3
{'c': 4, 'd': 5}
