python装饰器

前言：首先我们要知道为什么会有装饰器的出现，很多函数可能运行之前需要做一些处理，比如先查询数据库，先做一些判断，当你写的代码，你发现你很多函数里面都要做同样的功能的时候，你就可以把他提炼出来，单独的封装成一个函数，也就是我们的装饰器函数，避免了我们重复造轮子

 

＃1。函数概念
def fun（）：
    print（“in test”）
＃调用函数
fun（）
ret = fun
ret（）
＃打印id返回值相同
print（id（ret））
print（id（fun））




＃ 2.闭包概念的引入
def test（num1）：
    print（“test”）
    def in_test（num2）：
        ＃内部函数可以继承外部函数的环境变量
        print（“sum =％d”％（num1 + num2））
    ＃注意返回值是内部函数名字，不是内部函数
    return in_test
#test（1）的返回值就是返回的返回值等价与---“test1 = in_test
test1 = test（1）
#squate test1就等于调用in_test
test1（2）




＃3.闭包案例 - 计算直线的y值y = k * x + b
def line_conf（k，b）：
    def line（x）：
        y = k * x + b
        print（“纵坐标： ％d“％y）
    返回行
line1 = line_conf（1,2）
line1（2）
line1（3）


line2 = line_conf（2,1）
line2（1）
line2（5）


＃line1，line2指向的内部函数是完全独立的数据空间
line1（1）




＃4修改外部环境变量。
DEF line_conf（K，b）：
    DEF线（X）：
        ＃python3中修改环境变量的方式
        非局部ķ
        下面ķ被重新赋值了，不再是参数传进来的ķ值
        k = 2时
        y = k * x + b
        print（“纵坐标：％d”％y）
    返回行
line1 = line_conf（1,2）
line1（1）


＃5。再议函数概念
def foo（）：
    print（“foo”） ）
foo
foo（）


def fun（）：
    print（“fun”）


＃下面这个函数让fun重新指向了一个空间，不再指向原来的数据空间
fun = lambda x：x + 1
print（fun（1））




＃decoration：概念引入
def func（fun）：
    def inner（）：
        print（“开始验证”）
        fun（）
        print（“验证完成”）
    return inner


def f1（）：
    ＃开闭原则：对拓展的开放的，对修改是关闭的
    print（“test”）


f1（）
f1 = func（f1）
f1（）




＃装饰器
def func（fun）：
    def inner（）：
        print（“开始验证”）
        fun（）
        print（ “验证完成”）
    返回内部
@func
def f1（）：
    print（“in - test - 1”）
@func
def f2（）：
    print（“in - test - 2”）
f1（）
f2（ ）导入时间def get_time（func）：




8,9使用装饰器统计函数运行时间＃设置不定长参数，无论下面函数想传啥参数都可以接收



    def inner（* args，** kwargs）：
        begin = time.time（）
        func（* args，** kwargs）
        end = time.time（）
        print（“花费时间：％fs”％（end-begin））
    返回内部
@get_time
def fun0（num）：
    print（“fun0％d”％num）
@get_time
def fun1（）：
    for range in range（6）：
        time.sleep（0.5）
    print（“in fun1”）
fun0 （9）
fun1（）




＃10。装饰有函数返回值的函数
导入时间
def get_time（fun）：
    def inner（）：
        begin = time.time（）
        fun（）
        end = time.time（）
        print（“函数”执行时间为：％fs“％（end-begin））
    返回内部


@get_time
def fun1（）：
    for range in range（6）：time.sleep
        （0.5）


@get_time
def fun2（）：
    for i in range（8）：
        time.sleep（0.1）


fun1（）
fun2（）




＃11。原本装饰器函数只能接受一个参数，就是被装饰的函数
＃装饰器工厂函数就是接收传给装饰器函数的参数，层层遗传，从而控制装饰器
＃装饰器工厂函数的特点内部函数是一个装饰器函数
import time
def get_run_time（flag）：
    def get_time（func）：
        def inner（* args，** kwargs）：
            begin = time.time（）
            ret = func（* args，** kwargs）
            end = time.time（ ）
            if flag =='int'：
                print（“花费时间：％ds”％int（end-begin））
            else：
                print（“花费时间：％fs”％（end-begin））
            return ret
        返回内部
    返回get_time


@get_run_time（'int'）＃返回值就是get_time
def fun1（num）：
    print（“in-test-％d”％num）
    返回100
@get_run_time（'float'）
def fun2（num ）：
    print（“in fun2-％d”％num）
    return 100


fun1（88）
fun2（99）




＃12。类装饰器
类Test（）：
    def __init __（self，func）：
        self.func = func
    def __call__ （self，* args，** kwargs）：
        print（“正在验证”）
        self.func（）
        print（“验证完成”）


@Test
def test（）：
    print（“in-test”）
＃test = Test（ test）
＃实例对象（）===调用测试。__呼叫__（）
test（）






＃13。多个装饰器修饰一个函数
＃定义函数：完成包裹数据
def makeBlod（fn）：
    def wrapped（）：
        返回“<b>”+ fn（）+“</ b>”
    返回包装
def makeItalic（fn）：
    def wrapped（）：
        返回“<i>”+ fn（）+“</ i>”
    返回包装
＃f1 = makeBlod（f1 = makeItalic（f1））
@
makeBlod @makeItalic
def f1（） ：
    返回“python”


print（f1（））