1. 全栈程序员必看首页

Python装饰器

全栈程序员-站长 • • 未分类 • 阅读 45

装饰器表现形式1.函数装饰器编写自定义装饰器有许多方法，但最简单的方法是编写一个函数，返回包装原始函数调用的一个子函数例1：>>>[DEBUG]:entersay_he

大家好，又见面了，我是全栈君，今天给大家准备了Idea注册码。

全栈程序员社区此处内容已经被作者隐藏，请输入验证码查看内容
验证码：
请关注本站微信公众号，回复“验证码”，获取验证码。在微信里搜索“全栈程序员社区”或者“www_javaforall_cn”或者微信扫描右侧二维码都可以关注本站微信公众号。

　　Python装饰器的作用是使函数包装和方法包装变得更容易阅读和理解，最常见的就是@staticmethod和@classmethod，下面将从装饰器的表现形式和常用装饰器模式两方面进行描述和总结，若有不正确之处望大家指出。

装饰器表现形式

1. 函数装饰器

　　编写自定义装饰器有许多方法，但最简单的方法是编写一个函数，返回包装原始函数调用的一个子函数

　　例1：

#coding=utf-8

def debug(func):
    def wrapper(*agrs, **kwargs):
        '''包装函数内部文档''' 
        print ("[DEBUG]:enter %s()--%s" %(func.__name__, *agrs))
        return func(*agrs, **kwargs)
    return wrapper

@debug
def say_hello(parm):
    ''' 提供函数文档字符串'''
    print ("say_hello")
        
if __name__ == "__main__":
    say_hello("Python")
    print ("原始函数名：%s" %(say_hello.__name__))
    print ("函数文档字符串：%s" %(say_hello.__doc__))

>>> [DEBUG]:enter say_hello()–Python
>>> say_hello
>>> 原始函数名：wrapper
>>> 函数文档字符串：包装函数内部文档

　　例2：

#coding=utf-8

from functools import wraps

def debug(func):
    @wraps(func)
    def wrapper(*agrs, **kwargs):
        '''包装函数内部文档''' 
        print ("[DEBUG]:enter %s()--%s" %(func.__name__, *agrs))
        return func(*agrs, **kwargs)
    return wrapper

@debug
def say_hello(parm):
    ''' 提供函数文档字符串'''
    print ("say_hello")
    
if __name__ == "__main__":
    say_hello("Python")
    print ("原始函数名：%s" %(say_hello.__name__))
    print ("函数文档字符串：%s" %(say_hello.__doc__))

>>> [DEBUG]:enter say_hello()–Python
>>> say_hello
>>> 原始函数名：say_hello
>>> 函数文档字符串： 提供函数文档字符串

注意例1与例2的区别，也是使用装饰器的常用错误，在使用装饰器时不保存函数元数据（文档字符串和原始函数名）

2. 类作为装饰器

　　虽然装饰器几乎总是可以用函数来实现，但如果装饰器需要复杂的参数化或者依赖特定状态的话，使用自定义类进行封装可能会更好

#coding=utf-8

from functools import wraps

class debug:
    def __init__(self, func):
        self.func = func

    def __call__(self, *argv, **kwargv):
        '''包装函数内部文档'''
        print ("[DEBUG]:enter %s()--%s" %(self.func.__name__, *argv))
        self.func(*argv, **kwargv)

def say_hello(something):
    ''' 提供函数文档字符串 '''
    print ("say_hello", something)
    
if __name__ == "__main__":
    De = debug(say_hello)
    De("Python")
    print ("原始函数名：%s" %(say_hello.__name__))
    print ("函数文档字符串：%s" %(say_hello.__doc__))

>>> [DEBUG]:enter say_hello()–Python
>>> say_hello Python
>>> 原始函数名：say_hello
>>> 函数文档字符串： 提供函数文档字符串

3. 参数化装饰器

　　在实际代码中通常需要使用参数化的装饰器，比如次数、类型判断等，下面是一个简单的装饰器示例，给定重复次数，每次被调用时都会重复执行被装饰函数

#coding=utf-8

from functools import wraps

#参数化装饰器
def repeat(number=3):
    def debug(func):
        @wraps(func)
        def wrapper(*argv, **kwargv):
            '''包装函数内部文档'''
            for _ in range(number):
                print ("[DUBEG]:enter %s()--%s" %(func.__name__, *argv))
                result = func(*argv, **kwargv)
            return result
        return wrapper 
    return debug    

@repeat(2)
def say_hello(*agrv, **kwargv):
    '''提供函数文档字符串'''
    print ("say_hello")
    
if __name__ == "__main__":  
    say_hello("Python")
    print ("原始函数名：%s" %(say_hello.__name__))
    print ("函数文档字符串：%s" %(say_hello.__doc__))

>>> [DUBEG]:enter say_hello()–Python
>>> say_hello
>>> [DUBEG]:enter say_hello()–Python
>>> say_hello
>>> 原始函数名：say_hello
>>> 函数文档字符串：提供函数文档字符串

4. 装饰器装饰类

　　和装饰一个函数类似，也可以写一个函数来装饰类，用来向类中添加功能，基本原则一致，装饰器是一个函数或是一个可调用对象，它接受一个类作为参数，返回一个类作为返回值

#coding = utf-8

def decoratortest(cls):
    print ("{0.__class__.__qualname__}".format(cls))
    return cls

@decoratortest
class testclass:
    def __init__(self, value):
        self.value = value

    def __repr__(self):
        return "{0}:88".format(self)    

if __name__ == "__main__":
 
    t = testclass(88)

常用装饰器模式

1. 参数检查

　　将函数注册到全局字典中，并将其参数和返回值保存在一个类型列表中，并对参数类型进行检测

#coding=utf-8

'''将函数注册到全局字典中，并将其参数和返回值保存在一个类型列表中'''

funname = {}
def parmcheck(in_= (type(None),), out_ =(type(None), )):
    def fun1(func):
        func_name = func.__name__
        print ("funname:%s" %(func_name))
        funname[func.__name__] = (in_, out_)
        def checkType(elements, types):
            '''用来检查参数类型的子函数'''
            if len(elements) != len(types):
                raise TypeError("Parm count is wrong!")
            li = zip(elements, types)
            typed = enumerate(li)
            for index,couple in typed:
                argv, intype = couple
                if isinstance(argv, intype):
                    print ("parm(%s) and type(%s)are all right" %(argv, intype))
                    continue
                raise TypeError("argv %d should be %s" %(argv, intype))    
                
        def decoratorfun(*argv):
            #types = [type(i) for i in range(len(argv))]
            #checkType(argv, types)
            checkType(argv, in_)
            res = func(*argv)
            #检查输出内容
            if type(res) not in (tuple, list):
                checkable_res = (res, )
            else:
                checkable_res = res
            checkType(checkable_res, out_)    
        return decoratorfun
    return fun1    
             
@parmcheck((int,int)) 
def meth1(a,b):
    print ("received:%d,%d" %(a, b))

if __name__=="__main__":
    meth1(1,2)
    print (funname)

>>> funname:meth1
>>> parm(1) and type(<class ‘int’>)are all right
>>> parm(2) and type(<class ‘int’>)are all right
>>> received:1,2
>>> parm(None) and type(<class ‘NoneType’>)are all right
>>> {‘meth1’: ((<class ‘int’>, <class ‘int’>), (<class ‘NoneType’>,))}

注意zip、enumerate、解包、isinstance方法的使用

2. 缓存

　　缓存装饰器与参数检查十分相似，它的重点是关注那些内部状态不会影响输出的函数，每组参数都可以连接到唯一的结果

#coding = utf-8

import time
import pickle
import hashlib

#全局字典
cache = {}

def is_obsolete(entry, duration):
    print (time.time() - entry["time"])
    return time.time() - entry["time"] > duration

def compute_key(func, *argv, **kwargv):
    key = pickle.dumps((func.__name__, argv, kwargv))
    return hashlib.sha1(key).hexdigest()

def memoize(duration=10):
    def _memoize(func):
        def __memoize(*argv, **kwargv):
            key = compute_key(func,*argv, **kwargv)
            if ((key in cache) and not is_obsolete(cache[key], duration)):
                print ("we got a winner")
                return cache[key]['value']    
            result = func(*argv, **kwargv)
            cache[key]={"value":result,"time":time.time()}
            return result
        return __memoize
    return _memoize    

@memoize(3)
def fun(a,b):
    print (a+b)
    return a+b

if __name__=="__main__":
    fun(2,3)
    fun(2,2)
    fun(2,3)
    print (cache)

>>> 5
>>> 4
>>> 0.0
>>> we got a winner
>>> {‘a99634a4e619a2ad129df1b51002a8c0cb9cca2b’: {‘value’: 5, ‘time’: 1518243058.456
>>> 425}, ‘99683ddc4e22fd3f37e473de5d61699a5c27c2c6’: {‘value’: 4, ‘time’: 151824305
>>> 8.456425}}

3. 代理

　　代理装饰器使用全局机制来标记和注册函数。比如一个根据当前用户来保护代码访问的安全层可以使用集中式检查器和相关的可调用对象要求的权限来访问，这一模型常用于Python Web框架中，用于定义法布类的安全性

4. 上下文提供者

 　　上下文装饰器确保函数可以允许在正确的上下文中，比如临界资源的使用

#coding=utf-8

from threading import RLock

lock = RLock()

def synchronized(func):
    def _synchronized(*argv, **kdargv):
        lock.require()
        try:
            return func(*argv, **kdargv)
        except:
            print ("fun error!!!")
        finally:
            lock.release()
    return _synchronized

上下文装饰器通常会被上下文管理器with语句代替

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请联系我们举报，一经查实，本站将立刻删除。

发布者：全栈程序员-站长，转载请注明出处：https://javaforall.net/120210.html原文链接：https://javaforall.net

赞 (0)
全栈程序员-站长的头像全栈程序员-站长
0 0


相关推荐

  • MongoDB(二)—-数据库操作

    MongoDB(二)—-数据库操作

    MongoDB(二)—-数据库操作

    全栈程序员-站长的头像 全栈程序员-站长
    2020年11月12日
    194
  • 用Java代码实现学生管理系统[通俗易懂]

    用Java代码实现学生管理系统[通俗易懂]

    用Java代码实现学生管理系统[通俗易懂]学生管理系统1.1项目演示1.2学生管理系统实现思路定义学生类主界面的代码编写添加学生的代码编写查看学生的代码编写删除学生的的代码编写修改学生的代码编写1.3定义学生类学生类：Student成员变量：学号：sid姓名：name年龄：age居住地：address构造方法：无参构造带四个参数的构造成员方法：每个成员变量对应给出get/set方法1.4主界面的代码编写思路用输出语句完成主界面的编写用Scanner实现键盘录

    全栈程序员-站长的头像 全栈程序员-站长
    2022年9月20日
    2
  • Latex大括号及多行公式[通俗易懂]

    Latex大括号及多行公式[通俗易懂]

    Latex大括号及多行公式[通俗易懂]array中lrc表示各列内容的居左、居中、居右。.\begin{equation}\left\{\begin{array}{lr}x=\dfrac{3\pi}{2}(1+2t)\cos(\dfrac{3\pi}{2}(1+2t)),&\\y=s,&0\leqs\leqL,|t|\le

    全栈程序员-站长的头像 全栈程序员-站长
    2022年10月11日
    3
  • 数据库的第一范式，第二范式，第三范式，BCNF范式理解

    数据库的第一范式，第二范式，第三范式，BCNF范式理解

    数据库的第一范式，第二范式，第三范式，BCNF范式理解第一范式属性的原子性所谓的第一范式就是数据库中的每一列都是不可分割的基本数据项，同一列中不能有多个值，即实体中的某个属性不能有多个值或者不能有重复的属性，如果出现重复的属性则需要重新构建实体，新的实体由重复的属性构成。见图分析图：在进货和销售中有两个重复的属性（数量和单价）,并且进价和销售是可以再分割的，不满足原子性，即不满足第一范式，可以修改为下面的两个实体第二范式属性完…

    全栈程序员-站长的头像 全栈程序员-站长
    2022年5月24日
    49
  • upload通关手册

    upload通关手册

    uploadlabs通关0x00前言这段时间一直在忙，没时间来更新文章，这里就写篇uploadlabs的通关手册吧，现在包括网上也有很多upload通关手册，但是在这里还是想自己去写一篇，来

    全栈程序员-站长的头像 全栈程序员-站长
    2021年12月11日
    51
  • 茂名天源石化有限责任公司_茂名石化为什么在茂名

    茂名天源石化有限责任公司_茂名石化为什么在茂名

    茂名天源石化有限责任公司_茂名石化为什么在茂名目前来看，广东省已经拥有诸多国外化工巨头、大型民营炼化企业和不少国企的炼化项目，成为很多石化企业首选的项目落地基地。“石化业高质量发展看广东”，已经逐渐明朗。今年以来，已有恒力石化(惠州)PTA项目、东华能源(茂名)烷烃资源综合利用项目(一期)、茂名天源石化碳三碳四资源利用等项目开工今年3月31日，广东省发展改革委官网公布《广东省2021年重点建设项目计划》。在2021年重点项目名单中，广东共安排省重点项目1395个，总投资达7.28万亿元，年度计划投资8000亿元。其中新开工项目有3个，总投资约2

    全栈程序员-站长的头像 全栈程序员-站长
    2022年10月16日
    3

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

关注全栈程序员社区公众号