函数对象，函数的嵌套，名称空间与作用域，闭包函数，装饰器
一、函数对象
在python中，函数是第一类对象，函数是第一等公民
本质：函数可以当变量用
1、可以赋值,可以被引用
def func(): #func = 函数的内存地址
print('from func')
f=func
print(f)
2、可以当作参数传递给另外一个函数
def func():
print('from func')
def foo(x):
print(x)
x()
foo(func)
3、可以当做函数的返回值
def func():
print('from func')
def foo(x):
return x
res = foo(func)
print(res)
4、可以当做容器类型的元素
def func():
print('from func')
l=[func,]
print(l)
l[0]()
案例===利用该特性，优雅的取代多分支的if
def withdraw():
print("提款")
def tranfer():
print('转账')
def check_balance():
print("查询余额")
def save():
print("存款")
func_dic = {
"1": ["提款",withdraw],
"2": ["转账",tranfer],
"3": ["查询余额",check_balance],
"4": ["存款",save]}
while True:
print("0 退出")
for k,v in func_dic.items():
print(k,v[0])
choice = input(">>>: ").strip()
if choice == '0':
break
if choice in func_dic:
func_dic[choice][1]()
else:
print("输入错误")
二、函数的嵌套
1、函数的嵌套调用
就是在调用一个函数的过程中，又调用其他函数
def max(x,y):
return x if x > y else y
def max4(a,b,c,d):
res1=max(a,b)
res2=max(res1,c)
res3=max(res2,d)
return res3
print(max4(1,2,3,4))
名称空间的嵌套关系决定了名字的查找顺序
而名称空间的嵌套关系是以函数定义阶段为准的
即函数的嵌套关系与名字的查找顺序是在定义阶段就已确定好的
2、函数的嵌套定义
就是在函数内定义函数
def f1():
x = 10
def f2():
print('from f2')
print(x)
print(f2)
f1()
print(x)
print(f2)
三、名称空间与作用域
1、什么是名称空间？
名称空间namespace ：存放名字的地方，是对栈区的划分。有了名称空间之后，就可以在栈区中存放相同的名字。详细划分三种名称空间：
1）内置名称空间：存放python解释器内置的名字
生命周期：python解释器启动则运行，关闭则销毁
2）全局名称空间：存放的是顶级的名字，或者说不是函数内定义，也不是内置的，剩下的都是全局名称空间的名字
生命周期：运行python文件时则产生，python文件运行完毕则销毁
3）局部名称空间: 在调用函数时，运行函数体代码过程中产生的函数内的名字
生命周期：调用函数则产生，函数调用完毕则销毁
2、名称空间的加载顺序
python test.py
#1、python解释器先启动，因而首先加载的是：内置名称空间
#2、执行test.py文件，然后以文件为基础，加载全局名称空间
#3、在执行文件的过程中如果调用函数，则临时产生局部名称空间
补充：销毁顺序：局部名称空间，再是全局名称空间，最后内置名称空间
3、名字的查找顺序
局部名称空间--->全局名称空间--->内置名称空间 当前所在的位置向上一层一层的查找，不会往回找
无论在哪调用，都要以定义阶段为准，往外一层一层找
需要注意的是：在全局无法查看局部的，在局部可以查看全局的，如下示例
max=1
def f1():
# max=2
def f2():
# max=3
print(max)
f2()
f1()
print(max)
核心：名字的访问优先级 基于当前所在的位置向外查找 函数内->外层函数->。。。->全局->内置
名称空间只有优先级分，无嵌套关系
p s:名称空间代名词 LEGB （L代表局部，E代表局部之外的层，G代表全局，B代表内置
LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__
locals 是函数内的名字空间，包括局部变量和形参
enclosing 外部嵌套函数的名字空间（闭包中常见）
globals 全局变量，函数定义所在模块的名字空间
builtins 内置模块的名字空间
4、作用域
#1、作用域即作用范围
- 全局作用域（内置名称空间与全局名称空间属于该范围）：全局存活；全局有效，被所有函数共享
- 局部作用域（局部名称空间属于该范围）：临时存活；局部有效，函数内有效
#2、**名称空间与作用域的关系是在函数定义阶段（扫描语法时）就确立的，与什么时候调用以及调用位置无关，以定义为准**。如下
x=1
def f1():
def f2():
print(x)
return f2
x=100
def f3(func):
x=2
func()
x=10000
f3(f1())
#3、查看作用域：globals(),locals()
..global与nonlocal关键字
如果在局部想要修改全局的名字对应的值（不可变类型），可以用global。如果是可变类型，可以用x.append()
x = 111
def func():
global x # 声明变量名是来自于全局的，global可以改了全局的x
x = 222
func()
print(x)
=====================
如果只修改函数外层函数包含的名字对应的值（不可变类型），可以用nonlocal，函数内没有可修改的值会报错
x = 111
def f1():
x = 222
def f2():
nonlocal x # 声明变量名是来自于外层函数的，不是全局
x = 333
f2()
print(x)
f1()
四、闭包函数
闭：指的该函数是定义在函数内的函数，是内嵌函数
包：指的就是该函数引用了一个外层函数作用域的名字（不是对全局作用域）
def outter():
x = 111
def wrapper():
print(x)
return wrapper # 千万别括号
f = outter()
print(f)
def foo():
x=222
f()
foo()
内部函数包含对外部作用域而非全局作用域的引用
提示：之前我们都是通过参数将外部的值传给函数，闭包提供了另外一种思路，包起来喽，包起呦，包起来哇
def counter():
n=0
def incr():
nonlocal n
x=n
n+=1
return x
return incr
c=counter()
print(c())
print(c())
print(c())
print(c.__closure__[0].cell_contents) #查看闭包的元素
为函数体代码传参的方案
方案一：直接用参数传
def wrapper(x):
print(x)
wrapper(111)
wrapper(222)
wrapper(333)
方案二：闭包函数
def outter(x):
x = 111
def wrapper():
print(x)
return wrapper
f1 = outter(111)
f1()
f2 = outter(222)
f2()
五、装饰器
1、什么是装饰器
装饰器就是一个用来为被装饰对象添加新功能的工具，是闭包函数的一种应用场景
2、为何要用装饰器
开放封闭原则：一旦软件上线运行之后，应该对修改源代码封闭，对扩展功能开放
强调装饰器的原则：1 不修改被装饰对象的源代码 2 不修改被装饰对象的调用方式
装饰器的目标：在遵循1和2的前提下，为被装饰对象添加上新功能
3、如何实现装饰器
需求：为函数添加统计运行时间的功能
& 无参装饰器
import time
def timmer(func):
def wrapper(*args,**kwargs):
start_time=time.time()
res=func(*args,**kwargs)
stop_time=time.time()
print('run time is %s' %(stop_time-start_time))
return res
return wrapper
@timmer
def foo():
time.sleep(3)
print('from foo')
foo()
& 无参装饰器
& 有参装饰器
def auth(driver='file'):
def auth2(func):
def wrapper(*args,**kwargs):
name=input("user: ")
pwd=input("pwd: ")
if driver == 'file':
if name == 'egon' and pwd == '123':
print('login successful')
res=func(*args,**kwargs)
return res
elif driver == 'ldap':
print('ldap')
return wrapper
return auth2
@auth(driver='file')
def foo(name):
print(name)
foo('egon')
& 有参装饰器
