python 描述符参考文档_Python-描述符
Python中包含了许多内建的语言特性,它们使得代码简洁且易于理解。这些特性包括列表/集合/字典推导式,属性(property)、以及装饰器(decorator)。对于大部分特性来说,这些“中级”的语言特性有着完善的文档,并且易于学习。
但是这里有个例外,那就是描述符。至少对于我来说,描述符是Python语言核心中困扰我时间最长的一个特性。这里有几点原因如下:
有关描述符的官方文档相当难懂,而且没有包含优秀的示例告诉你为什么需要编写描述符(我得为Raymond Hettinger辩护一下,他写的其他主题的Python文章和视频对我的帮助还是非常大的)
编写描述符的语法显得有些怪异
自定义描述符可能是Python中用的最少的特性,因此你很难在开源项目中找到优秀的示例
但是一旦你理解了之后,描述符的确还是有它的应用价值的。这篇文章告诉你描述符可以用来做什么,以及为什么应该引起你的注意。
一句话概括:描述符就是可重用的属性
在这里我要告诉你:从根本上讲,描述符就是可以重复使用的属性。也就是说,描述符可以让你编写这样的代码:
f =Foo()
b=f.bar
f.bar=cdel f.bar
而在解释器执行上述代码时,当发现你试图访问属性(b = f.bar)、对属性赋值(f.bar = c)或者删除一个实例变量的属性(del f.bar)时,就会去调用自定义的方法。
让我们先来解释一下为什么把对函数的调用伪装成对属性的访问是大有好处的。
property——把函数调用伪装成对属性的访问
想象一下你正在编写管理电影信息的代码。你最后写好的Movie类可能看上去是这样的:
classMovie(object):def __init__(self, title, rating, runtime, budget, gross):
self.title=title
self.rating=rating
self.runtime=runtime
self.budget=budget
self.gross=grossdefprofit(self):return self.gross - self.budget
你开始在项目的其他地方使用这个类,但是之后你意识到:如果不小心给电影打了负分怎么办?你觉得这是错误的行为,希望Movie类可以阻止这个错误。 你首先想到的办法是将Movie类修改为这样:
classMovie(object):def __init__(self, title, rating, runtime, budget, gross):
self.title=title
self.rating=rating
self.runtime=runtime
self.gross=grossif budget <0:raise ValueError("Negative value not allowed: %s" %budget)
self.budget=budgetdefprofit(self):return self.gross - self.budget
但这行不通。因为其他部分的代码都是直接通过Movie.budget来赋值的——这个新修改的类只会在__init__方法中捕获错误的数据,但对于已 经存在的类实例就无能为力了。如果有人试着运行m.budget = -100,那么谁也没法阻止。作为一个Python程序员同时也是电影迷,你该怎么办?
幸运的是,Python的property解决了这个问题。如果你从未见过property的用法,下面是一个示例:
classMovie(object):def __init__(self, title, rating, runtime, budget, gross):
self._budget=None
self.title=title
self.rating=rating
self.runtime=runtime
self.gross=gross
self.budget=budget
@propertydefbudget(self):returnself._budget
@budget.setterdefbudget(self, value):if value <0:raise ValueError("Negative value not allowed: %s" %value)
self._budget=valuedefprofit(self):return self.gross -self.budget
m= Movie('Casablanca', 97, 102, 964000, 1300000)print m.budget #calls m.budget(), returns result
try:
m.budget= -100 #calls budget.setter(-100), and raises ValueError
exceptValueError:print "Woops. Not allowed"
964000Woops. Not allowed
我们用@property装饰器指定了一个getter方法,用@budget.setter装饰器指定了一个setter方法。当我们这么做时,每当有 人试着访问budget属性,Python就会自动调用相应的getter/setter方法。比方说,当遇到m.budget = value这样的代码时就会自动调用budget.setter。
花点时间来欣赏一下Python这么做是多么的优雅:如果没有property,我们将不得不把所有的实例属性隐藏起来,提供大量显式的类似 get_budget和set_budget方法。像这样编写类的话,使用起来就会不断的去调用这些getter/setter方法,这看起来就像臃肿的 Java代码一样。更糟的是,如果我们不采用这种编码风格,直接对实例属性进行访问。那么稍后就没法以清晰的方式增加对非负数的条件检查——我们不得不重 新创建set_budget方法,然后搜索整个工程中的源代码,将m.budget = value这样的代码替换为m.set_budget(value)。太蛋疼了!!
因此,property让我们将自定义的代码同变量的访问/设定联系在了一起,同时为你的类保持一个简单的访问属性的接口。干得漂亮!
property的不足
对property来说,最大的缺点就是它们不能重复使用。举个例子,假设你想为rating,runtime和gross这些字段也添加非负检查。下面是修改过的新类:
classMovie(object):def __init__(self, title, rating, runtime, budget, gross):
self._rating=None
self._runtime=None
self._budget=None
self._gross=None
self.title=title
self.rating=rating
self.runtime=runtime
self.gross=gross
self.budget=budget#nice
@propertydefbudget(self):returnself._budget
@budget.setterdefbudget(self, value):if value <0:raise ValueError("Negative value not allowed: %s" %value)
self._budget=value#ok
@propertydefrating(self):returnself._rating
@rating.setterdefrating(self, value):if value <0:raise ValueError("Negative value not allowed: %s" %value)
self._rating=value#uhh...
@propertydefruntime(self):returnself._runtime
@runtime.setterdefruntime(self, value):if value <0:raise ValueError("Negative value not allowed: %s" %value)
self._runtime=value#is this forever?
@propertydefgross(self):returnself._gross
@gross.setterdefgross(self, value):if value <0:raise ValueError("Negative value not allowed: %s" %value)
self._gross=valuedefprofit(self):return self.gross - self.budget
可以看到代码增加了不少,但重复的逻辑也出现了不少。虽然property可以让类从外部看起来接口整洁漂亮,但是却做不到内部同样整洁漂亮。
描述符登场(最终的大杀器)
这就是描述符所解决的问题。描述符是property的升级版,允许你为重复的property逻辑编写单独的类来处理。下面的示例展示了描述符是如何工作的(现在还不必担心NonNegative类的实现):
from weakref importWeakKeyDictionaryclassNonNegative(object):"""A descriptor that forbids negative values"""
def __init__(self, default):
self.default=default
self.data=WeakKeyDictionary()def __get__(self, instance, owner):#we get here when someone calls x.d, and d is a NonNegative instance
#instance = x
#owner = type(x)
returnself.data.get(instance, self.default)def __set__(self, instance, value):#we get here when someone calls x.d = val, and d is a NonNegative instance
#instance = x
#value = val
if value <0:raise ValueError("Negative value not allowed: %s" %value)
self.data[instance]=valueclassMovie(object):#always put descriptors at the class-level
rating =NonNegative(0)
runtime=NonNegative(0)
budget=NonNegative(0)
gross=NonNegative(0)def __init__(self, title, rating, runtime, budget, gross):
self.title=title
self.rating=rating
self.runtime=runtime
self.budget=budget
self.gross=grossdefprofit(self):return self.gross -self.budget
m= Movie('Casablanca', 97, 102, 964000, 1300000)print m.budget #calls Movie.budget.__get__(m, Movie)
m.rating = 100 #calls Movie.budget.__set__(m, 100)
try:
m.rating= -1 #calls Movie.budget.__set__(m, -100)
exceptValueError:print "Woops, negative value"
964000Woops, negative value
这里引入了一些新的语法,我们一条条的来看:
NonNegative是一个描述符对象,因为它定义了__get__,__set__或__delete__方法。
Movie类现在看起来非常清晰。我们在类的层面上创建了4个描述符,把它们当做普通的实例属性。显然,描述符在这里为我们做非负检查。
访问描述符
当解释器遇到print m.buget时,它就会把budget当作一个带有__get__ 方法的描述符,调用Movie.budget.__get__方法并将方法的返回值打印出来,而不是直接传递m.budget来打印。这和你访问一个 property相似,Python自动调用一个方法,同时返回结果。
__get__接收2个参数:一个是点号左边的实例对象(在这里,就是m.budget中的m),另一个是这个实例的类型(Movie)。在一些Python文档中,Movie 被称作描述符的所有者(owner)。如果我们需要访问Movie.budget,Python将会调用 Movie.budget.__get__(None, Movie)。可以看到,第一个参数要么是所有者的实例,要么是None。这些输入参数可能看起来很怪,但是这里它们告诉了你描述符属于哪个对象的一部 分。当我们看到NonNegative类的实现时这一切就合情合理了。
对描述符赋值
当解释器看到m.rating = 100时,Python识别出rating是一个带有__set__方法的描述符,于是就调用Movie.rating.__set__(m, 100)。和__get__一样,__set__的第一个参数是点号左边的类实例(m.rating = 100中的m)。第二个参数是所赋的值(100)。
删除描述符
为了说明的完整,这里提一下删除。如果你调用del m.budget,Python就会调用Movie.budget.__delete__(m)。
NonNegative类是如何工作的?
带着前面的困惑,我们终于要揭示NonNegative类是如何工作的了。每个NonNegative的实例都维护着一个字典,其中保存着所有者实 例和对应数据的映射关系。当我们调用m.budget时,__get__方法会查找与m相关联的数据,并返回这个结果(如果这个值不存在,则会返回一个默 认值)。__set__采用的方式相同,但是这里会包含额外的非负检查。我们使用WeakKeyDictionary来取代普通的字典以防止内存泄露—— 我们可不想仅仅因为它在描述符的字典中就让一个无用 的实例一直存活着。
使用描述符会有一点别扭。因为它们作用于类的层次上,每一个类实例都共享同一个描述符。这就意味着对不同的实例对象而言,描述符不得不手动地管理 不同的状态,同时需要显式的将类实例作为第一个参数准确传递给__get__、__set__以及__delete__方法。
我希望这个例子解释清楚了描述符可以用来做什么——它们提供了一种方法将property的逻辑隔离到单独的类中来处理。如果你发现自己正在不同的property之间重复着相同的逻辑,那么本文也许会成为一个线索供你思考为何用描述符重构代码是值得一试的。
秘诀和陷阱
把描述符放在类的层次上(class level)
为了让描述符能够正常工作,它们必须定义在类的层次上。如果你不这么做,那么Python无法自动为你调用__get__和__set__方法。
classBroken(object):
y= NonNegative(5)def __init__(self):
self.x= NonNegative(0) #NOT a good descriptor
b=Broken()print "X is %s, Y is %s" %(b.x, b.y)
Xis <__main__.nonnegative object at>, Y is 5
可以看到,访问类层次上的描述符y可以自动调用__get__。但是访问实例层次上的描述符x只会返回描述符本身,真是魔法一般的存在啊。
确保实例的数据只属于实例本身
你可能会像这样编写NonNegative描述符:
classBrokenNonNegative(object):def __init__(self, default):
self.value=defaultdef __get__(self, instance, owner):returnself.valuedef __set__(self, instance, value):if value <0:raise ValueError("Negative value not allowed: %s" %value)
self.value=valueclassFoo(object):
bar= BrokenNonNegative(5)
f=Foo()try:
f.bar= -1
exceptValueError:print "Caught the invalid assignment"Caught the invalid assignment
这么做看起来似乎能正常工作。但这里的问题就在于所有Foo的实例都共享相同的bar,这会产生一些令人痛苦的结果:
classFoo(object):
bar= BrokenNonNegative(5)
f=Foo()
g=Foo()print "f.bar is %s\ng.bar is %s" %(f.bar, g.bar)print "Setting f.bar to 10"f.bar= 10
print "f.bar is %s\ng.bar is %s" % (f.bar, g.bar) #ouch
f.bar is 5g.baris 5Setting f.bar to10f.baris 10g.baris 10
这就是为什么我们要在NonNegative中使用数据字典的原因。__get__和__set__的第一个参数告诉我们需要关心哪一个实例。NonNegative使用这个参数作为字典的key,为每一个Foo实例单独保存一份数据。
classFoo(object):
bar= NonNegative(5)
f=Foo()
g=Foo()print "f.bar is %s\ng.bar is %s" %(f.bar, g.bar)print "Setting f.bar to 10"f.bar= 10
print "f.bar is %s\ng.bar is %s" % (f.bar, g.bar) #better
f.bar is 5g.baris 5Setting f.bar to10f.baris 10g.baris 5
这就是描述符最令人感到别扭的地方(坦白的说,我不理解为什么Python不让你在实例的层次上定义描述符,并且总是需要将实际的处理分发给__get__和__set__。这么做行不通一定是有原因的)
注意不可哈希的描述符所有者
NonNegative类使用了一个字典来单独保存专属于实例的数据。这个一般来说是没问题的,除非你用到了不可哈希(unhashable)的对象:
class MoProblems(list): #you can't use lists as dictionary keys
x = NonNegative(5)
m=MoProblems()print m.x #womp womp
---------------------------------------------------------------------------TypeError Traceback (most recent call last) in ()3
4 m =MoProblems()----> 5 print m.x #womp womp
in __get__(self, instance, owner)9 #instance = x
10 #owner = type(x)
---> 11 returnself.data.get(instance, self.default)12
13 def __set__(self, instance, value):
TypeError: unhashable type:'MoProblems'
因为MoProblems的实例(list的子类)是不可哈希的,因此它们不能为MoProblems.x用做数据字典的key。有一些方法可以规避这个问题,但是都不完美。最好的方法可能就是给你的描述符加标签了。
classDescriptor(object):def __init__(self, label):
self.label=labeldef __get__(self, instance, owner):print '__get__', instance, ownerreturn instance.__dict__.get(self.label)def __set__(self, instance, value):print '__set__'instance.__dict__[self.label] =valueclassFoo(list):
x= Descriptor('x')
y= Descriptor('y')
f=Foo()
f.x= 5
printf.x__set__
__get__ []
5
这种方法依赖于Python的方法解析顺序(即,MRO)。我们给Foo中的每个描述符加上一个标签名,名称和我们赋值给描述符的变量名相同,比如x = Descriptor(‘x’)。之后,描述符将特定于实例的数据保存在f.__dict__['x']中。这个字典条目通常是当我们请求f.x时 Python给出的返回值。然而,由于Foo.x 是一个描述符,Python不能正常的使用f.__dict__[‘x’],但是描述符可以安全的在这里存储数据。只是要记住,不要在别的地方也给这个描 述符添加标签。
classFoo(object):
x= Descriptor('y')
f=Foo()
f.x= 5
printf.x
f.y= 4 #oh no!
printf.x__set__
__get__ <__main__.foo object at>
5
__get__ <__main__.foo object at>
4
我不喜欢这种方式,因为这样的代码很脆弱也有很多微妙之处。但这个方法的确很普遍,可以用在不可哈希的所有者类上。David Beazley在他的书中用到了这个方法。
在元类中使用带标签的描述符
由于描述符的标签名和赋给它的变量名相同,所以有人使用元类来自动处理这个簿记(bookkeeping)任务。
classDescriptor(object):def __init__(self):#notice we aren't setting the label here
self.label =Nonedef __get__(self, instance, owner):print '__get__. Label = %s' %self.labelreturn instance.__dict__.get(self.label, None)def __set__(self, instance, value):print '__set__'instance.__dict__[self.label] =valueclassDescriptorOwner(type):def __new__(cls, name, bases, attrs):#find all descriptors, auto-set their labels
for n, v inattrs.items():ifisinstance(v, Descriptor):
v.label=nreturn super(DescriptorOwner, cls).__new__(cls, name, bases, attrs)classFoo(object):__metaclass__ =DescriptorOwner
x=Descriptor()
f=Foo()
f.x= 10
printf.x__set__
__get__. Label =x10
我不会去解释有关元类的细节——参考文献中David Beazley已经在他的文章中解释的很清楚了。 需要指出的是元类自动的为描述符添加标签,并且和赋给描述符的变量名字相匹配。
尽管这样解决了描述符的标签和变量名不一致的问题,但是却引入了复杂的元类。虽然我很怀疑,但是你可以自行判断这么做是否值得。
访问描述符的方法
描述符仅仅是类,也许你想要为它们增加一些方法。举个例子,描述符是一个用来回调property的很好的手段。比如我们想要一个类的某个部分的状态发生变化时就立刻通知我们。下面的大部分代码是用来做这个的:
classCallbackProperty(object):"""A property that will alert observers when upon updates"""
def __init__(self, default=None):
self.data=WeakKeyDictionary()
self.default=default
self.callbacks=WeakKeyDictionary()def __get__(self, instance, owner):returnself.data.get(instance, self.default)def __set__(self, instance, value):for callback inself.callbacks.get(instance, []):#alert callback function of new value
callback(value)
self.data[instance]=valuedefadd_callback(self, instance, callback):"""Add a new function to call everytime the descriptor updates"""
#but how do we get here?!?!
if instance not inself.callbacks:
self.callbacks[instance]=[]
self.callbacks[instance].append(callback)classBankAccount(object):
balance=CallbackProperty(0)deflow_balance_warning(value):if value < 100:print "You are poor"ba=BankAccount()#will not work -- try it#ba.balance.add_callback(ba, low_balance_warning)
这是一个很有吸引力的模式——我们可以自定义回调函数用来响应一个类中的状态变化,而且完全无需修改这个类的代码。这样做可真是替人分忧解难呀。现在,我 们所要做的就是调用ba.balance.add_callback(ba, low_balance_warning),以使得每次balance变化时low_balance_warning都会被调用。
但是我们是如何做到的呢?当我们试图访问它们时,描述符总是会调用__get__。就好像add_callback方法是无法触及的一样!其实关键在于利用了一种特殊的情况,即,当从类的层次访问时,__get__方法的第一个参数是None。
classCallbackProperty(object):"""A property that will alert observers when upon updates"""
def __init__(self, default=None):
self.data=WeakKeyDictionary()
self.default=default
self.callbacks=WeakKeyDictionary()def __get__(self, instance, owner):if instance isNone:returnselfreturnself.data.get(instance, self.default)def __set__(self, instance, value):for callback inself.callbacks.get(instance, []):#alert callback function of new value
callback(value)
self.data[instance]=valuedefadd_callback(self, instance, callback):"""Add a new function to call everytime the descriptor within instance updates"""
if instance not inself.callbacks:
self.callbacks[instance]=[]
self.callbacks[instance].append(callback)classBankAccount(object):
balance=CallbackProperty(0)deflow_balance_warning(value):if value < 100:print "You are now poor"ba=BankAccount()
BankAccount.balance.add_callback(ba, low_balance_warning)
ba.balance= 5000
print "Balance is %s" %ba.balance
ba.balance= 99
print "Balance is %s" %ba.balance
Balanceis 5000You are now poor
Balanceis 99
python 描述符参考文档_Python-描述符相关推荐
- python 描述符参考文档_python 描述符详解
Python中包含了许多内建的语言特性,它们使得代码简洁且易于理解.这些特性包括列表/集合/字典推导式,属性(property).以及装饰器(decorator).对于大部分特性来说,这些" ...
- python 描述符参考文档_描述符 - Python 学习笔记 - UDN开源文档
描述符 很少有人会去刻意关注描述符 (Descriptor),尽管它时时刻刻以属性.方法的身份出现. 描述符协议: __get__(self, instance, owner) --> retu ...
- python html转word文档_Python实现将HTML转换成doc格式文件的方法示例
本文实例讲述了Python实现将HTML转换成doc格式文件的方法.分享给大家供大家参考,具体如下: 网页上的一些文章,因为有格式的原因,它们在网页上的源码都是带有html标签的,用css来进行描述. ...
- python 自动生成word文档_python实现的生成word文档功能示例
本文实例讲述了python实现的生成word文档功能.分享给大家供大家参考,具体如下: 每月1次的测试费用报销,需要做一个文档.干脆花点时间写个程序吧. # -*- coding: utf-8 -*- ...
- python数组写入txt文档_Python打开文件,将list、numpy数组内容写入txt文件中的方法...
{"moduleinfo":{"card_count":[{"count_phone":1,"count":1}],&q ...
- python能处理表格文档_python处理excel表格
1. Python 操作 Excel 的函数库我主要尝试了 3 种读写 Exce... python 导出 oracle excel 报表 (字段名和内容支持中 文字符) 1.需要预先安装两个 pyt ...
- python第三方库使用文档_python 的第三方库的使用
我们写python代码的时候往往需要用第三方的库文件,Python强大的原因就是有大量的功能各异的第三方库.因此学会如何使用第三方库很有必要. 除了python官方自带的模块外,大部分第三方库是需要先 ...
- python批量提取word指定内容_使用python批量读取word文档并整理关键信息到excel表格的实例...
目标 最近实验室里成立了一个计算机兴趣小组 倡议大家多把自己解决问题的经验记录并分享 就像在CSDN写博客一样 虽然刚刚起步 但考虑到后面此类经验记录的资料会越来越多 所以一开始就要做好模板设计(如下 ...
- Spring Boot 3.0.0-M1 Reference Documentation(Spring Boot中文参考文档) 9-16
9. 数据 Spring Boot与多个数据技术集成,包括SQL和NoSQL. 9.1. SQL数据库 Spring Framework提供扩展支持用于与SQL数据工作,从使用JdbcTemplate ...
- Python+pymupdf处理PDF文档案例6则
推荐图书: <Python程序设计(第3版)>,(ISBN:978-7-302-55083-9),清华大学出版社,2020年6月第1次印刷,7月第2次印刷 京东购买链接:https://i ...
最新文章
- Android5.0如何正确启用isLoggable(二) 理分析
- PHP根据IP获取当前所在地地址
- CollaDec 之前的三个SharePoint工具开源发布
- NYOJ-523 亡命逃窜(三维立体的BFS)
- 工业以太网交换机的作用和工作原理详解
- 工作110:表格重置
- 面试官问你MySQL的优化,看这篇文章就够了
- shell 脚本中 while 只执行一次
- [转载] Python 主成分分析PCA
- 程序员2009精华本 有哪些精彩值得期待
- scala实现数值类型加法
- jquery解析php json,Jquery解析json数据详解_jquery
- 用C#制作PDF文件全攻略
- Linux桌面文件被隐藏,在Deepin系统中隐藏桌面图标的好办法
- 2021年嵌入式校招求职经历
- vscode eslint beautify 格式化 html
- 提高生活、学习、工作效率的方法——时间管理Vs个人管理
- javamail发送邮件到qq邮箱图片不能显示问题
- Eclipse中Android SDK Manager无法打开
- ubuntu 开机启动 ibus 输入法