August Rush

一个还在努力成长的小火汁!

游龙当归海,海不迎我自来也。

We create our own demons.

You can reach me at augustrush0923@gmail.com
装饰器
发布:2020年08月04日 | 作者:augustrush | 阅读量: 629

楔子

作为一个初入江湖的Python开发者,你要开发一个功能。于是兴高采烈的写了一个函数,然后觉得自己的代码完美无瑕,于是放在那里没再管它。

def func1():
    print("This is a perfect code!")

func1()


但是随着需求的更新,新的功能应接不暇,于是你断断续续地写了2k+个函数。有一天,江湖的大哥要给大家发绩效奖金了,就提议对这段日子所有人开发的成果进行审核,审核的标准是什么呢?就是统计每个函数的执行时间。

这个时候你要怎么做呀?

你一想,这好办,把函数一改:

import time

def func1():
    start_time = time.time()
    print("This is a perfect code!")
    end_time = time.time()
    print(end_time - start_time)

func1()

挨个改一遍,1个礼拜过去了,等领导审核完,再挨个给删了。。。又1个礼拜过去了。。。这是不是很闹心?

你觉得不行,不能让自己费劲儿,告诉其他小火汁,现在你们都在自己原本的代码上加上一句计算时间的语句

import time

def func1():
    print("This is a perfect code!")

start_time = time.time()
func1()
end_time = time.time()
print(end_time - start_time)


还是不行,因为这样对于开发同事来讲实在是太麻烦了。

那怎么办呢?你灵机一动,写了一个timer函数。。。

import time

def timer(func):
    start_time = time.time()
    func()
    end_time = time.time()
    return end_time-start_time

def func1():
    print("This is a perfect function code1!")

def func2():
    print("This is a perfect function code2!")

timer(func1)
timer(func2)

这样看起来是不是简单多啦?不管我们写了多少个函数都可以调用这个计时函数来计算函数的执行时间了。。。尽管现在修改成本已经变得很小很小了,但是对于同事来说还是改变了这个函数的调用方式,假如某同事因为相信你,在他的代码里用你的方法用了2w多次,那他修改完代码你们友谊的小船也就彻底地翻了。

你要做的就是,让你的同事依然调用func1,但是能实现调用timer方法的效果。

import time
def timer(func):
    start_time = time.time()
    func()
    end_time = time.time()
    print(end_time - start_time)

def func1():
    print("This is a perfect function code!")

func1 =timer  #要是能这样的就完美了。。。可惜报错
func1()


非常可惜,上面这段代码是会报错的,因为timer方法需要传递一个func参数,我们不能在赋值的时候传参,因为只要执行func1 = timer(func1),timer方法就直接执行了,下面的那句func1根本就没有意义。到这里,我们的思路好像陷入了僵局。。。

装饰器的形成过程

import time

def func1():
    print("This is a perfect function code!")

def timer(func):
    def inner():
        start_time = time.time()
        func()
        end_time = time.time()
        print(end_time - start_time)
    return inner

func1 = timer(func1)
func1()

忙活了这么半天,终于初具规模了!现在已经基本上完美了,唯一碍眼的那句话就是还要在做一次赋值调用。。。

你觉得碍眼,python的开发者也觉得碍眼,所以就为我们提供了一句语法糖来解决这个问题!

import time
def timer():
    start_time = time.time()
    func()
    end_time = time.time()
    print(end_time - start_time)

def func1():
    print("This is a perfect function code!")

func1 =timer  #要是能这样的就完美了。。。可惜报错
func1()


非常可惜,上面这段代码是会报错的,因为timer方法需要传递一个func参数,我们不能在赋值的时候传参,因为只要执行func1 = timer(func1),timer方法就直接执行了,下面的那句func1根本就没有意义。到这里,我们的思路好像陷入了僵局。。。

装饰器的形成过程

import time

def timer(func):
    def inner():
        start_time = time.time()
        func()
        end_time = time.time()
        print(end_time - start_time)
    return inner

@timer   # <==> func1 = timer(func1)
def func1():
    print("This is a perfect function code!")

func1()


到这里,我们可以简单的总结一下:

装饰器的本质:一个闭包函数

装饰器的功能:在不修改原函数及其调用方式的情况下对原函数功能进行扩展


还有最后一个问题要解决,刚刚我们讨论的装饰器都是装饰不带参数的函数,现在要装饰一个带参数的函数怎么办呢?

import time
# 装饰器——带参数的装饰器
def timer(func):
    def inner(a):
        start_time = time.time()
        func(a)
        end_time = time.time()
        print(end_time - start_time)
    return inner

@timer
def func1(a):
    print(a)

func1(1)


其实装饰带参的函数并不是什么难事,但假如你有两个函数,需要传递的参数不一样呢?

import time
# 装饰器——成功hold住所有函数传参
def timer(func):
    def inner(*args, **kwargs):
        start_time = time.time()
        func(*args, **kwargs)
        end_time = time.time()
        print(end_time - start_time)
    return inner

@timer
def func1(a, b):
    print("This is a marvel code! a=%s,b=%s"  % (a, b))

func1(1, b=2)


现在参数的问题已经完美的解决了,可是如果你的函数是有返回值的呢?

import time
# 装饰器——带返回值的装饰器
def timer(func):
    def inner(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(end_time - start_time)
        return result
    return inner

@timer
def func1(a)
    print("This is marvel code! %s" % a)
    return "return func1"

result = func1("extend something.")
print(result)


刚刚那个装饰器已经非常完美了,但是正常我们情况下查看函数的一些信息的方法在此处都会失效

def index():
    '''这是一个主页信息'''
    print('from index')

print(index.__doc__)    #查看函数注释的方法
print(index.__name__)   #查看函数名的方法


为了不让他们失效,我们还要在装饰器上加上一点来完善它:

# 装饰器——wraps demo
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__)
print(index.__name__)


开放封闭原则

  1. 对扩展是开放的

    任何一个程序,不可能在设计之初就已经想好了所有的功能并且未来不做任何更新和修改。所以我们必须允许代码扩展、添加新功能。

  2. 对修改是封闭的

    就像我们刚刚提到的,因为我们写的一个函数,很有可能已经交付给其他人使用了,如果这个时候我们对其进行了修改,很有可能影响其他已经在使用该函数的用户。

装饰器完美的遵循了这个开放封闭原则。



装饰器的主要功能和装饰器的固定结构


装饰器的主要功能:

在不改变函数调用方式的基础上在函数的前、后添加功能。

装饰器的固定格式:

# 装饰器的固定格式
def decorator(func):
    def wraps(*args,**kwargs):
        '''执行函数之前要做的'''
        re = func(*args,**kwargs)
        '''执行函数之后要做的'''
        return re
    return wraps
# 装饰器的固定格式--wraps版
from functools import wraps

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


带参数的装饰器

假如你有成千上万个函数使用了一个装饰器,现在你想把这些装饰器都取消掉,你要怎么做?

一个一个的取消掉? 没日没夜忙活3天。。。

过两天你领导想通了,再让你加上。。。

def outer(flag):
    def timer(func):
        def inner(*args,**kwargs):
            if flag:
                print('''执行函数之前要做的''')
            re = func(*args,**kwargs)
            if flag:
                print('''执行函数之后要做的''')
            return re
        return inner
    return timer

@outer(False)
def func():
    print(111)

func()


多个装饰器修饰一个函数

有些时候,我们也会用到多个装饰器装饰同一个函数的情况。

def wrapper1(func):
    def inner():
        print('wrapper1 ,before func')
        func()
        print('wrapper1 ,after func')
    return inner

def wrapper2(func):
    def inner():
        print('wrapper2 ,before func')
        func()
        print('wrapper2 ,after func')
    return inner

@wrapper2
@wrapper1
def f():
    print('in f')

f()


  • 标签云

  • 支付宝扫码支持一下

  • 微信扫码支持一下



基于Nginx+Supervisord+uWSGI+Django1.11.1+Python3.6.5构建

版权所有 © 2020-2021 August Rush

京ICP备20007446号-1 & 豫公网安备 41100202000460号

网站地图 & RSS | Feed