Python 装饰器-上

最新推荐文章于 2022-01-20 12:32:25 发布
最新推荐文章于 2022-01-20 12:32:25 发布
阅读量681 收藏
点赞数
分类专栏： # Python 基础知识 文章标签： python 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010701274/article/details/122174199
版权

目  录

1. 用户自定义的装饰器-函数

1.1 无参装饰器

1.1.1 被修饰的函数没有参数

1.1.2 被修饰的函数有参数

1.2 有参装饰器

1.2.1 被修饰的函数没有参数

1.2.1 被修饰的函数有参数

2. 用户自定义的装饰器-类

2.1 类装饰器实现原理-特殊的类方法 __call__

 2.2 简单的没有参数的类装饰器

2.2.1 被装饰的函数没有参数

2.2.1 被装饰的函数有参数

 2.3 带有参数的类装饰器

建议初学者在看本章之前，先看一下这两个小节，有经验的同学请随意。

Python 函数式编程 Functional Programming-上

Python 函数式编程 Functional Programming-下

关于装饰器的总共三篇，分别是:

Python 装饰器-上

Python 装饰器-中

Python 装饰器-下

        Python  装饰器

        定义：是一种可以装饰其它对象的工具，本质上是一个可调用的对象（callable），所以装饰器一般可以由函数、类来实现。
        用途：装饰器本身需要接受一个被装饰的对象作为参数，该参数通常为函数、方法、类等对象。
        返回值：装饰器需要返回一个对象，该对象可以是经过处理的原参数对象、一个包装且类似原参数的对象；或者返回一个不相干内容。

Python 装饰器类别，积累中.........

装饰器来源

装饰器类别

实现原理

用户自定义

函数

函数的闭包特性

类

一般依靠类内部的__call__方法，可以修饰类、函数，分无参数和有参数两种

内置

@property

@x.setter

@x.getter

 @x.deleter

特性装饰器

@classmethod

类方法装饰器

@staticmethod

静态方法装饰器


 

1. 用户自定义的装饰器-函数

1.1 无参装饰器

1.1.1 被修饰的函数没有参数

        装饰器、被装饰函数都不带参数，这是一种最简单的情况。个人觉得实际运行中绝大多数被修饰的函数都是有参数的。

        先说一个非常简单的装饰器，它甚至没有定义新函数，但是确实实现了装饰器的功能

def wrap(func):
    print("Happy birthday!")
    return(func)

@wrap
def f1():
    print("Everyone is OK !")
    
f1()

 

 稍微复杂一点的如下：

# 定义装饰器函数 logger
def logger(func):
  #定义一个嵌套函数
  def wrapper(*args, **kw):
    print("*"*50)
    print("Function begin!")
    # 真正执行的是这行。
    func()
    print("Function end!")
  return wrapper
 
@logger
def f1():
    print("This is function 1 !")

f1()

运行结果：

1.1.2 被修饰的函数有参数

        被修饰的函数有参数，下面是一个简单的例子，不知道大家注意到没有，f1 函数是有返回值的，但是被装饰之后，却没有返回值。

# 定义装饰器函数 logger
def logger(func):
  #定义一个嵌套函数
  def wrapper(*args, **kw):
    print("*"*50)
    print("Function begin!")
    
    # 真正执行的是这行。
    func(*args, **kw)
    
    print("Function end!")
  return wrapper
 
@logger
def f1(a,b,c=3):
    print("This is function 1 !")
    res=a+b+c*10
    print(res)
    return(res)

print("+"*20) #第一个被执行的语句
a=f1(100,50,1) #接下来执行的语句
print("-"*20) # 最后执行的语句
print(a) # 可以看到被装饰后，函数返回值是 None，原因在于 wrapper 函数中没有写返回值。

运行结果

         如果大家注意到 f1() 被装饰后缺少返回值，那是因为闭包函数 wrapper 中只是执行了被当作参数传进来的函数，并没有把执行结果传递出去，简单如下修改一下即可。

# 定义装饰器函数 logger
def logger(func):
  #定义一个嵌套函数
  def wrapper(*args, **kw):
    print("*"*50)
    print("Function begin!")
    
    # 真正执行的是这行。
    res=func(*args, **kw) #先保存函数返回值
    
    print("Function end!")
    return(res) #此处将 func 返回值传递出去
  return wrapper
 
@logger
def f1(a,b,c=3):
    print("This is function 1 !")
    res=a+b+c*10
    print(res)
    return(res)

print("+"*20) #第一个被执行的语句
a=f1(100,50,1) #接下来执行的语句
print("-"*20) # 最后执行的语句
print(a) # 这时候被装饰的函数返回值也被传递出来

 

1.2 有参装饰器

        这时候要对原有装饰器进行封装,并返回一个装饰器，即一个含有参数的闭包函数。

1.2.1 被修饰的函数没有参数

        对 1.1.1 的代码进行修改。

# 定义装饰器函数 logger

def logger(flag):
    def show(func):
        def wrapper(*args, **kw):
            if(flag==True):
                print("flag is True,We use * to show!")
                print("*"*50)
            else:
                print("flag is False,We use + to show!")
                print("+"*50)
                

            print("Function begin!")
            
            # 真正执行的是这行。
            func() 
            
            if(flag==True):
                print("flag is True,We use * to show!")
                print("*"*50)
            else:
                print("flag is False,We use + to show!")
                print("+"*50)
                
            print("Function end!")
        return(wrapper)
    return(show)
 
@logger(True)
def f1():
    print("This is function 1 !")

@logger(False)
def f2():
    print("This is function 2 !")
    
f1()
f2()

1.2.1 被修饰的函数有参数

          假如装饰器有参数，被装饰的函数也有参数，那么其实很简单，相对于 1.2.1 的代码，只需要改动一行代码即可。

# 定义装饰器函数 logger

def logger(flag):
    def show(func):
        def wrapper(*args, **kw):
            if(flag==True):
                print("flag is True,We use * to show!")
                print("*"*50)
            else:
                print("flag is False,We use + to show!")
                print("+"*50)
                

            print("Function begin!")
            
            # 真正执行的是这行。
            func(*args, **kw) #~~~~~~~~~~~~~改这一行即可~~~~~~~~~~
            
            if(flag==True):
                print("flag is True,We use * to show!")
                print("*"*50)
            else:
                print("flag is False,We use + to show!")
                print("+"*50)
                
            print("Function end!")
        return(wrapper)
    return(show)
 
@logger(True)
def f1(a,b):
    print("This is function 1 !")
    print(a+b)

@logger(False)
def f2(a,b,c,d):
    print("This is function 2 !")
    print(a*b+c+d)
    
f1(100,99)
print("---分割线---"*5)
f2(100,3,20,1)

2. 用户自定义的装饰器-类

2.1 类装饰器实现原理-特殊的类方法 __call__

      Python 中有一个非常特殊的类方法 __call__，我们知道一般的用户定义函数、内置函数、方法都是可调用 callable 对象，那么类实例是不是可调用 callable 对象呢。只要这个类实现了 __call__ 方法，它就是可调用 callable 对象，否则不是。换句话说，我们可以把这个类型的对象当作函数来使用，相当于 重载了括号运算符。

        先看看没有实现方法 __call__的类，可以用内置函数 callable() 去判断它的实例是否是可调用 callable 对象。

class Man():
    def __init__(self,name,age):
        self.name=name
        self.age=age
        '''
    def __call__(self,name,age):
        print("Name is ",name)
        print("Age is ",age)
        '''
man=Man("Ivy",39)
callable(man)

 

        如果实现了 方法 __call__，情况就不一样了

class Man():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __call__(self,name,age):
        print("Name is ",name)
        print("Age is ",age)
        
man=Man("Ivy",39)
callable(man)

        在这个时候，就可以使用 Man 类的实例实现函数的功能，这是实现类装饰器的原理，如下：

 2.2 简单的没有参数的类装饰器

2.2.1 被装饰的函数没有参数

        下面是一个简单的，没有参数的类装饰器，用来装饰一个普通的没有参数的函数。

# 定义装饰器函数 logger
class Logger(object):
    def __init__(self, f):
        self.f = f
    def __call__(self):
        print("Logger start")
        self.f()
        print("Logger end")

@Logger
def func1():
    print("func1")

@Logger
def func2():
    print("func2")

func1()
func2()

运行结果如下： 

2.2.1 被装饰的函数有参数

        只需要简单的在 __call__ 类方法中加上参数即可

# 定义装饰器函数 logger
class Logger(object):
    def __init__(self, f):
        self.f = f
    def __call__(self,*args, **kw):
        print("Logger start")
        self.f(*args, **kw)
        print("Logger end")

@Logger
def func1(a,b):
    print("func1")
    print(a+b)

@Logger
def func2(a,b,c,d):
    print("func2")
    print(a*b*c-d)

func1(100,99)
func2(2,3,11,5)

 2.3 带有参数的类装饰器

        类装饰器带有参数时候稍微复杂一点

# 定义装饰器函数 logger
class Logger(object):
    def __init__(self, level):
        self.level = level
    def __call__(self,func,*args, **kw):
        def wrapper(*args, **kwargs):
            print("[{0}]: enter {1}()".format(self.level, func.__name__))
            return func(*args, **kwargs)
        return wrapper

@Logger(True)
def func1(a,b):
    print("func1")
    print(a+b)

@Logger(False)
def func2(a,b,c,d):
    print("func2")
    print(a*b*c-d)

func1(100,99)
func2(2,3,11,5)

'''

要是大家觉得写得还行，麻烦点个赞或者收藏吧，想个博客涨涨人气，非常感谢！

'''

江南野栀子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python中装饰器和被装饰函数都有参数的使用
abin的博客
01-14 401
python中装饰器和被装饰函数都有参数的使用
python 装饰器简单笔记（附 *args **kw）
lilong117194的博客
04-26 1849
1. 装饰器 由于函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数。 现在，假设我们要增强函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。 本质上，decorator就是一个返回函数的高阶函数。 # 这里定义一个能打印日志的decorator,所以接受一个函数作...
python wrapper函数_初学Python函数的笔记整理
weixin_30670859的博客
01-28 1415
定义返回单值 def my_abs(x):if x >= 0:return xelse:return -x返回多值返回多值就是返回一个tuple import mathdef move(x, y, step, angle=0):nx = x + step * math.cos(angle)ny = y - step * math.sin(angle)return nx, ny空函数 def ...
python之logger使用案例
小白博客
01-04 2109
创建logger对象以及，且写入文件以及输出控制台 import logging import os.path import time class Logger(object): def __init__(self,logger): """指定保存日志的文件路径，日志级别，以及调用文件 将日志存入到指定的文件中 :paramlogger: """ # 创建一个logger self.logger =.
python的日志配置
wcl1800的博客
05-25 272
一.类方法 class Logger(object): def __init__(self, log_file_name, log_level, logger_name): # 创建一个logger self.__logger = logging.getLogger(logger_name) # 指定日志的最低输出级别，默认为WARN级别 self.__logger.setLevel(log_level) # 创建
Python装饰器-失败用例自动重试Python装饰器-失败用例自动重试Python装饰器-失败用例自动重试Python装饰器-失败用例自动重试Python装饰
06-29
Python装饰器-失败用例自动重试
python装饰器-限制函数调用次数的方法(10s调用一次)
12-23
当时是笔试的，只写了大概的代码，回来后温习了python装饰器的基础知识，把代码写完了。决定写篇博客记录下。 装饰器分为带参数得装饰器以及不带参数得装饰器。 #不带参数的装饰器 @dec1 @dec2 def func(): ... #...
python-装饰器Decorators.pdf
最新发布
02-06
python方法 python_装饰器Decorators
简单了解python装饰器原理及使用方法
09-18
主要介绍了简单了解python装饰器原理及使用方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
python装饰器实例大详解
09-21
主要介绍了python装饰器实例大详解,非常不错，具有参考借鉴价值，需要的朋友可以参考下
Python黑魔法—学习笔记
studyeboy的专栏
08-28 570
王炳明的《Python 黑魔法手册》的学习笔记。 小整数池 在同一行里，同时给两个变量赋同一值时，解释器知道这个对象已经生成，那么它就会引用大同一个对象。如果分成两行的话，解释器并不直达这个对象已经存在了，就会重新申请内存存放这个对象。 intern机制 site-packages和dist-packages dist-packages是debian系的Linux系统（如Ubuntu）才有的目录，当使用apt去安装的Python包会使用dist-packages，而使用pip或者easy_insta
一篇文章搞懂装饰器所有用法
woliuqiangdong的博客
10-28 550
对于每一个学习 Python 的同学，想必对@符号一定不陌生了，正如你所知， @ 符号是装饰器的语法糖，@符号后面的函数就是我们本文的主角：装饰器。 装饰器放在一个函数开始定义的地方，它就像一顶帽子一样戴在这个函数的头上。和这个函数绑定在一起。在我们调用这个函数的时候，第一件事并不是执行这个函数，而是将这个函数做为参数传入它头顶上这顶帽子，这顶帽子我们称之为装饰器。 曾经我在刚转行做程序员时的一次的面试中，被面试官问过这样的两个问题： 1、你都用过装饰器实现过什么样的功能？ 2、如何写一个可...
logging日志记录模板
Mugo_Moon的博客
03-26 255
import logging from logging import handlers # 定义日志文件格式 class Logger(object): level_relations = { 'debug': logging.DEBUG, 'info': logging.INFO, 'warning': logging.WARNING, 'error': logging.ERROR, 'crit': logging.
python logging模块handlers用法详解
哎呀美呔小丸子
06-21 5173
常用的3个日志文件类：StreamHandler、FileHandler、TimeRotatingFileHandler 1）StreamHandler：把日志输出到控制台 #!/usr/bin/env python3 # _*_ coding: utf-8 _*_ import logging import os.path import time from logging import handlers class Logger(object): def __init__(self):
【python】logger的使用
tiandaochouqin99的博客
07-04 350
logger_config.ini [loggers] keys = root [logger_root] level = DEBUG handlers = consoleHandler, fileHandler [handlers] keys = consoleHandler, fileHandler [handler_consoleHandler] class = StreamHan...
【Python日志封装类基本实现】
钱塘江渔夫的专栏
01-20 708
Python日志封装类基本实现 前言 日志功能，作为软件开发必不可少。Python的日志封装网上也有不少，不乏抄来抄去。抄，可以。但必须验证才能转发。如果仅仅是复制粘贴，就没意思了，甚至误导别人。以下是2天内自己研究验证的新的，与大家共享。 实现的思路是基于logging包。 需求： 支持屏幕打印和文件输出 支持日期、时间、引用源文件名（不要求全路径）、行号，日志信息 说明：这里是最基础的要求。更高要求实现，在后续文章介绍。 实现过程 直接上代码 class Logger(object): ''
python日志(Logger)的输出
Micheal 超 的博客
05-11 1921
方法一： import sys class Logger(object): def __init__(self, filename='default.log', stream=sys.stdout): self.terminal = stream self.log = open(filename, 'a') # add content def write(self, message): self.terminal.write(messag
python -----class(类)中的object是什么意思?
m0_37347812的博客
03-29 199
不继承object对象，只拥有了__doc__ , module 和 自己定义的name变量, 也就是说这个类的命名空间只有三个对象可以操作. Animal类继承了object对象，拥有了好多可操作对象，这些都是类中的高级特性。 对于不太了解python类的同学来说，这些高级特性基本上没用处，但是对于那些要着手写框架或者写大型项目的高手来说，这些特性就比较有用了，比如说tornado里面的异常捕获时就有用到__class__来定位类的名称，还有高度灵活传参数的时候用到__dict__来完成. 参考： cla
Logger之Logger.getLogger(CLass)
weixin_34248705的博客
09-16 1310
之前一直在使用System.out.println()来调试.但是用这种方式开发项目部署到生产环境,会因为众多的控制台输出降低应用的性能.这时候Log4J就成为可平衡开发和部署应用的利器了.   在项目中使用Log4J并不是一件困难的事情,简单粗暴的方式就是在每个类A中声明一个Logger私有属性     private static Logger logger =...
python装饰器 写在类上
07-27
- *1* *2* [python装饰器详解](https://blog.csdn.net/weixin_44992737/article/details/125868592)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

江南野栀子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值