函数对象，函数的嵌套，名称空间与作用域，闭包函数，装饰器

一、函数对象

在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')
& 有参装饰器