Python之描述符_郑州千锋IT培训

Python之描述符

来源：千锋教育

发布人：xqq

时间： 2023-11-12 02:27:40

Descriptors(描述符)是Python语言中一个深奥但很重要的一个黑魔法，它被广泛应用于Python语言的内核，熟练掌握描述符将会为Python程序员的工具箱添加一个额外的技巧。本文我将讲述描述符的定义以及一些常见的场景，并且在文末会补充一下__getattr，__getattribute__,__getitem__这三个同样涉及到属性访问的魔术方法。

描述符的定义

descr__get__(self,obj,objtype=None)-->value

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

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

只要一个objectattribute(对象属性)定义了上面三个方法中的任意一个，那么这个类就可以被称为描述符类。

描述符基础

下面这个例子中我们创建了一个RevealAcess类，并且实现了__get__方法，现在这个类可以被称为一个描述符类。

classRevealAccess(object):

def__get__(self,obj,objtype):

print('selfinRevealAccess:{}'.format(self))

print('self:{}\nobj:{}\nobjtype:{}'.format(self,obj,objtype))

classMyClass(object):

x=RevealAccess()

deftest(self):

print('selfinMyClass:{}'.format(self))

EX1实例属性

接下来我们来看一下__get__方法的各个参数的含义，在下面这个例子中，self即RevealAccess类的实例x，obj即MyClass类的实例m，objtype顾名思义就是MyClass类自身。从输出语句可以看出，m.x访问描述符x会调用__get__方法。

>>>m=MyClass()

>>>m.test()

selfinMyClass:<__main__.MyClassobjectat0x7f19d4e42160>

>>>m.x

selfinRevealAccess:<__main__.RevealAccessobjectat0x7f19d4e420f0>

self:<__main__.RevealAccessobjectat0x7f19d4e420f0>

obj:<__main__.MyClassobjectat0x7f19d4e42160>

objtype:

EX2类属性

如果通过类直接访问属性x，那么obj接直接为None，这还是比较好理解，因为不存在MyClass的实例。

>>>MyClass.x

selfinRevealAccess:<__main__.RevealAccessobjectat0x7f53651070f0>

self:<__main__.RevealAccessobjectat0x7f53651070f0>

obj:None

objtype:

描述符的原理

描述符触发

上面这个例子中，我们分别从实例属性和类属性的角度列举了描述符的用法，下面我们来仔细分析一下内部的原理：

如果是对实例属性进行访问，实际上调用了基类object的__getattribute__方法，在这个方法中将obj.d转译成了type(obj).__dict__['d'].__get__(obj,type(obj))。

如果是对类属性进行访问，相当于调用了元类type的__getattribute__方法，它将cls.d转译成cls.__dict__['d'].__get__(None,cls)，这里__get__()的obj为的None，因为不存在实例。

简单讲一下__getattribute__魔术方法，这个方法在我们访问一个对象的属性的时候会被无条件调用，详细的细节比如和__getattr,__getitem__的区别我会在文章的末尾做一个额外的补充，我们暂时并不深究。

描述符优先级

首先，描述符分为两种:

如果一个对象同时定义了__get__()和__set__()方法，则这个描述符被称为datadescriptor。

如果一个对象只定义了__get__()方法，则这个描述符被称为non-datadescriptor。

我们对属性进行访问的时候存在下面四种情况：

datadescriptor

instancedict

non-datadescriptor

__getattr__()

它们的优先级大小是：

datadescriptor>instancedict>non-datadescriptor>__getattr__()

这是什么意思呢?就是说如果实例对象obj中出现了同名的datadescriptor->d和instanceattribute->d，obj.d对属性d进行访问的时候，由于datadescriptor具有更高的优先级，Python便会调用type(obj).__dict__['d'].__get__(obj,type(obj))而不是调用obj.__dict__[‘d’]。但是如果描述符是个non-datadescriptor，Python则会调用obj.__dict__['d']。

Property

每次使用描述符的时候都定义一个描述符类，这样看起来非常繁琐。Python提供了一种简洁的方式用来向属性添加数据描述符。

property(fget=None,fset=None,fdel=None,doc=None)->propertyattribute

fget、fset和fdel分别是类的getter、setter和deleter方法。我们通过下面的一个示例来说明如何使用Property：

classAccount(object):

def__init__(self):

self._acct_num=None

defget_acct_num(self):

returnself._acct_num

defset_acct_num(self,value):

self._acct_num=value

defdel_acct_num(self):

delself._acct_num

acct_num=property(get_acct_num,set_acct_num,del_acct_num,'_acct_numproperty.')

如果acct是Account的一个实例，acct.acct_num将会调用getter，acct.acct_num=value将调用setter，delacct_num.acct_num将调用deleter。

>>>acct=Account()

>>>acct.acct_num=1000

>>>acct.acct_num

1000

Python也提供了@property装饰器，对于简单的应用场景可以使用它来创建属性。一个属性对象拥有getter,setter和deleter装饰器方法，可以使用它们通过对应的被装饰函数的accessor函数创建属性的拷贝。

classAccount(object):

def__init__(self):

self._acct_num=None

@property

#the_acct_numproperty.thedecoratorcreatesaread-onlyproperty

defacct_num(self):

returnself._acct_num

@acct_num.setter

#the_acct_numpropertysettermakesthepropertywriteable

defset_acct_num(self,value):

self._acct_num=value

@acct_num.deleter

defdel_acct_num(self):

delself._acct_num

如果想让属性只读，只需要去掉setter方法。

在运行时创建描述符

我们可以在运行时添加property属性：

classPerson(object):

defaddProperty(self,attribute):

#createlocalsetterandgetterwithaparticularattributename

getter=lambdaself:self._getProperty(attribute)

setter=lambdaself,value:self._setProperty(attribute,value)

#constructpropertyattributeandaddittotheclass

setattr(self.__class__,attribute,property(fget=getter,\

fset=setter,\

doc="Auto-generatedmethod"))

def_setProperty(self,attribute,value):

print("Setting:{}={}".format(attribute,value))

setattr(self,'_'+attribute,value.title())

def_getProperty(self,attribute):

print("Getting:{}".format(attribute))

returngetattr(self,'_'+attribute)

>>>user=Person()

>>>user.addProperty('name')

>>>user.addProperty('phone')

>>>user.name='johnsmith'

Setting:name=johnsmith

>>>user.phone='12345'

Setting:phone=12345

>>>user.name

Getting:name

'JohnSmith'

>>>user.__dict__

{'_phone':'12345','_name':'JohnSmith'}

静态方法和类方法

我们可以使用描述符来模拟Python中的@staticmethod和@classmethod的实现。我们首先来浏览一下下面这张表：

静态方法

对于静态方法f。c.f和C.f是等价的，都是直接查询object.__getattribute__(c,‘f’)或者object.__getattribute__(C,’f‘)。静态方法一个明显的特征就是没有self变量。

静态方法有什么用呢?假设有一个处理专门数据的容器类，它提供了一些方法来求平均数，中位数等统计数据方式，这些方法都是要依赖于相应的数据的。但是类中可能还有一些方法，并不依赖这些数据，这个时候我们可以将这些方法声明为静态方法，同时这也可以提高代码的可读性。

使用非数据描述符来模拟一下静态方法的实现：

classStaticMethod(object):

def__init__(self,f):

self.f=f

def__get__(self,obj,objtype=None):

returnself.f

我们来应用一下：

classMyClass(object):

@StaticMethod

defget_x(x):

returnx

print(MyClass.get_x(100))#output:100

类方法

Python的@classmethod和@staticmethod的用法有些类似，但是还是有些不同，当某些方法只需要得到类的引用而不关心类中的相应的数据的时候就需要使用classmethod了。

使用非数据描述符来模拟一下类方法的实现：

classClassMethod(object):

def__init__(self,f):

self.f=f

def__get__(self,obj,klass=None):

ifklassisNone:

klass=type(obj)

defnewfunc(*args):

returnself.f(klass,*args)

returnnewfunc

其他的魔术方法

首次接触Python魔术方法的时候，我也被__get__,__getattribute__,__getattr__,__getitem__之间的区别困扰到了，它们都是和属性访问相关的魔术方法，其中重写__getattr__，__getitem__来构造一个自己的集合类非常的常用，下面我们就通过一些例子来看一下它们的应用。

__getattr__

Python默认访问类/实例的某个属性都是通过__getattribute__来调用的，__getattribute__会被无条件调用，没有找到的话就会调用__getattr__。如果我们要定制某个类，通常情况下我们不应该重写__getattribute__，而是应该重写__getattr__，很少看见重写__getattribute__的情况。

从下面的输出可以看出，当一个属性通过__getattribute__无法找到的时候会调用__getattr__。

In[1]:classTest(object):

...:def__getattribute__(self,item):

...:print('call__getattribute__')

...:returnsuper(Test,self).__getattribute__(item)

...:def__getattr__(self,item):

...:return'call__getattr__'

...:

In[2]:Test().a

call__getattribute__

Out[2]:'call__getattr__'

应用

对于默认的字典，Python只支持以obj['foo']形式来访问，不支持obj.foo的形式，我们可以通过重写__getattr__让字典也支持obj['foo']的访问形式，这是一个非常经典常用的用法：

classStorage(dict):

"""AStorageobjectislikeadictionaryexceptobj.foocanbeusedinadditiontoobj['foo']."""

def__getattr__(self,key):

try:

returnself[key]

exceptKeyErrorask:

raiseAttributeError(k)

def__setattr__(self,key,value):

self[key]=value

def__delattr__(self,key):

try:

delself[key]

exceptKeyErrorask:

raiseAttributeError(k)

def__repr__(self):

return''!

我们来使用一下我们自定义的加强版字典：

>>>s=Storage(a=1)

>>>s['a']

>>>s.a

>>>s.a=2

>>>s['a']

>>>dels.a

>>>s.a

...

AttributeError:'a'

__getitem__

getitem用于通过下标[]的形式来获取对象中的元素，下面我们通过重写__getitem__来实现一个自己的list。

classMyList(object):

def__init__(self,*args):

self.numbers=args

def__getitem__(self,item):

returnself.numbers[item]

my_list=MyList(1,2,3,4,6,5,3)

printmy_list[2]

这个实现非常的简陋，不支持slice和step等功能，请读者自行改进，这里我就不重复了。

应用

下面是参考requests库中对于__getitem__的一个使用，我们定制了一个忽略属性大小写的字典类。

程序有些复杂，我稍微解释一下：由于这里比较简单，没有使用描述符的需求，所以使用了@property装饰器来代替，lower_keys的功能是将实例字典中的键全部转换成小写并且存储在字典self._lower_keys中。重写了__getitem__方法，以后我们访问某个属性首先会将键转换为小写的方式，然后并不会直接访问实例字典，而是会访问字典self._lower_keys去查找。赋值/删除操作的时候由于实例字典会进行变更，为了保持self._lower_keys和实例字典同步，首先清除self._lower_keys的内容，以后我们重新查找键的时候再调用__getitem__的时候会重新新建一个self._lower_keys。

classCaseInsensitiveDict(dict):

@property

deflower_keys(self):

ifnothasattr(self,'_lower_keys')ornotself._lower_keys:

self._lower_keys=dict((k.lower(),k)forkinself.keys())

returnself._lower_keys

def_clear_lower_keys(self):

ifhasattr(self,'_lower_keys'):

self._lower_keys.clear()

def__contains__(self,key):

returnkey.lower()inself.lower_keys

def__getitem__(self,key):