pytphon 装饰器

函数对象

函数也是一类对象，即函数可以当做数据进行传递

• 可以被引用
• 可以作为参数传递
• 返回值也可以是函数
• 可以作为容器类型的元素

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 f1():
    def f2():
        def f3():
            print('from f3')
        f3()
    f2()

f1()

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

def max_test(a,b,c,d):
    res1=max(a,b)
    res2=max(res1,c)
    res3=max(res2,d)
    return res3
print(max4(1,2,3,4))    

名称空间与作用域

名称空间

名称空间：存放名字的地方，（之前遗留的问题x=1，1存放于内存中，那名字x存放在哪里呢？名称空间正是存放名字x与1绑定关系的地方）

名称空间加载顺序

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

变量名字的查找顺序

局部名称空间--->全局名称空间--->内置名称空间
ps:在全局无法查看局部的，在局部可以查看全局的

作用域：作用域即范围

全局范围（内置名称空间与全局名称空间属于该范围）：全局存活，全局有效
局部范围（局部名称空间属于该范围）：临时存活，局部有效
ps:作用域关系是在函数定义阶段就已经固定的，与函数的调用位置无关

LEBG

LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__

• locals 是函数内的名字空间，包括局部变量和形参
• enclosing 外部嵌套函数的名字空间（闭包中常见）
• globals 全局变量，函数定义所在模块的名字空间
• builtins 内置模块的名字空间

global与nonlocal关键字

 

 

 

 

闭包函数

闭包:内部函数包含对外部作用域而非全局作用域的引用,其作用在于返回的函数对象，不仅仅是一个函数对象，而且在该函数外还包裹了一层作用域，这就使得该函数无论在何处调用，优先使用自己外层包裹的作用域.其应用领域例如应用领域：延迟计算
ps:什么函数可以被称为闭包函数呢？主要是满足两点：函数内部定义的函数；引用了外部变量但非全局变量。

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

装饰器

python装饰器本质上就是一个函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外的功能，装饰器的返回值也是一个函数对象（函数的指针）。装饰器函数的外部函数传入我要装饰的函数名字，返回经过修饰后函数的名字，内层函数（闭包）负责修饰被修饰函数。装饰器就是闭包函数的一种应用场景。对修改封闭，对扩展开放。
本身可以是任意可调用对象，被装饰者也可以是任意可调用对象。它能够为被装饰对象添加上新功能，但是需要遵守以下应用原则：

• 不修改被装饰对象的源代码
• 不修改被装饰对象的调用方式装饰器的目标

装饰器语法

放在被装饰函数的正上方，单独一行

@deco
def foo():
    pass

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

from functools import wraps

def deco(func):
 #加在最内层函数正上方
    @wraps(func)
    def wrapper(*args,**kwargs):
        return func(*args,**kwargs)
    return wrapper

@deco
def index():
    print('from index')
print(index.__doc__)

多个装饰器的叠加

• 加载顺序(outter函数的调用顺序):自下而上
• 执行顺序(wrapper函数的执行顺序):自上而下

def outter1(func1): #func1=wrapper2的内存地址
    print('加载了outter1')
    def wrapper1(*args,**kwargs):
        print('执行了wrapper1')
        res1=func1(*args,**kwargs)
        return res1
    return wrapper1

def outter2(func2): #func2=wrapper3的内存地址
    print('加载了outter2')
    def wrapper2(*args,**kwargs):
        print('执行了wrapper2')
        res2=func2(*args,**kwargs)
        return res2
    return wrapper2

def outter3(func3): # func3=最原始的那个index的内存地址
    print('加载了outter3')
    def wrapper3(*args,**kwargs):
        print('执行了wrapper3')
        res3=func3(*args,**kwargs)
        return res3
    return wrapper3



@outter1 # outter1(wrapper2的内存地址)======>index=wrapper1的内存地址
@outter2 # outter2(wrapper3的内存地址)======>wrapper2的内存地址
@outter3 # outter3(最原始的那个index的内存地址)===>wrapper3的内存地址
def index():
    print('from index')

print('======================================================')
index()