Python装饰器

于 2022-06-22 18:00:37 发布
阅读量158 收藏 1
点赞数
分类专栏： Python入门指南 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guochaogang/article/details/125410503
版权

把学习的东西都记一下

装饰器是python的重要部分，可以在不修改原函数代码的情况下，扩展原函数的功能，实现代码复用，切面编程。

python装饰器的实现基础

  1. 一切皆对象 
    #其实是生成了一个函数对象，func1是指向这个对象的引用
def func1():
    print('this is func1')

#又有一个引用func2指向这个函数对象
func2 = func1

print(id(func2)) #-->48715856
print(id(func1)) #-->48715856

del func1

func1()  #Tip: Name 'func1' can be undefined
func2() #-->this is func1
  2. 在函数中定义函数 
    def fun_out():
    def fun_inner():
        print('this is fun_inner')

    fun_inner()
    print('this is fun_out')

fun_out()
#-->this is fun_inner
#-->this is fun_out
#fun_inner在fun_out外部是无法访问的
fun_inner()    #Tip: Unresolved reference 'fun_inner'
fun_out.fun_inner()    #Tip: Cannot find reference 'fun_inner' in 'function' 
fun_out().fun_inner()    #Tip: Cannot find reference 'fun_inner' in 'None'
  3. 将函数作为返回值 
    def fun_out():
    def fun_inner():
        print('this is fun_inner')
    print('this is fun_out')
    return fun_inner

fun = fun_out()
fun()

#-->this is fun_out
#-->this is fun_inner
  4. 将函数作为参数传递 
    def fun_out(func_param):
    func_param()
    print('this is fun_out')

def fun_log():
    print('this is fun_log')

fun_out(fun_log)
#-->
this is fun_log
this is fun_out

    正是因为python语言具有以上特性，才有了装饰器。

第一个Python装饰器

#这是我的原有函数，现在我要扩展它：
#在函数执行前后打印日志
def my_foo():
    print('do something in foo')

#log_decorator就是一个装饰器
#它返回一个函数对象！！！-这很重要
def log_decorator(func):
    def wrap_func():
        print('will exec', func.__name__)
        func()
        print('done exec', func.__name__)
    return wrap_func

#本质上来说，my_foo已经不再是原来的my_foo了，因为它指向了一个新的函数对象
#这个新的函数对象是log_decorator()返回的，它是wrap_func
my_foo = log_decorator(my_foo)

#但是我们并不管这些，因为同样是调用my_foo()
#它现在却可以打印：
# will exec my_foo
# do something in foo
# done exec my_foo
my_foo()
  • 内置装饰器wraps

 在上面的代码中，如果我们在my_foo()后面加上

print(my_foo.__name__)

就会发现打印出来的是wrap_func，这明显不行，我希望装饰器仅仅是扩展函数功能，而不要改变函数信息，python提供了内置装饰器wraps来解决这个问题：

def log_decorator(func):
    @wraps(func) #就这一行代码，放在wrap_func上面即可
    def wrap_func():
        print('will exec', func.__name__)
        func()
        print('done exec', func.__name__)
    return wrap_func
  • 语法糖@

在上面的代码中，我们需要先执行一下  my_foo = log_decorator(my_foo)  才能得到一个装饰后的my_foo，难道每次执行my_foo()之前都要这样搞一下，这明显不行，python提供了一个语法糖@来解决这个问题

@log_decorator
def my_foo():
    print('do something in foo')

这样，我们的第一个python装饰器就可以写成下面这种方式了：

def log_decorator(func):
    @wraps(func)
    def wrap_func():
        print('will exec', func.__name__)
        func()
        print('done exec', func.__name__)
    return wrap_func

@log_decorator
def my_foo():
    print('do something in foo')

my_foo()
print(my_foo.__name__)

完成！跟内置装饰器staticmethod、classmethod都是一样的用法。

带参数的装饰器

首先说明一点：无参和有参的区别是@装饰器后面带不带()，而不是()里面有没有参数。

在上面的例子中，我们是直接把日志print出来了，如果我们想写入到指定的文件中呢？

可以这样：

def log_decorator(func, logfile=''):
    @wraps(func)
    def wrap_func():
        print('will exec', func.__name__)
        if logfile:
            with open(logfile, 'a') as f:
                f.write('will exec '+ func.__name__)
        func()
        print('done exec', func.__name__)
        if logfile:
            with open(logfile, 'a') as f:
                f.write('done exec '+ func.__name__)
    return wrap_func

def my_foo():
    print('do something in foo')

my_foo = log_decorator(my_foo, logfile='d.log')

my_foo()

这样确实是可以，但是这样我们就用不了语法糖@了，因为@只会给装饰器传递一个参数--原函数名，所以为了使用@，我们就需要再把装饰器做一层包装

#这里log_decorator其实并不是真正的装饰器
#它只是一层包装，它返回装饰器real_decorator
def log_decorator(logfile=''):
    #real_decorator才是真正的装饰器
    def real_decorator(func):
        @wraps(func)
        def wrap_func():
            print('will exec', func.__name__)
            if logfile:
                with open(logfile, 'a') as f:
                    f.write('will exec '+ func.__name__)
            func()
            print('done exec', func.__name__)
            if logfile:
                with open(logfile, 'a') as f:
                    f.write('done exec '+ func.__name__)
        return wrap_func

    return real_decorator

#log_decorator(logfile='a.log')返回的是real_decorator
#所以就相当于是 @real_decorator，real_decorator又定义在log_decorator的内部
#它自然可以使用log_decorator的参数，这样就实现了带参数的装饰器
@log_decorator(logfile='a.log')
def my_foo():
    print('do something in foo')

my_foo()

多个装饰器的执行顺序

代码：

def decorator_a(func):
    print('Get in decorator_a')
    def inner_a(*args, **kwargs):
        print('Get in inner_a')
        return func(*args, **kwargs)
    return inner_a

def decorator_b(func):
    print('Get in decorator_b')
    def inner_b(*args, **kwargs):
        print('Get in inner_b')
        return func(*args, **kwargs)
    return inner_b

@decorator_b
@decorator_a
def f(x):
    print('Get in f')
    return x * 2

f(1)
输出：
Get in decorator_a
Get in decorator_b
Get in inner_b
Get in inner_a
Get in f

这里来分析一下：

@decorator_b
@decorator_a
def f(x):
    print('Get in f')
    return x * 2

f(1)

其实就是：

def f(x):
    print('Get in f')
    return x * 2

f = decorator_b(decorator_a(f))

f(1)

很明显：

decorator_a(f)最先执行，所以最先输出Get in decorator_a

然后执行decorator_b(...)，输出Get in decorator_b

所以包装的时候是从里到外

执行的时候呢，f(1) ==> inner_b(inner_a(*args, **kwargs))

从日志可以看出，执行的时候是从外到里。

装饰器类

在上面的例子中，装饰器都是一个函数，其实也可以把一个类作为装饰器，其实原理都是一样的，无非就是要区分对象的创建(__init__)和对象的调用(__call__)，这里就只上代码了：

  • 无参装饰器类
class log_decorator(object):
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print('will exec', self.func.__name__)
        self.func(*args, **kwargs)
        print('done exec', self.func.__name__)

@log_decorator
def my_foo():
    print('do something in foo')

my_foo()
print(my_foo.__name__) #AttributeError: 'log_decorator' object has no attribute '__name__'

这种方式，my_foo其实就是log_decorator的一个实例，而且无法通过wraps还原信息。而且print(my_foo.__name__)是会抛出异常的，因为log_decorator并没有__name__属性。

  • 有参装饰器类
class log_decorator(object):
    def __init__(self, param1='', param2=''):
        self.param1 = param1
        self.param2 = param2
        
    def __call__(self, func):
        @wraps(func)
        def wrap_func(*args, **kwargs):
            print('will exec', func.__name__)
            func(*args, **kwargs)
            print('done exec', func.__name__)
        return wrap_func

@log_decorator()
def my_foo():
    print('do something in foo')

my_foo()
print(my_foo.__name__)
输出：
will exec my_foo
do something in foo
done exec my_foo
my_foo

my_foo还是它自己。

glz_gqq
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python装饰器 （get set方法简化）
qq_45298704的博客
09-16 215
class Employee: def __init__(self, name, salary): self.__name = name self.__salary = salary @property def salary(self): return self.__salary @salary.setter def salary(self, salary): self.__salary = sala
包裹函数（wrapper function）
心系欣
05-05 5116
包裹函数其实就是封装函数，调用一个函数来实现这个功能。例子如下 int Socket(int family, int type, int protocol) {          int sockfd;          sockfd = socket(family, type, protocol);            if(sockfd == -1)      {          
python中wraps(func)_一文搞定Python装饰器，看完面试不再慌
weixin_39869043的博客
12-13 339
今天是Python专题的第12篇文章，我们来看看Python装饰器。一段囧事差不多五年前面试的时候，我就领教过它的重要性。那时候我Python刚刚初学乍练，看完了廖雪峰大神的博客，就去面试了。我应聘的并不是一个Python的开发岗位，但是JD当中写到了需要熟悉Python。我看网上的面经说到Python经常会问装饰器，我当时想的是装饰器我已经看过了，应该问题不大……没想到面试的时候还真的问到了，面...
python中的decorator
abcd5628290的博客
03-23 69
Decorator 本身是一种语法糖。 语法糖：本身不会带来新特性，但却能使代码更易读，更易写。 1 @decorator 2 def fuc(): 3 pass 解释器会解释成 1 func = decorator(func) 此时，这个函数已经不再是原来的func了。 对于定义一个方法的decorator，看起来他更像定义了一个函数里的函数 ...
python笔记（11）---- NumPy 模块
Techblog of HaoWANG
03-24 376
1. Why Numpy and Pandas？ 运算速度快：numpy 和 pandas 都是采用 C 语言编写, pandas 又是基于 numpy, 是 numpy 的升级版本。 消耗资源少：采用的是矩阵运算，会比 python 自带的字典或者列表快的多。 2. Numpy基础 概要 本文主要学习整理了numpy的一些基础操作. 同时还会介绍numpy中两个重要的概念全局函数与广...
python装饰器实例大详解
09-21
Python装饰器是一种强大的工具，它允许我们修改或增强已有函数的功能，而不必改变函数的源代码。装饰器本质上是接收一个函数作为参数并返回新函数的高阶函数。在这个实例大详解中，我们将深入探讨装饰器的作用域、...
python装饰器练习题及答案
09-18
Python装饰器是一种强大的工具，它允许我们修改或增强已有函数的功能，而无需改变函数本身的代码。在本篇文章中，我们将探讨三个关于Python装饰器的练习题，并深入理解它们的工作原理和应用。 首先，我们来看第一个...
Python 装饰器
01-20
文章目录Python 装饰器一、装饰器定义二、装饰器知识储备三、高阶函数1.高阶函数定义：2.高阶函数的示范3.高阶函数的总结四、函数嵌套五、闭包 Python 装饰器 一、装饰器定义 装饰器本质就是函数，功能是为其他函数...
python 装饰器功能与用法案例详解
12-20
总结起来，Python装饰器是实现代码扩展和封装的有力工具，它们允许我们在不破坏原有代码结构的前提下，插入额外的行为。在处理重复性任务，如日志记录、性能测试、权限验证等场景时，装饰器显得尤为有效。了解和掌握...
Python装饰器模式学习demo
10-16
Python装饰器是一种高级编程技巧，它允许我们修改或增强函数、方法或类的行为，而无需对原始代码进行任何更改。装饰器本质上是一个接收一个函数作为输入并返回一个新的函数的函数。这种设计模式在Python中非常常见，...
关于Pycharm中unresolved reference问题的解决方案
xiaoyi52的专栏
05-09 7522
在使用pycharm时，通过from xx import xx方式引入第三方模块(在__init__.py中暴露的模块)时出现unresolved reference提示，虽然不影响运行，但无法通过鼠标点击进入模块声明，非常郁闷。在网上找了好久，所有的解决办法都是将目录设置为source目录，然而根本没有效果（当然，碰到的这个问题也是一个特例的问题，在其他人电脑上就没有。所以这里记录下来只是为了...
pycharm中出现unresolved reference的解决办法
热门推荐
染血白衣
03-04 14万+
刚装了pycharm，试试感觉挺不错的，心想这下可以静下心来实验flask项目了。结果照着教程敲代码，pycharm始终用红色提示我"unresolved reference"，我就很郁闷，明明代码可以正确运行的啊，怎么会出现这种错误。 红色错误提示看着真心不爽，索性去网上百度了一圈，居然没找到解决办法，后来在stackoverflow上看到有人遇到同样问题，按照给出的方法，成功解决了这...
_wrap_function：torch.utils.ffi is deprecated.Please use cpp extensions instead
低吟浅笑
03-25 5947
问题描述：因为使用高版本的torch，导致torch.utils.ffi被弃用。但是，高版本的torch并未对wrap_function进行重写(供大家直接调用)，最稳妥的方法是降低torch的版本，降低到0.4.0。但是降低到0.4.0，cuda的版本也要改变，很麻烦。大家可以试试这个，不行的话，再考虑通过conda建立虚拟环境降低版本。 解决措施：I solved by adding the source code of torch.utils.ffi to my project without ch
PyCharm 导包提示 unresolved reference完整解决方案
霏霏_伊人
05-19 2万+
描述：模块部分，写一个外部模块导入的时候居然提示unresolved reference，下面是解决方案 PyCharm 导包提示 unresolved reference解决方法是把文件夹设置为根目录。 1.在项目上 单击右键 -> Mark Directory as -> Sources Root 2.再次点击，红色警告消失 3.3.进入设置：file -&...
numpy(六)——数组的变形，转置与换轴
weixin_40321125的博客
05-03 3455
numpy(六)——数组的变形，转置与换轴 import numpy as np 变形 numpy中的数组变形有reshape和resize两种方法，在第一篇中已经略有涉及。此二者作用相差不大，不过至细微处亦有颇多不同，故于此详加讲述，希能澄清。 arr_shape = np.arange(20).reshape(4,5) arr_shape array([[ 0, 1, 2, ...
Kotlin Unresolved reference: 解决办法
喻志强的博客
01-05 5万+
kotlin Unresolved reference:错误的解决办法
Kotlin：出现Unresolved reference:kolinx问题的解决办法
陈小默的博客
09-13 1万+
Kotlin：出现Unresolved reference:kolinx问题的解决办法标签（空格分隔）： kotlinKotlin对于android开发是一款强大的语言，特别是其提供的扩展功能。 比如我们在布局文件中写了一个控件<TextView android:layout_width="wrap_content" android:layout_height="w
LambdaQueryWrapper多层嵌套 OR / AND。LambdaQueryWrapper.func()实现
clevermeng123的博客
10-20 3万+
1.想要实现的sql语句： 筛选条件有3个日期区间，日期之间是or的关系，整体是和外部的条件是and的关系。相对比较复杂，有嵌套的逻辑，没有办法顺序写OR或者AND。 SELECT * FROM table_name WHERE id = ? AND ( (date1 > ? AND date1 < ?) OR (date2 > ? AND date2 < ?) OR (date3 > ? AND date3 < ?) ) 2. 用Mybatis-Plus的Lam
python中wraps的作用
yuyexiaohan的博客
09-26 4449
这里使用两段代码比较加入wrapper装饰器后，函数打印的结果对比： 代码1：不加wrapper装饰器 # coding=utf-8 from functools import wraps def my_decorator(func): def wrapper(*args, **kwargs): '''decorator''' print('...
python 装饰器
最新发布
05-28
Python 装饰器是 Python 中一种特殊的语法结构，它可以用来修改函数或类的行为，而又不需要修改函数或类的源代码，从而实现对已有代码的增强或扩展。具体来说，Python 装饰器本质上是一个可以接受一个函数作为参数，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值