一.不使用函数的问题
1，代码的组织结构不清晰，可读性差
2，遇到重复的功能只能重复编写实现代码，代码冗余
3，功能需要扩展时，需要找出所有实现该功能的地方修改，无法统一管理且维护难度极大
二.函数是什么？
函数就是具备某一功能的工具------可以重复使用，需要先定义
事先准备工具的过程-------函数的定义
拿来就用-----函数的调用
三.函数的分类
1.内置函数---python解释器已经定义好的函数
2.自定义函数---根据需求，事先定制好的，实现某种功能的函数
四.如何定义函数？
语法：
def 函数名（参数1，参数2，参数3，....）
'''文档描述'''
函数体
return 返回的值
def：定义函数的关键字
函数名：用来调用函数的。函数名要能反映其意义
文档描述：推荐写，增强函数的可读性
函数体：函数的功能实现代码
return：函数的返回值
1 def auth(user:str,password:str)->int: 2 ''' 3 auth function 4 :param user: 用户名 5 :param password: 密码 6 :return: 认证结果 7 ''' 8 if user == 'egon' and password == '123': 9 return 1
五，函数使用的原则：先定义，再调用
5.1 函数即‘变量’，‘变量’必须先定义后引用。没有定义而直接引用函数，就相当于在引用一个
不存在的变量名
#测试一 def foo(): print('from foo') bar() foo() #报错 #测试二 def bar(): print('from bar') def foo(): print('from foo') bar() foo() #正常
结论：函数的使用，必须遵循原则：先定义，后调用
在使用函数时，一定要明确区分定义阶段和调用阶段
##定义阶段
def foo（）
print（‘from foo’）
##调用阶段：函数名加括号就是在调用函数
foo（）
5.2函数在定义阶段只检测语法，不执行代码
语法错误在函数的定义阶段就会被检测出来，而代码的逻辑错误只有在执行时才会知道
六，定义函数的三种形式
#1、无参：当函数的代码逻辑不需要函数的调用者参入值，应用场景仅仅只是执行一些操作，比如与用户交互，打印
#2、有参：需要根据外部传进来的参数，才能执行相应的逻辑，比如统计长度，求最大值最小值、
#3.空函数：设计代码结构
结论：
#1、定义时无参，意味着调用时也无需传入参数
#2、定义时有参，意味着调用时也必须传入参数
七.函数的调用
1.调用函数-----函数名加括号就是在调用函数
1.先找到名字 2.根据名字调用函数
2.函数的返回值
无return-----相当于返回None
return后跟一个值，返回该值本身
return 逗号分隔多个值----返回元组
###调用函数，需要一个明确的结果，则必须要有返回值，有参函数需要有返回值
###调用函数，不需要什么明确的结果，则不需要有返回值，通常无参函数不需要返回值
3.函数调用的三种形式
1，语句形式：foo(） 2，表达式形式：3*len（‘hello’） 3，当中另外一个函数的参数：range（len('hello'))
八，函数的参数
1，形参与实参
#形参（形式参数）
指的是在定义函数是，括号内定义的参数，形参其实就是变量名，
#实参（实际参数）
指的是在调用函数时，括号内传入的值，实参其实就是变量值，
注意：实参值和形参的绑定关系，函数调用时，将值绑定到变量名上，关系生效，函数调用结束，解除绑定
2，具体应用******************
1.位置参数：按照从左到右的顺序定义的参数
位置形参：定义函数时，按照位置定义的形参，称为位置形参
特点：调用函数时必须为其传值，不能多也不能少
位置实参：调用函数时，按照位置定义的实参，称为位置实参
注意：位置实参会与形参一一对应
2.关键字参数
在调用函数时，按照key=value的形式定义的实参，称为关键字参数
注意的问题：
1，相当于指名道姓的为形参传值，即使不按照顺序定义，仍然能为指定的参数传值
2，调用函数时，位置实参与关键字实参可以混合使用，但是必须
2.1.关键字实参必须在位置实参右面
2.2对于一个形参不能重复传值
2.3遵循形参的规则
3.默认参数：在定义阶段就已经为某个形参赋值，那么该形参就称为默认参数
1，定义阶段已经有值，以为着调用阶段可以不传值
2，位置形参必须在默认参数前面
3，默认参数的值只在定义阶段赋值一次，也就是说默认参数的值在定义阶段就固定了
4，默认参数的值应该设置为不可变类型
4，可变长参数
可变长指的是实参值得个数不固定
而实参有按照位置和安装关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放他们，分别是*args，**kwargs
形参里面包含*和**
*会将溢出的位置实参全部接收，然后保存成元组的形式赋值给args
**会将溢出的关键字实参全部接收，然后保存成字典的形式赋值给kwargs
实参里面包含*和**
一旦碰到实参加*或者**，就把实参的值打散
===========*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=========== 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})
组合使用：
调用的是wrapper函数，但是实际遵循的是foo函数的规则
===========*args+**kwargs=========== def foo(x,y): print(x,y) def wrapper(*args,**kwargs): print('====>') foo(*args,**kwargs)
5，命名关键字参数：*后定义的参数，必须被传值（有默认的除外），且必须按照关键字实参的形式传递--可以保证，传入的参数中一定包含某些关键字