前往小程序，Get更优阅读体验！
立即前往
文档建议反馈控制台
首页
学习
活动
专区
工具
TVP
最新优惠活动
文章/答案/技术大牛
发布
首页
学习
活动
专区
工具
TVP最新优惠活动
返回腾讯云官网
社区首页 >专栏 >Pyhton Cookbook 学习笔记 ch9_02 元编程[通俗易懂]

Pyhton Cookbook 学习笔记 ch9_02 元编程[通俗易懂]

作者头像
全栈程序员站长
发布于 2022-09-05 15:14:23
3960
发布于 2022-09-05 15:14:23
举报
文章被收录于专栏：全栈程序员必看

大家好，又见面了，我是你们的朋友全栈君。

【传送门】

9.8 将装饰器定义为类的一部分

  • 问题：想在类中定义装饰器，并作用在其他的函数上
  • 方案：在类中定义装饰器首先要确定它的使用方法，是作为一个实例方法还是作为一个类方法
代码语言：javascript
复制
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
代码语言：javascript
复制
#作为实列使用
a = A()
@a.decorator1
def spam():
    print('spam')
#作为类方法使用
@A.decorator2
def grok():
    print("grok")
  • 在类中定义装饰器很奇怪，但是标准库中有很多这种方式，@property装饰器实际上是一个类，他内部定义了三个方法getter()、setter()、deleter()每个方法都是装饰器
代码语言：javascript
复制
class Person:
    first_name = property()
    @first_name.getter
    def first_name(self):
        return self._first_name
    
    @first_name.setter
    def first_name(self,value):
        if not isinstance(value,str):
            raise TypeError("Expected a string")
        self._first_name = value

9.9 将装饰器定义为类

  • 问题：想使用一个装饰器去包装函数，但是希望返回一个可以调用的实例。需要让装饰器可以同时工作在类定义的内部和外部
  • 方案：为了将装饰器定义成一个实例，需要确保它实现了__call__()、__get__()方法
代码语言：javascript
复制
import types
from functools import wraps
class Profiled:
    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)
  • 接下来你可以将它作为一个装饰器使用，在类内或者外面都可以
代码语言：javascript
复制
@Profiled
def add(x, y):
    return x + y

class Spam:
    @Profiled
    def bar(self, x):
        print(self, x)
代码语言：javascript
复制
add(2,3)
代码语言：javascript
复制
5
代码语言：javascript
复制
add(4,5)
代码语言：javascript
复制
9
代码语言：javascript
复制
add.ncalls
代码语言：javascript
复制
2
代码语言：javascript
复制
s = Spam()
s.bar(1)
代码语言：javascript
复制
<__main__.Spam object at 0x00B65350> 1
代码语言：javascript
复制
s.bar(2)
代码语言：javascript
复制
<__main__.Spam object at 0x00B65350> 2
代码语言：javascript
复制
s.bar(10)
代码语言：javascript
复制
<__main__.Spam object at 0x00B65350> 10
代码语言：javascript
复制
Spam.bar.ncalls
代码语言：javascript
复制
3
  • 也可以使用闭包和nonlocal变量来实现装饰器
代码语言：javascript
复制
import types
from functools import wraps
def profiled(func):
    ncalls = 0
    @wraps(func)
    def wrapper(*args,**kwargs):
        nonlocal ncalls
        ncalls += 1
        return func(*args, **kwargs)
    wrapper.ncalls = lambda: ncalls
    return wrapper
代码语言：javascript
复制
@profiled
def add(x,y):
    return x+y
add(2,3)
代码语言：javascript
复制
5
代码语言：javascript
复制
add(3,4)
代码语言：javascript
复制
7
代码语言：javascript
复制
add.ncalls()
代码语言：javascript
复制
2

9.10 为类和静态方法提供装饰器

  • 问题：想要给类或者静态方法提供装饰器
  • 方案：在@classmethod或者@staticmethod之前定义
代码语言：javascript
复制
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
代码语言：javascript
复制
class Spam:
    @timethis
    def instance_method(self, n ):
        print(self, n)
        while n > 0:
            n -= 1
    @classmethod
    @timethis
    def class_method(cls,n):
        print(cls,n)
        while n > 0:
            n -= 1
            
    @staticmethod
    @timethis
    def static_method(n):
        print(n)
        while n > 0:
            n -= 1
  • 装饰后的类和静态方法可以正常工作，但是增加了计时功能
代码语言：javascript
复制
s = Spam()
s.instance_method(10000000)
代码语言：javascript
复制
<__main__.Spam object at 0x00B79510> 10000000
0.7324073314666748
代码语言：javascript
复制
Spam.class_method(1000000)
代码语言：javascript
复制
<class '__main__.Spam'> 1000000
0.12408709526062012
代码语言：javascript
复制
Spam.static_method(10000000)
代码语言：javascript
复制
10000000
0.8057591915130615
  • 注意：在使用的时候上面代码中@staticmethod和@timethis的顺序不能调换
  • 如果想要定义一个抽象类方法，可以使用下面的那样：
代码语言：javascript
复制
from abc import ABCMeta, abstractmethod
class A(metaclass=ABCMeta):
    @classmethod
    @abstractmethod
    def method(cls):
        pass
  • 上面的两个@也是不可以交换顺序的

9.11 装饰器为被包装函数增加参数

  • 问题：想要给被包装的函数增加额外的参数，但是不可以改变该函数的现有调用规则
  • 方案：可以使用关键字参数来给被包装的函数增加额外的参数
代码语言：javascript
复制
from functools import wraps
def optional_debug(func):
    @wraps(func)
    def wrapper(*args, debug=False, **kwargs):
        if debug:
            print('Calling ', func.__name__)
        return func(*args,**kwargs)
    return wrapper
@optional_debug
def spam(a,b,c):
    print(a,b,c)
代码语言：javascript
复制
spam(1,2,3)
代码语言：javascript
复制
1 2 3
代码语言：javascript
复制
spam(1,2,3,debug=True)
代码语言：javascript
复制
Calling  spam
1 2 3
  • 通过装饰器给被包装的函数增加参数并不常见，但有事该方法可以避免代码的重复
代码语言：javascript
复制
def a(x,debug=False):
    if debug:
        print("calling a")
def b(x,y,z,debug=False):
    if debug:
        print("calling b")
def c(x,y,debug=False):
    print("calling c")
代码语言：javascript
复制
# 我们可以将上述代码重写为：
from functools import wraps
import inspect
def optional_debug(func):
    if 'debug' in inspect.getfullargspec(func).args:
        raise TypeError("debug argument already defined")
    @wraps(func)
    def wrapper(*args, debug=False, **kwargs):
        if debug:
            print("calling ",func.__name__)
        return func(*args,**kwargs)
    return wrapper

@optional_debug
def a(x):
    pass
@optional_debug
def b(x,y,z):
    pass
@optional_debug
def c(x,y):
    pass

9.12 使用装饰器扩充类的功能

  • 问题：想通过反省或者重写类定义来修改其部分i行为，但是不想使用继承
  • 方案：使用类装饰器
代码语言：javascript
复制
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
代码语言：javascript
复制
a = A(22)
a.x
代码语言：javascript
复制
getting :  x





22
代码语言：javascript
复制
a.spam()
代码语言：javascript
复制
getting :  spam

9.13 使用元类控制实例的创建

  • 问题：想要通过改变实例创建的方式来实现单例、缓存、等特性
  • 方案：如下
代码语言：javascript
复制
# 我们知道python创建的类可以像函数一样调用它来创建实例
class Spam:
    def __init__(self,name):
        self.name = name
a = Spam("Guido")
b = Spam("Diana")
代码语言：javascript
复制
# 假设我们不想让任何人创建该类的实例
class NoInstance(type):
    def __call__(self,*args,**kwargs):
        raise TypeError("can't instance directly")
class Spam(metaclass=NoInstance):
    @staticmethod
    def grok(x):
        print("Spam.grok")
代码语言：javascript
复制
#这样我们只能调用该类的静态方法，而不能进行实例化
Spam.grok(42)
代码语言：javascript
复制
Spam.grok
代码语言：javascript
复制
s = Spam()
代码语言：javascript
复制
---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-30-ee1b074714bf> in <module>()
----> 1 s = Spam()


<ipython-input-28-8781af2ac6ac> in __call__(self, *args, **kwargs)
      2 class NoInstance(type):
      3     def __call__(self,*args,**kwargs):
----> 4         raise TypeError("can't instance directly")
      5 class Spam(metaclass=NoInstance):
      6     @staticmethod


TypeError: can't instance directly
  • 假如你仅仅想要创建一个实例（单例模式）：
代码语言：javascript
复制
class Singleton(type):
    def __init__(self, *args,**kwargs):
        self.__instance = None
        super().__init__(*args,**kwargs)
    def __call__(self,*args, **kwargs):
        if self.__instance is None:
            self.__instance = super().__call__(*args, **kwargs)
            return self.__instance
        else:
            return self.__instance
class Spam(metaclass = Singleton):
    def __init__(self):
        print("creating Spam")
代码语言：javascript
复制
a = Spam()
代码语言：javascript
复制
creating Spam
代码语言：javascript
复制
b = Spam()
代码语言：javascript
复制
a == b
代码语言：javascript
复制
True
代码语言：javascript
复制
a is b
代码语言：javascript
复制
True
  • 假设想要缓存实例
代码语言：javascript
复制
import weakref
class Cached(type):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.__cache = weakref.WeakValueDictionary()
    def __call__(self, *args):
        if args in self.__cache:
            return self.__cache[args]
        else:
            obj = super().__call__(*args)
            self.__cache[args] = obj
            return obj
class Spam(metaclass=Cached):
    def __init__(self,name):
        print("creating Spam({!r})".format(name))
        self.name = name
代码语言：javascript
复制
a = Spam('Guodo')
代码语言：javascript
复制
creating Spam('Guodo')
代码语言：javascript
复制
b = Spam("Diana")
代码语言：javascript
复制
creating Spam('Diana')
代码语言：javascript
复制
c = Spam("Guodo")
代码语言：javascript
复制
#注意上面并没有重新创建
a is c
代码语言：javascript
复制
True
代码语言：javascript
复制
a is b
代码语言：javascript
复制
False

9.14 捕获类的属性定义顺序

  • 问题：想要自动的记录一个类中属性和方法的定义顺序
  • 方案：利用元类
代码语言：javascript
复制
from collections import OrderedDict
class Typed:
    _expected_type = type(None)
    def __init__(self,name=None):
        self._name = name
    def __set__(self, instance, value):
        if not isinstance(value, self._expected_type):
            raise TypeError('type Error')
        instance.__dict__[self._name] = value

class Integer(Typed):
    _expected_type = int
class Float(Typed):
    _expected_type = float
class String(Typed):
    _expected_type = str
class OrderMeta(type):
    def __new__(cls, clsname, bases, clsdict):
        d = dict(clsdict)
        order = []
        for name, value in clsdict.items():
            if isinstance(value, Typed):
                value._name = name
                order.append(name)
        d['_order'] = order
        return type.__new__(cls, clsname, bases, d)
    @classmethod
    def __prepare__(cls, clsname, bases):
        return OrderedDict()
  • 下面将使用上面代码将一个类实例的数据序列化为一个csv数据
代码语言：javascript
复制
class Structure(metaclass=OrderMeta):
    def as_csv(self):
        return ','.join(str(getattr(self,name)) for name in  self._order)
class Stock(Structure):
    name = String()
    shares = Integer()
    price = Float()
    def __init__(self, name, shares, price):
        self.name = name
        self.shares = shares
        self.price = price
代码语言：javascript
复制
s = Stock("google",100, 234.19)
s.name
代码语言：javascript
复制
'google'
代码语言：javascript
复制
s.as_csv()
代码语言：javascript
复制
'google,100,234.19'

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

本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。
原始发表：2022年6月3，如有侵权请联系 cloudcommunity@tencent.com 删除
java
https
c++
网络安全
缓存

本文分享自 作者个人站点/博客 前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ，欢迎热爱写作的你一起参与！

java
https
c++
网络安全
缓存
评论
登录后参与评论
0 条评论
热度
最新
登录 后参与评论
推荐阅读
LV.
文章
0
获赞
0
目录
  • 9.8 将装饰器定义为类的一部分
  • 9.9 将装饰器定义为类
  • 9.10 为类和静态方法提供装饰器
  • 9.11 装饰器为被包装函数增加参数
  • 9.12 使用装饰器扩充类的功能
  • 9.13 使用元类控制实例的创建
  • 9.14 捕获类的属性定义顺序
领券

腾讯云开发者

扫码关注腾讯云开发者

扫码关注腾讯云开发者

领取腾讯云代金券

热门产品

热门推荐

更多推荐

Copyright © 2013 - 2024 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569

腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号 | 京公网安备号11010802020287

问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

Copyright © 2013 - 2024 Tencent Cloud.

All Rights Reserved. 腾讯云 版权所有

登录 后参与评论