1给函数添加一个包装

问题：给函数加一个外包装层，已添加额外的处理，例如，记录日志，计时统计等

解决方案：可以定义一个装饰器来包装函数

2编写装饰器时如何保存函数的元数据

问题：当一个函数被装饰器装饰时，一些重要的元数据比如：函数名、文档字符串、函数注解以及调用签名都丢失了

解决方案：每当定义一个装饰器时应该总是记得为底层的包装函数添加functools库中的@wraps装饰器

#问题：当一个函数被装饰器装饰时，一些重要的元数据比如：函数名、文档字符串、函数注解以及调用签名都丢失了

#解决方案：每当定义一个装饰器时应该总是记得为底层的包装函数添加functools库中的@wraps装饰器

import time

import functools

def timethis(func):

    @functools.wraps(func)

    def wrapper(*args,**kwargs):

        start_time = time.time()

        result = func(*args,**kwargs)

        end_time = time.time()

        print(func.__name__,end_time-start_time)

        return result

    return wrapper

@timethis

def mysleep(num:int):

    """

    原函数注释文档

    :param num:

    :return:

    """

    time.sleep(num)

    print("我是原函数")

mysleep(3)

print(mysleep.__name__)

print(mysleep.__doc__)

print(mysleep.__annotations__)

#如果装饰器使用@functools.wraps(func) 装饰，我们就可以使用下面的方法获取到原函数！！！

mysleep.__wrapped__(3)


3对装饰器进行解包装


问题： 我们已经把装饰器添加到函数上了，但是想撤销它，访问未经包装的原函数。

解决方案：假设装饰器已经实现了@warps(func)，一般来说我们可以通过访问__wrapped__属性来获取到原函数


4定义一个可接收参数的装饰器


问题：我们想编写一个可接收参数的装饰器函数

解决方案：假设我们想编写一个为函数添加日志功能的装饰器，但是又允许用户指定日志的等级以及一些其他的细节操作作为参数。




import logging

import functools

def logged(level,name=None,message=None):

    def decorate(func):

        logname = name if name else func.__module__

        log = logging.getLogger(logname)

        logmsg = message if message else func.__name__

        @functools.wraps(func)

        def wrapper(*args,**kwargs):

            log.log(level,message)

            return func(*args,**kwargs)

        return wrapper

    return decorate




5定义一个属性可由用户修改的装饰器


问题：我们想编写一个装饰器来包装函数，但是可以让用户调整装饰器的属性，这样在运行时就能够控制装饰器的行为




from functools import wraps,partial

import logging

def attach_wrapper(obj,func=None):

    if func is None:

        return partial(attach_wrapper,obj)

    setattr(obj,func.__name__,func)

    return func

def logged(level,name=None,message=None):

    def decorate(func):

        logname = name if name else func.__module__

        log = logging.getLogger(logname)

        logmsg = message if message else func.__name__

        @wraps(func)

        def wrapper(*args,**kwargs):

            log.log(level,logmsg)

            return func(*args,**kwargs)

        @attach_wrapper(wrapper)

        def set_level(newlevel):

            nonlocal level

            level = newlevel

        @attach_wrapper(wrapper)

        def set_message(newmsg):

            nonlocal logmsg

            logmsg = newmsg

        return wrapper

    return decorate

logging.basicConfig(level=logging.DEBUG)

@logged(logging.DEBUG)

def add(x,y):

    return x + y

add(2,5)

add.set_message("Add called")

add(3,8)




6定义一个能接收可选参数的装饰器


问题：我们想编写一个单独的装饰器，使其既可以像@decorator 这样不带参数，也可以像@decorator(x,y,z)这样接收可选参数




from functools import wraps,partial

import logging

def logged(func=None,*,level=logging.DEBUG,name=None,message=None):

    if func is None:

        return partial(logged,level=level,name=name,message=message)

    logname = name if name else func.__module__

    log = logging.getLogger(logname)

    logmsg = message if message else func.__name__

    @wraps(func)

    def wrapper(*args,**kwargs):

        log.log(level,logmsg)

        return func(*args,**kwargs)

    return wrapper

@logged

def add(x,y):

    logging.debug("hahahah")

    return x+y

#没有参数时，装饰器就相当于：logged(func),所以装饰器的第一个参数就是func,其他都是可选参数

@logged(level=logging.CRITICAL,name="example")

def spam():

    print("spam!!!")

#有参数时，装饰器就相当于logged(level=logging.DEBUG,name="example")(spam)

#巧妙的利用functools.partial 将构建好的方法返回

add(1,2)

spam()




7利用装饰器对函数参数强制执行类型检查


问题：我们想为函数参数添加强制类型检查功能，将其作为一种断言或者与调用者之间的契约




from inspect import signature

from functools import wraps

def typeassert(*ty_args,**ty_kwargs):

    def decorate(func):

        if not __debug__:

            return func

        sig = signature(func)#获取func的参数签名（x,y,z）

        bound_types = sig.bind_partial(*ty_args,**ty_kwargs).arguments# 参数签名与类型参数做映射   [("x",<class "int">),("z",<class "int">)]

        @wraps(func)

        def wrapper(*args,**kwargs):

            bound_values = sig.bind(*args,**kwargs).arguments# 参数签名与函数参数做映射

            for name,value in bound_values.items():

                if name in bound_types:#判断参数是否有类型限制

                    if not isinstance(value,bound_types[name]):

                        raise TypeError("Argument {} must be {}".format(name,bound_types[name]))

            return func(*args,**kwargs)

        return wrapper

    return decorate

class A():

    def a(self):

        print("a")

@typeassert(int,A,z=int)

def add(x,y,z):

    print(x,y,z)

    return x

add(1,A(),3)

#想法：参数类型的限制可以使用在参数处理方法中，对前端接收的参数进行检查，也可以使用在一些需要限制传入参数类型的地方

#注：此装饰器一个微妙的地方，只检查传递的参数，如果是默认参数，没有进行传递，参数类型不进行检查

@typeassert(int,list)

def bar(x,items=None):

    if items is None:

        items = []

    items.append(x)

    return items

print(bar(2))




8在类中定义装饰器


问题： 我们想在类中定义一个装饰器，并将其作用到其他函数或方法上




from functools import wraps

class A:

    def decorator1(self,func):

        @wraps(func)

        def wrapper(*args,**kwargs):

            print("decorator 1")

            return func(*args,**kwargs)

        return wrapper

    @classmethod

    def decorator2(cls,func):

        @wraps(func)

        def wrapper(*args,**kwargs):

            print("decorator 2")

            return func(*args,**kwargs)

        return wrapper

#思考：@property 实际上是一个拥有 getter(),setter(),deleter()方法的类，每一个方法都可作为一个装饰器

#几个装饰器都可以操纵实例的状态，因此，如果需要装饰器在背后记录或合并信息，这是一个很明智的方法。




9把装饰器定义成类


问题： 我们想用装饰器来包装函数，但是希望得到的结果是一个可调用的实例。我们需要装饰器既能在类中工作，也可以在类外部使用

解决方案：要把装饰器定义成类实例，需要确保在类中实现__call__()和__get__()方法




import types

from functools import wraps

class Profield:

    def __init__(self,func):

        wraps(func)(self)

        self.ncalls = 0

    def __call__(self, *args, **kwargs):

        self.ncalls +=1

        return self.__wrapped__(*args,**kwargs)

    def __get__(self, instance, cls):

        if instance is None:

            return self

        else:

            return types.MethodType(self,instance)

#该装饰器相当于为函数添加一个属性 ncalls




10把装饰器作用到类和静态方法上


问题：我们想在类或者静态方法上应用装饰器

解决方案：将装饰器作用到类和静态方法上是简单而直接的，但是要保证装饰器在应用的时候需要放在@classmethod 和 @staticmethod 之前，示例如下：




import time

from functools import wraps

def timethis(func):

    @wraps(func)

    def wrapper(*args,**kwargs):

        start = time.time()

        r = func(*args,**kwargs)

        end = time.time()

        print(end-start)

        return r

    return wrapper




@classmethod 和 @staticmethod 装饰器并不会返回一个可执行对象，所以装饰器都要放在他们下面！！！


11编写装饰器为被包装函数添加参数


问题：我们想编写一个装饰器，为被包装的函数添加额外的参数，但是添加的参数不能影响到该函数已有的调用约定

解决方案：




from functools import wraps

def optinoal_debug(func):

    @wraps(func)

    def wrapper(*args,debug=False,**kwargs):

        if debug:

            print("Calling",func.__name__)

        return func(*args,**kwargs)

    return wrapper




函数中的一部分参数被装饰器解析所用，剩下参数给到函数，可以用被包装函数的参数来控制装饰器的行为


12利用装饰器给函数定义打补丁


#问题：我们想检查或改写一部分类的定义，以此来修改类的行为，但是不想通过继承或者元类的方式来做

#解决方案：




def log_getattribute(cls):

    orig_getattribute = cls.__getattribute__

    def new_getattribute(self,name):

        print("getting",name)

        return orig_getattribute(self,name)

    cls.__getattribute__ = new_getattribute

    return cls

@log_getattribute

class A:

    def __init__(self,x):

        self.x = x

    def spam(self):

        pass

a = A(42)

a.x




可以通过此方法对类的属性做监控
												


																

最新文章
	

    
						
  1. Nagios+zabbix+ganglia的相关参数分析和优缺点介绍
		
    2. 
						
  2. Python Snippet
		
    3. 
						
  3. POJ1151+线段树+扫描线
		
    4. 
						
  4. PHP array_chunk() 函数
		
    5. 
						
  5. 缓存 Cache
		
    6. 
						
  6. No Hibernate Session bound to thread, and configuration does not allow creat
		
    7. 
						
  7. 怎样在UICollectionView中添加Header和footer
		
    8. 
						
  8. jspsmart(支持中文下载)
		
    9. 
						
  9. 用ArrayList（解决约瑟夫问题）
		
    10. 
						
  10. jQuery的$.ajax方法响应数据类型有哪几种？本质上原生ajax响应数据格式有哪几种，分别对应哪个属性？
		
    11. 
						
  11. Intellij-创建Maven项目速度慢
		
    12. 
						
  12. linux 命令：tr 的简单使用
		
    13. 
						
  13. ionic3 小记录
		
    14. 
						
  14. Nginx使用教程(七)：使用Nginx缓存之proxy cache
		
    15. 
						
  15. pring @Configuration 和 @Component 区别
		
    16. 
						
  16. General Test Scenarios
		
    17. 
						
  17. python闭包的理解说明
		
    18. 
						
  18. Python之路，第十九篇：Python入门与基础19
		
    19. 
						
  19. CommonJS/AMD/CMD/UMD
		
    20. 
						
  20. python模块部分 re模块 之正则表达式
		
    21. 
		

	


热门文章
	

    
									
  1. 转：Mongoose使用操作
			
    2. 
						
  2. 用nodejs调用webservice
			
    3. 
						
  3. 使用burpsuite进行重放攻击
			
    4. 
						
  4. Storm 学习之路（三）——  Storm单机版本环境搭建
			
    5. 
						
  5. 【粗略版】Linux deploy手机上创建自己的服务器
			
    6. 
						
  6. 使用事件注册器进行swoole代码封装
			
    7. 
						
  7. Windows使用Python虚拟环境
			
    8. 
						
  8. ~~函数基础（二）：返回值&amp;作用域~~
			
    9. 
						
  9. 获取一个整数所有的质因数(C语言实现)
			
    10. 
						
  10. linux应用程序设计--Makefile工程管理
			
    11.