1、函数知识体系
什么是函数？
在程序中具备某一功能的工具就是函数
函数的使用原则：先定义、后调用为什么要用函数？
（1）代码冗余
（2）程序组织结构不清晰、可读性差
（3）扩展性差函数的分类：
（1）内置函数
python自带的
（2）自定义函数
自己定义的自定义函数和使用
函数的定义分为两个阶段：定义和调用
函数定义： 定义只检测语法不执行代码
def 函数名(参数1，参数2...): //必须
"""
文档注释
"""
函数代码块1 //必须
函数代码块2
...
return 值
函数调用：开始执行函数代码
函数名()
- 定义函数的三种方式
（1）无参函数
def func():
print('......')
func()
（2）有参函数
def func(x,y):
if x > y:
return(x)
else:
return(y)
res=func(1,2)
（3）空函数
def register():
pass
- 调用函数的三种形式
（1）语句模式
def func():
print('......')
func()
（2）表达式形式
def func(x,y):
if x > y:
return(x)
else:
return(y)
res=func(1,2) * 12
print(res)
（3）函数的调用可以当作另外一个函数的参数传入
def func(x,y):
if x > y:
return(x)
else:
return(y)
res=func(func(1,2),3)
print(res)
返回值的特点
（1）返回值没有类型限制，也没有个数限制
（2）return是函数结束运行的标志，函数内可以有多个return，但只要执行一次return函数就立即结束，并且将return后的值当作本次调用的结果返回。函数的参数
形参即变量名，实参即变量值，函数调用时，将值绑定到变量名上，函数调用结束，解除绑定函数参数详解
（1）形参
位置形参：按照从左至右的顺序依次定义的形参
特点：必须被传值默认参数：在定义阶段，就已经为某个形参赋值，该形参称之为默认形参
特点：在定义阶段就已经有值，意味着调用阶段不用为其传值
def func(x,y=2):
print(x,y)
func(1)
注意：位置形参与默认形参可以混用，位置形参必须放在默认形参的前面
（2）实参
位置实参：在调用阶段，按照从左到右的顺序依次传入的值
特点：这种传值方式会与形参一一对应关键字实参：在调用阶段，按照key=value的格式传值
特点：可以完全打乱位置，但仍然能为指定的形参传值
注意：
1、可以混用位置实参与关键字实参，但是同一个形参只能被赋值一次
2、位置实参必须在关键字实参的前面
（3）形参中*与**的用法
- 形参中带*，*会将溢出的位置实参存成元组的形式然后赋值其后变量名
def func(x,y,*args):
print(x,y,args)
print(1,2,3,4,5,6)
- 形参中带**；**会将溢出的关键字实参存成字典的格式然后赋值其后变量名
def func(x,y,**kwargs):
print(x,y,kwargs)
print(1,y=2,z=3,m=4,n=5)
（4）实参中* 与**的用法
- 实参中带*；先将实参打散成位置实参，然后再与形参做对应
def func(x,y,z):
print(x,y,z)
func(*[1,2,3])
func(*'llo')
- 实参中带**；先将实参打散成关键字实参，然后再与形参做对应
def func(x,y,z):
print(x,y,z)
func(**{'x':1,'z':3,'y':2}) //func(z=3,y=2,x=1)
将一个函数的参数完全转给另一个函数
def index(x,y,z)
print(x,y,z)
def wrapper(*args,**kwargs):
index(*args,**kwargs)
#以上两行意思是将一个函数的参数完全传给另一个函数
wrapper(1,2,3)
2、函数对象
函数对象：把函数的内存地址当作一种变量值去使用，函数对象不加（）；如果内存地址加（）就是在调用函数
与变量相同的用法：可以被引用、可以当作参数传递、返回值可以是函数、可以被储存到容器类型（列表、字典、元组）
独有的用法：加（）可以运行其内部代码
- 可以被引用
def func1()
print('from func')
func2=func1
func2()
- 可以当作参数传递
def func1()
print('from func')
def bar(xxx)
xxx()
bar(func1)
- 返回值可以是函数
def func1()
print('from func')
def bar()
return func1
f=bar()
f()
- 可以被储存到容器类型（列表、字典、元组）
def func1()
print('from func')
l=[func1,]
l[0]()
3、函数嵌套
嵌套调用：在一个函数中调用了另一个函数
嵌套定义：在一个函数中定义的一个函数，只能在函数里面使用，外界不能用
def func1()
print('hello')
def func2()
print('world')
func1()
func2()
----------------------------------------
world
hello
4、名称空间
名称空间：就是存储名字与内存地址绑定关系的空间
4.1 名称空间的分类：
（1）内置名称空间：存储解释器自带的变量名称与值的对应关系（print、len、max、min）；python解释器启动时创建内置名称空间，关闭解释器销毁
（2）全局名称空间：文件级别的名称，只要你的名字定义是顶着最左边（空格也算）写的就在全局空间，除了内置的和函数内的，都是全局名称空间；执行py文件创建全局名称空间，关闭解释器销毁
（3）局部名称空间：只要在函数里面就是局部的；调用函数时创建，函数执行完毕销毁
名称空间的加载顺序
内置的名称空间--->全局的名称空间---->局部的查找顺序
局部的名称空间---->全局的名称空间----->内置的名称空间总结：
1、名字的查找顺序是从当前位置往外查找
2、名称空间的嵌套关系是在函数定义阶段就固定死的，与调用位置无关。
5、作用域(作用范围)
域：指的是区域，范围的意思
全局的名称空间和内置的名称空间，在使用上没有什么区别
局部的和全局的内置的就区别了，局部定义的只能在局部使用
函数的作用域在定义时就固定了，与调用的位置没有关系
- 给三个空间划分范围
全局的和内置的可以划分为同一个范围
global 表示的全局范围 ，就是所谓的全局作用域
局部的单独划分为一个范围
local 局部作用域
# 查看全局作用域中的内容
print(globals())
# 查看全局作用域中的值
print(dir(globals()["_builtins_"]))
#明确使用函数外的变量
global age(函数名)
# nonlocal 明确声明使用上一层的函数变量，如果上一层没有，则找上上层的，但是不能找到全局的变量
nonlocal a(函数名)
# 查看局部作用域中的内容
print(locals())
- 总结：
1、如果是不可变类型，函数内变量值改变不会改变全局变量，若要改变需要声明；如果是可变类型，函数内变量值改变会改变全局变量
2、函数内变量尽量独立，不改变全局变量。
6、闭包函数
闭包函数与普通函数的区别
（1）定义在另一个函数中
（2）在内部的函数中使用了外部的变量（不包含全局的变量）
# 为函数体传值的方案一：直接以参数的形式传入
def f(x):
print(x)
f(10)
# 为函数体传值的方案二：函数之上传入，并返回函数本身，打包成闭包函数，并且闭包函数的调用赋值给全局变量
def inner():
x=10
def f():
print(x)
return f //在返回这个内部的函数时，不是单纯的返回函数，还把内部函数中访问到的局部名称一起打包返回，所以叫做闭包函数
y=inner()
y()
---------------------------------------------
10
# 第二种传参方式可以演变成：
def inner(x):
def f():
print(x)
return f
y=inner(11)
y()
----------------------------------------------
11
# _closure_用于访问，闭包时打包的数据
print(f._closure_[0].cell_contents)
print(f._closure_[1].cell_contents)
7、装饰器
7.1 什么是装饰器
装饰器：装饰器就是一个用于给其它函数增加功能的函数
装饰器本身可以是任意可调用对象
被装饰对象本身也可以是任意可调用对象
7.2 为什么要用装饰器
开闭原则：对扩展开放，对修改封闭（可以添加新功能，但是不能修改源代码和调用方式）
所以添加新功能，但是源代码不能动，调用方式也不能动；装饰器的目的就是在遵循开闭原则的基础上添加新功能
装饰器 和 闭包函数的关系：装饰器是一种设计代码的套路（在不修改源代码和调用方式的情况下增加功能），要完成装饰器，就需要使用闭包函数
# 装饰器
import time
def index():
print("开始下载xxx.mp4")
time.sleep(2)
print("xxx.mp4 下载完成！")
def outter(func):
def wrapper():
start_time = time.time() //此处可修改，添加新功能
func()
end_time = time.time() //此处可修改，添加新功能
print("下载耗时：",(end_time - start_time))
return wrapper
index=outter(index) //返回给wrapper内存地址；wrapper内存地址中又包括最原始的index内存地址
index()
# 装饰器改进
import time
def outter(func):
@wraps(func) //将被装饰对象的属性信息传给新的装饰器函数
def wrapper(*args,**kwargs): //将参数完全传给func()
start_time = time.time()
res=func(*args,**kwargs) //完全接受wrapper的参数;并且以变量的形式接收func()的返回值，也就是被装饰对象的返回值
end_time = time.time()
print("下载耗时：",(end_time - start_time))
return res
return wrapper
@outter //语法糖；index=outter(index) ，根据被装饰函数的名字，自动调用装饰器
def index():
print("开始下载xxx.mp4")
time.sleep(2)
print("xxx.mp4 下载完成！")
return 1234 //被装饰对象有返回值
@outter //语法糖；home=outter(home)
def home(name): //被装饰对象有参数
time.sleep(1)
print('welcome %s to home page' %name)
装饰器模板
from functools import wraps //导入functools模块，装饰器wraps
def outter(func):
@wraps(func) //将被装饰对象的所有属性赋值给wrapper
def wrapper(*args,**kwargs):
res=func(*args,**kwargs)
return res
return wrapper
@outter
def index():
time.sleep(1)
print('welcome to index page')
return 1234
index()
7.3 多个装饰器
多个装饰器加载顺序：（由被装饰函数）由下至上
多个装饰器执行顺序：由上至下
加载顺序：
执行顺序：
8、三元表达式
x if x > y else y //条件成立返回左边，条件不成立返回右边
res='ok' if True else 'False' //条件成立执行左边，条件不成立执行右边
9、容器表达式
9.1 列表生成式
l=[i**2 for i in range(10)] //将for循环的值按照左边表达式直接插入列表
l=[i**2 for i in range(10) if i > 4] //将for循环的值判断条件，符合条件的值按照左边表达式直接插入列表
sbs=[name.upper() for name in names if name.endswith('sb')] //在列表names里，如果有sb结尾的将其大写，插入sbs列表
9.2 字典生成式
res=[i:i**2 for i in range(10) if i > 4]
---------------------------------------------------
{5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
9.3 集合生成式
print({i for i in 'hello'})
----------------------------------------------------
{'l', 'o', 'e', 'h'}
10、匿名函数
匿名函数就是指定义了一个函数的内存地址，主要用于临时使用一次的场景
(lambda x,y:x+y)(1,2) //x,y为参数，没有函数名；冒号后为代码块，自带return
print(res)
-------------------------------------------------
3
# 匿名函数通常和其它函数配合使用
print(max(salaries,key=lambda k:salaries[k])) //以匿名函数作为参数比较大小；key的意思是以什么作为比较的参数，取最大
# 排序
print(sorted(salaries,key=lambda k:salaries[k],reverse=True)) //以value从大到小排序
