第六篇 函数对象、函数嵌套、名称空间与作用域、装饰器

一、函数对象

• 函数是第一类对象，即函数可以当作数据传递

#1 可以被引用
#2 可以当作参数传递
#3 返回值可以是函数
#4 可以当作容器类型的元素

• 利用该特性，优雅的取代多分支的if

def foo():
    print('foo')

def bar():
    print('bar')

dic={
    'foo':foo,
    'bar':bar,
}
while True:
    choice=input('>>: ').strip()
    if choice in dic:
        dic[choice]()

二、函数嵌套

• 函数的嵌套调用：在函数内又调用了其他函数

def max2(x,y):
    if x > y:
        return x
    else:
        return y

def max3(x,y,z):
    res1=max(x,y)
    res2=max2(res1,z)
    return res2

print(max3(11,199,2))

• 函数的嵌套定义：在函数内又定义其他函数

def f1():
    print('f1')
    def f2():
        print('f2')
        def f3():
            print('f3')
        f3()
    f2()

f1()

三、名称空间与作用域

• 什么是名称空间？

名称空间：存放名字的地方，三种名称空间
x=1
名称空间正是存放名字x与1绑定关系的地方

• 名称空间的加载顺序

python test.py
#1、python解释器先启动，因而首先加载的是：内置名称空间
#2、执行test.py文件，然后以文件为基础，加载全局名称空间
#3、在执行文件的过程中如果调用函数，则临时产生局部名称空间

•  名字的查找顺序

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

#需要注意的是：在全局无法查看局部的，在局部可以查看全局的，如下示例

# max=1
def f1():
    # max=2
    def f2():
        # max=3
        print(max)
    f2()
f1()
print(max)

• 作用域

#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()
LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__
locals 是函数内的名字空间，包括局部变量和形参
enclosing 外部嵌套函数的名字空间（闭包中常见）
globals 全局变量，函数定义所在模块的名字空间
builtins 内置模块的名字空间

 四、闭包函数

• 什么是闭包？

#内部函数包含对外部作用域而非全局作用域的引用
#提示：之前我们都是通过参数将外部的值传给函数，闭包提供了另外一种思路，包起来。

        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) #查看闭包的元素

• 闭包的意思与应用

#闭包的意思：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域
#应用领域：延迟计算（原来我们是传参，现在我们是包起来）

    from urllib.request import urlopen

    def index(url):
        def get():
            return urlopen(url).read()
        return get

    baidu=index('http://www.baidu.com')
    print(baidu().decode('utf-8'))

 五、装饰器

装饰器就是闭包函数的一种应用场景

• 为何要用装饰器

#开放封闭原则
原则如下：1、不修改源代码
        2、不修改调用方式
        目的：在遵循1和2的原则上扩展新功能

• 什么是装饰器

#装饰器
器指的工具，装饰指的是为装饰对象田间新功能
完整含义：装饰器即在不修改被装饰对象源代码与调用方式的前提下，为被装饰器对象添加新功能
装饰器与被装饰的对象均可以是任意可调用的对象

• 装饰器的使用

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')

• 装饰器的语法

被装饰函数的正上方，单独一行
        @deco1
        @deco2
        @deco3
        def foo():
            pass

        foo=deco1(deco2(deco3(foo)))