Python屬性和描述符的使用

關於@property裝飾器

在Python中我們使用@property裝飾器來把對函數的呼叫偽裝成對屬性的存取。

那為什麼要這樣做呢？因為@property讓我們將自訂的程式碼同變數的存取/設定聯繫在了一起，同時為你的類別保持一個簡單的存取屬性的介面。

舉個栗子，假如我們有一個需要表示電影的類別：

class Movie(object):
 def __init__(self, title, description, score, ticket):
 self.title = title
 self.description = description
 self.score = scroe
 self.ticket = ticket

你開始在專案的其他地方使用這個類，但之後你意識到：如果你不小心給電影打了負分怎麼辦？你覺得這是錯誤的行為，希望Movie類別可以阻止這個錯誤。 你首先想到的辦法是將Movie類別修改為這樣：

class Movie(object):
 def __init__(self, title, description, score, ticket):
 self.title = title
 self.description = description
　　　　 self.ticket = ticket
 if score < 0:
  raise ValueError("Negative value not allowed:{}".format(score))
 self.score = scroe

但這行不通。因為其他部分的程式碼都是直接透過Movie.score來賦值的。這個新修改的類別只會在__init__方法中捕獲錯誤的數據，但對於已經存在的類別實例就無能為力了。如果有人試著跑m.scrore= -100，那麼誰也沒辦法阻止。那該怎麼辦？

Python的property解決了這個問題。

我們可以這樣做

class Movie(object):
 def __init__(self, title, description, score):
 self.title = title
 self.description = description
 self.score = score
　　　　 self.ticket = ticket
 
 @property
 def score(self):
 return self.__score
 
 
 @score.setter
 def score(self, score):
 if score < 0:
  raise ValueError("Negative value not allowed:{}".format(score))
 self.__score = score
 
 @score.deleter
 def score(self):
 raise AttributeError("Can not delete score")

這樣在任何地方修改score都會偵測它是否小於0。

property的不足

對property來說，最大的缺點就是它們不能重複使用。舉個例子，假設你想為ticket欄位也加上非負檢定。

下面是修改過的新類別：

class Movie(object):
 def __init__(self, title, description, score, ticket):
 self.title = title
 self.description = description
 self.score = score
 self.ticket = ticket
 
 @property
 def score(self):
 return self.__score
 
 
 @score.setter
 def score(self, score):
 if score < 0:
  raise ValueError("Negative value not allowed:{}".format(score))
 self.__score = score
 
 @score.deleter
 def score(self):
 raise AttributeError("Can not delete score")
 
 
 @property
 def ticket(self):
 return self.__ticket
 
 @ticket.setter
 def ticket(self, ticket):
 if ticket < 0:
  raise ValueError("Negative value not allowed:{}".format(ticket))
 self.__ticket = ticket
 
 
 @ticket.deleter
 def ticket(self):
 raise AttributeError("Can not delete ticket")

#可以看到程式碼增加了不少，但重複的邏輯也出現了不少。雖然property可以讓類別從外部看起來介面整潔漂亮，但卻做不到內部同樣整潔漂亮。

描述符登場

什麼是描述符？

一般來說，描述子是一個具有綁定行為的物件屬性，其屬性的存取被描述符協定方法覆寫。這些方法是__get__()  、 __set__()和__delete__() ，一個物件中只要包含了這三個方法中的至少一個就稱它為描述符。

描述子有什麼作用？

The default behavior for attribute access is to get, set, or delete the attribute from an object's dictionary. For instance, a.x has a lookup chain starting witha.__dict__['x'], then has a lookup chain starting witha.__dict__['x'], then type(a) .__dict__['x'], and continuing through the base classes of type(a) excluding metaclasses. If the looked-up value is an object defining one of the descriptor methods, then Python may override the default beiord instead. Where this occurs in the precedence chain depends on which descriptor methods were defined.—–摘自官方文檔

簡單的說描述符會改變一個屬性的基本的獲取、設置和刪除方式。

先看如何用描述子來解決上面 property邏輯重複的問題。

class Integer(object):
 def __init__(self, name):
 self.name = name
 
 def __get__(self, instance, owner):
 return instance.__dict__[self.name]
 
 def __set__(self, instance, value):
 if value < 0:
  raise ValueError("Negative value not allowed")
 instance.__dict__[self.name] = value
 
class Movie(object):
 score = Integer(&#39;score&#39;)
 ticket = Integer(&#39;ticket&#39;)

因為描述符優先級高並且會改變預設的get、set行為，這樣一來，當我們訪問或設定Movie().score的時候都會受到描述符Integer的限制。

不過我們總不能用下面這樣的方式來建立實例。

a = Movie()
a.score = 1
a.ticket = 2
a.title = ‘test'
a.descript = ‘…'

這樣太生硬了，所以我們還缺少一個建構子。

class Integer(object):
 def __init__(self, name):
 self.name = name
 
 def __get__(self, instance, owner):
 if instance is None:
  return self
 return instance.__dict__[self.name]
 
 def __set__(self, instance, value):
 if value < 0:
  raise ValueError(&#39;Negative value not allowed&#39;)
 instance.__dict__[self.name] = value
 
 
class Movie(object):
 score = Integer(&#39;score&#39;)
 ticket = Integer(&#39;ticket&#39;)
 
 def __init__(self, title, description, score, ticket):
 self.title = title
 self.description = description
 self.score = score
 self.ticket = ticket

這樣在取得、設定和刪除score和ticket的時候都會進入Integer的__get__ 、 __set__ ，從而減少了重複的邏輯。

現在雖然問題得到了解決，但是你可能會好奇這個描述符到底是如何運作的。具體來說，在__init__函數裡訪問的是自己的self.score和self.ticket，怎麼和類別屬性score和ticket關聯起來的？

描述子如何運作

看官方的說明

If an object defines both __get__() and __set__(), it is considered a data descriptor. Descriptors that only define __get__() are called non-data descriptors (they are typically used for methods but other uses are possible).

Data and non-data descriptors differ in how overrides are calculated with respect to ents in If an instance's dictionary has an entry with the same name as a data descriptor, the data descriptor takes precedence. If an instance's dictionary has an entry with the same name as a non-data descriptor the dicary cry. ##The important points to remember are:

descriptors are invoked by the __getattribute__() method

overriding __getattribute__() prevents automatic descriptor calls__##object.__getattribute(mtribute) 和 mtyped. different calls to __get__().

data descriptors always override instance dictionaries.
non-data descriptors may be overridden by instance dictionaries.

##類__(__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

以下是摘自國外一篇部落格上的內容。

Given a Class “C” and an Instance “c” where “c = C(…)”, calling “c.name” means looking up an Attribute “name” on the Instance “c” like this :

Get the Class from Instance
Call the Class's special method getattribute__. All objects have a default __getattribute
Inside getattribute

Get the Class's mro as ClassParents
For each ClassParent in ClassParents
If the Attribute is in the ClassParent's dict
If is a data descriptor
Return the result from calling the data descriptor's special method __get__()
Break the for each (do not continue searching the same Attribute any further)
If the Attribute is in Instance's dict
Return the value as it is (even if the value is a data descriptor)
For each ClassParent in ClassParents
If the Attribute is in the ClassParent's dict
If is a non-data descriptor
Return the result from calling the non-data descriptor's special method __get__()
If it is NOT a descriptor
Return the value
If Class has the special method getattr
Return the result from calling the Class's special method__getattr__.

我对上面的理解是，访问一个实例的属性的时候是先遍历它和它的父类，寻找它们的__dict__里是否有同名的data descriptor如果有，就用这个data descriptor代理该属性，如果没有再寻找该实例自身的__dict__ ，如果有就返回。任然没有再查找它和它父类里的non-data descriptor，最后查找是否有__getattr__

描述符的应用场景

python的property、classmethod修饰器本身也是一个描述符，甚至普通的函数也是描述符（non-data discriptor）

django model和SQLAlchemy里也有描述符的应用

class User(db.Model):
 id = db.Column(db.Integer, primary_key=True)
 username = db.Column(db.String(80), unique=True)
 email = db.Column(db.String(120), unique=True)
 
 def __init__(self, username, email):
 self.username = username
 self.email = email
 
 def __repr__(self):
 return &#39;<User %r>' % self.username

总结

只有当确实需要在访问属性的时候完成一些额外的处理任务时，才应该使用property。不然代码反而会变得更加啰嗦，而且这样会让程序变慢很多。以上就是本文的全部内容，由于个人能力有限，文中如有笔误、逻辑错误甚至概念性错误，还请提出并指正。

更多Python属性和描述符的使用相关文章请关注PHP中文网！