杂项之python描述符协议

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了杂项之python描述符协议相关的知识,希望对你有一定的参考价值。

杂项之python描述符协议

本节内容

  1. 由来
  2. 描述符协议概念
  3. 类的静态方法及类方法实现原理
  4. 类作为装饰器使用

1. 由来

闲来无事去看了看django中的内置分页方法,发现里面用到了类作为装饰器来使用,由于之前就看到过这一类的用法,但是一直没有明白具体是如何实现的,今天本着打破砂锅问到底的精神去网上搜资料,在这里不得不吐槽下百度搜索的垃圾了。。。。。竞价排名做的那么6,搜一些技术文档。。。。。各种坑爹。。。就是找不到想要的资源。。。
于是FQ上google搜了搜,找到了python官网的文档。。。里面详细解释了原理以及用法,表示英语渣是硬伤。。。。囫囵吞枣的理解了里面的一部分内容。。。于是就有了本文的诞生。。。。。python官网文档连接在这:
python官方文档地址
英语比较好的小伙伴可以去拜读下。

2. 描述符协议概念

在python中有个概念叫做描述符(descriptors)
描述符在python中是一个协议,协议的定义如下:
如果为某个对象定义了__get__,__set__及__delete__中的任意一种方法,那么就称这个对象是描述符。
描述符是一个功能强大的通用协议,类中的属性,方法,静态方法,类方法甚至super()背后都是基于描述符它是在python2.2中引入的新式类中实现的,描述符使底层的C代码实现更简单,并且为python编程提供了一个灵活的新工具。

官方说明如下:

descr.__get__(self, obj, type=None) --> value

descr.__set__(self, obj, value) --> None

descr.__delete__(self, obj) --> None

如果对象中定义了__get__()和__set__(),它被认为是一个数据描述符。只定义__get__()的描述符称为非数据描述符(它们通常用于方法,但其他用途也是可能的)。
数据和非数据描述符的区别在如何重写对象的字典计算实例。

  • 如果实例字典具有与数据描述符相同的项,则数据描述符将优先。
  • 如果实例字典具有与非数据描述符同名的项,则字典条目优先。

描述符的调用:
描述符在被调用时区别在于调用描述符的是对象还是类:
对于对象:

  • 数据描述符被优先调用
  • 非数据描述符可能会被实例字典所覆盖

解释:
非数据描述符在对象调用中可能会被实例字典覆盖的举例:

#-------------------------------------被实例的字典覆盖的例子-------------------------------------------------------------
class RevealAccess:
    """A data descriptor that sets and returns values
       normally and prints a message logging their access.
    """

    def __init__(self, initval=None, name=‘var‘):
        self.val = initval
        self.name = name

    def __get__(self, obj, objtype):
        print(‘Retrieving‘, self.name)
        return self.val

class MyClass:
    x=RevealAccess(10,‘var"x"‘)

m=MyClass()
m.x=3
print(m.x)
# 3
# 这里的非数据描述符被实例中的字典给覆盖了,当调用实例m的属性x的时候,x对应的是数字3

#---------------------------------------数据描述符被优先调用的例子-------------------------------------------------------
class RevealAccess:
    """A data descriptor that sets and returns values
       normally and prints a message logging their access.
    """

    def __init__(self, initval=None, name=‘var‘):
        self.val = initval
        self.name = name

    def __get__(self, obj, objtype):
        print(‘Retrieving‘, self.name)
        return self.val

    def __set__(self, obj, val):
        print(‘Updating‘, self.name)
        print(obj,val)
        self.val = val

class MyClass:
    x=RevealAccess(10,‘var"x"‘)

m=MyClass()
m.x=3
print(m.x)
# Updating var"x"
# <__main__.MyClass object at 0x0000021E5F33A7B8> 3
# Retrieving var"x"
# 3

# 这里的数据描述符无法被实例中的字典覆盖。。。当实例m给属性x赋值的时候,实际是调用了x对应的RevealAccess对象的__set__方法给属性x赋值,这里的数据描述符的优先级比对象的属性的优先级更高

会将对象b.x 转换成 type(b).__dict__[‘x’].__get__(obj, type(b))
对于类:
会将class.x 转换成 class.__dict__[‘x’].__get__(None, class)

python模拟__getattribute__()的实现

def __getattribute__(self, key):
    "Emulate type_getattro() in Objects/typeobject.c"
    v = object.__getattribute__(self, key)
    if hasattr(v, ‘__get__‘):
        return v.__get__(None, self)
    return v

需要重点记住的点:

  • 描述符只有在__getattribute__()的时候才会被调用
  • 重写__get__将会覆盖默认的__getattribute__()中的调用
  • __getattribute__()只适用于新式类和对象
  • object.__getattribute__() 和 type.__getattribute__()调用__get__()的方式不同
  • 数据描述符总是覆盖实例中的字典
  • 非数据描述符可能被实例字典所覆盖

例子:

class RevealAccess:
    """A data descriptor that sets and returns values
       normally and prints a message logging their access.
    """

    def __init__(self, initval=None, name=‘var‘):
        self.val = initval
        self.name = name

    def __get__(self, obj, objtype):
        print(‘Retrieving‘, self.name)
        return self.val

    def __set__(self, obj, val):
        print(‘Updating‘, self.name)
        print(obj,val)
        self.val = val

class MyClass:
    x=RevealAccess(10,‘var"x"‘)

m=MyClass()
print(m.x)
# Retrieving var"x"  通过对象调用属性x,将会执行RevealAccess对象的__get__方法(描述符)。
# 10
m.x = 20  # 将20赋值给MyClass的对象m的属性x-->RevealAccess对象-->调用RevealAccess对象的__set__方法
# Updating var"x"
# <__main__.MyClass object at 0x0000013064DAA7F0> 20  # __set__方法接收的第一个参数是MyClass对象,第二个参数是=后面的值
print(m.x)
# Retrieving var"x"
# 20

3. 类的静态方法及类方法实现原理

类的静态方法及类方法作用可以参考我之前的博客:
python 高级之面向对象初级

类的静态方法实现原理:

class StaticMethod(object):
    "Emulate PyStaticMethod_Type() in Objects/funcobject.c"

    def __init__(self, f):
        self.f = f

    def __get__(self, obj, objtype=None):
        return self.f

class E(object):
    @staticmethod
    def f(x):
        print x
    # 上面的装饰器相当于 f = staticmethod(f)

print E.f(3)
# 3
print E().f(3)
# 3

类方法实现原理:

class ClassMethod(object):
    "Emulate PyClassMethod_Type() in Objects/funcobject.c"
    def __init__(self, f):
        self.f = f

    def __get__(self, obj, klass=None):
        if klass is None:
            klass = type(obj)
        def newfunc(*args):
            return self.f(klass, *args)
        return newfunc

class Dict(object):

    @classmethod
    def fromkeys(klass, iterable, value=None):
        "Emulate dict_fromkeys() in Objects/dictobject.c"
        d = klass()
        for key in iterable:
            d[key] = value
        return d
    # 上面的装饰器相当于 fromkeys = classmethod(fromkeys)

print(Dict.fromkeys(‘abracadabra‘))
# {‘a‘: None, ‘r‘: None, ‘b‘: None, ‘c‘: None, ‘d‘: None}

#执行Dict.fromkeys相当创建了classmethod(fromkeys)对象,并执行了该对象的__get__方法,该方法返回一个新的函数,而后面的(‘abracadabra‘)相当于传递参数‘abracadabra‘执行了这个新函数,返回的是fromkeys的执行结果。

4. 类作为装饰器使用

代码如下:

class MyClassDescriptor:
    def __init__(self, func, name=None):
        self.func = func
        self.name = name or func.__name__
        self.__doc__=getattr(func, ‘__doc__‘)

    def __get__(self,instance,cls=None):
        if instance is None:
            print(instance,cls)
            return self
        print(instance,cls)
        res = instance.__dict__[self.name] = self.func(instance)
        return res

class MyClass:
    @MyClassDescriptor
    def foo(self):
        print("MyClass foo")
    # foo=MyClassDescriptor(foo)

m.foo
# <__main__.MyClass object at 0x000001BE9597A828> <class ‘__main__.MyClass‘>  # 传递进__get__方法的两个参数,第一个是MyClass对象m,第二个是MyClass类的内存地址,在__get__方法中返回的是foo函数的执行结果,也就打印出来了‘MyClass foo‘
# MyClass foo
print(MyClass.foo)
# None <class ‘__main__.MyClass‘>  # 当是类调用foo时,传递进__get__方法中的第一个参数为None,第二个参数是MyClass类的内存地址
# <__main__.MyClassDescriptor object at 0x000001BE9597A7F0>













以上是关于杂项之python描述符协议的主要内容,如果未能解决你的问题,请参考以下文章

杂项之使用qq邮箱发送邮件

杂项之python利用pycrypto实现RSA

sh 杂项bash片段

杂项之年终总结

php的特殊协议

Python之路:描述符,类装饰器,元类