函数

函数的定义

封装 减少重复代码

def func():
  print('111')

函数的调用

函数 + 小括号  == 调用
 func()

函数的返回值

有return的时候,得写print(函数名)
不写return返回的是一个None
写了return不给值 返回也是None
return 可以返回随意数据 多个元素返回的都是元祖
return 可以终止这个函数
return值返回给了调用者 函数名 + 括号 就是调用者

函数的参数

形参：定义的时候

def fucn(msg,school)                 # 位置
def func(school='清华')                 # 默认参数
def func(msg,school='清华')             # 混合

实参的角度: 调用的时候

func('清华','东莞')                      位置
func(msg = '清华',school = '东莞')     关键字
func('清华',school='清华')           混合

参数的顺序: 位置参数 > 默认参数(关键字参数),在默认参数前边写位置参数
传参: 从实参到形参的过程

动态参数 与 万能参数

*args(位置动态参数) #接收所有的位置参数 获取到一个元祖
*args会把所有的都接收,位置参数接收不到内容了
*args 定义的时候是聚合
*args 使用的时候 打散
**kwargs(#动态默认参数) 接收所有关键字参数 获取到是一个字典
*kwargs 使用的时候 打散字典的键(获取的是键)

注:**是聚合,一个是打散, 两个是错的

位置大小

位置参数， > 动态位置参数* >, 默认参数, > **动态默认参数

例子：

函数注释

查看函数的注释 函数名.doc

def fun(*a):
'''
:param a:
:return:
'''
print(a)
fun(*[1,2,3])
print(fun.__doc__)

名称空间

存储变量与值的对应关系

内置名称空间　　全局名称空间　　局部名称空间

找值：从里往外　　局部空间　＞　全局空间　＞　内置空间
加载: 从外往里 内置空间 > 全局空间 > 局部空间

内置空间 + 全局空间 == 全局空间 globals() 查看全局空间的内容
局部空间 == 局部空间 locals() 查看局部空间的内容

局部空间:数据不能共享,是独立的
作用域名称空间:

global #在局部修改全局的数据，如果全局没有的时候，在局部修改的时候回创建一个

nonlocal # 在局部里,修改离它最近的上一级,上一级不存在就继续往上找

结果是10 和1

函数名使用

print(func)查看内存地址

函数可以当做值,赋值给变量 a=func
函数可以参数,传递个函数的形参 函数当参数的时候不能加括号
函数可以当返回值 当返回值的时候不括号
函数名可以元素存在容器里

闭包

def func():
    name = '宝元'    # 生命周期延长   常驻内存
    def foo():
        print(name)    (这一行的name去调用上一层的name叫闭包)
    return foo
ret = func()  # ret == foo内存地址
ret()    #  foo函数

检验闭包

Print(函数名.__closure__)  返回none就不是闭包

嵌套函数

在嵌套函数内,内部函数使用外部变量(非全局变量) 就是一个闭包 闭包可以多层

应用场景

登录校验，日志，类方法，flask路由

好处

保护变量不会被外界修改
函数内使用到的变量会生命周期延长
节省开辟空间和销毁空间的时间

作用

临时空间不会随着函数改变