python类：描述器Descriptors和元类MetaClasses

桃扇骨 2022-08-19 02:17 184阅读 0赞

http://[blog.csdn.net/pipisorry/article/details/50444769][blog.csdn.net_pipisorry_article_details_50444769]

# 描述器(Descriptors) #

描述器决定了对象属性是如何被访问的。描述器的作用是定制当你想引用一个属性时所发生的操作。

构建描述器的方法是至少定义以下三个方法中的一个。需要注意，下文中的instance是包含被访问属性的对象实例，而owner则是被描述器修辞的类。

*  \_\_get\_\_(self, instance, owner) – 这个方法是当属性被通过(value = obj.attr)的方式获取时调用，这个方法的返回值将被赋给请求此属性值的代码部分。
 *  \_\_set\_\_(self, instance, value) – 这个方法是当希望设置属性的值(obj.attr = ‘value’)时被调用，该方法不会返回任何值。
 *  \_\_delete\_\_(self, instance) – 当从一个对象中删除一个属性时(del obj.attr)，调用此方法。

译者注：对于instance和owner的理解，考虑以下代码：

**class** Celsius( object ):

**def** \_\_init\_\_( self , value **=** 0.0 ):

self .value **=** float (value)

**def** \_\_get\_\_( self , instance, owner):

**return** self .value

**def** \_\_set\_\_( self , instance, value):

self .value **=** float (value)

**class** Temperature( object ):

celsius **=** Celsius()

temp **=** Temperature()

temp.celsius \#calls Celsius.\_\_get\_\_

上例中，instance指的是temp，而owner则是Temperature。

LazyLoading Properties例子：

**import** weakref

**class** lazyattribute( object ):

**def** \_\_init\_\_( self , f):

self .data **=** weakref.WeakKeyDictionary()

self .f **=** f

**def** \_\_get\_\_( self , obj,  cls ):

**if** obj **not** **in** self .data:

self .data\[obj\] **=** self .f(obj)

**return** self .data\[obj\]

**class** Foo( object ):

@lazyattribute

**def** bar( self ):

print "Being lazy"

**return** 42

f **=** Foo()

**print** f.bar

\# Being lazy

\# 42

print f.bar

\# 42

描述器很好的总结了Python中的绑定方法(bound method)这个概念，绑定方法是经典类(classic classes)的实现核心。在经典类中，当在一个对象实例的字典中没有找到某个属性时，会继续到类的字典中查找，然后再到基类的字典中，就这么一直递归的查找下去。如果在类字典中找到这个属性，解释器会检查找到的对象是不是一个Python函数对象。如果是，则返回的并不是这个对象本身，而是返回一个柯里化(currying function)的包装器对象。当调用这个包装器时，它会首先在参数列表之前插入实例，然后再调用原函数。

译者注：  
1. 柯里化 – [http://zh.wikipedia.org/wiki/%E6%9F%AF%E9%87%8C%E5%8C%96][http_zh.wikipedia.org_wiki_E6_9F_AF_E9_87_8C_E5_8C_96]  
2. function，method，bound method及unbound method的区别。首先，函数(function)是由def或lambda创建的。当一个函数在class语句块中定义或是由type来创建时，它会转成一个非绑定方法(unbound method)，而当通过类实例(instance)来访问此方法的时候，它将转成绑定方法(bound method)，绑定方法会自动将实例作为第一个参数传入方法。综上所述，方法是出现在类中的函数，绑定方法是一个绑定了具体实例的方法，反之则是非绑定方法。

综上，描述器被赋值给类，而这些特殊的方法就在属性被访问的时候根据具体的访问类型自动地调用。

\[[Descriptor Protocol][]\]

[皮皮blog][blog]

# 元类(MetaClasses) #

元类提供了一个改变Python类行为的有效方式。

元类的定义是“一个类的类”。任何实例是它自己的类都是元类。

**class** demo( object ):

**pass**

obj **=** demo()

print "Class of obj is \{0\}" . format (obj.\_\_class\_\_)

**print** "Class of obj is \{0\}" . format (demo.\_\_class\_\_)

\# Class of obj is <class '\_\_main\_\_.demo'>

\# Class of obj is <type 'type'>

在上例中，我们定义了一个类demo，并且生成了一个该类的对象obj。首先，可以看到obj的\_\_class\_\_是demo。有意思的来了，那么demo的class又是什么呢？可以看到demo的\_\_class\_\_是type。

所以说type是python类的类，换句话说，上例中的obj是一个demo的对象，而demo本身又是type的一个对象。

所以说type就是一个元类，而且是python中最常见的元类，因为它使python中所有类的默认元类。

因为元类是类的类，所以它被用来创建类(正如类是被用来创建对象的一样)。但是，难道我们不是通过一个标准的类定义来创建类的么？的确是这样，但是python内部的运作机制如下：

*   *  当看见一个类定义，python会收集所有属性到一个字典中。
     *  当类定义结束，python将决定类的元类，我们就称它为Meta吧。
     *  最后，python执行Meta(name, bases, dct)，其中：

a. Meta是元类，所以这个调用是实例化它。  
b. name是新建类的类名。  
c. bases是新建类的基类元组  
d. dct将属性名映射到对象，列出所有的类属性。

那么如何确定一个类(A)的元类呢？简单来说，如果一个类(A)自身或其基类(Base\_A)之一有\_\_metaclass\_\_属性存在，则这个类(A/Base\_A)就是类(A)的元类。否则type就将是类(A)的元类。\[[Python高级编程技巧][Python]\]

[皮皮blog][blog]

### \_\_slots\_\_ ###

默认情况下，Python 用一个字典来保存一个对象的实例属性。这使得我们可以在运行的时候动态的给类的实例添加新的属性：  
test = Test()  
test.new\_key = 'new\_value'  
然而这个字典浪费了多余的空间 — 很多时候我们不会创建那么多的属性。因此通过\_\_slots\_\_可以告诉 Python 不要使用字典而是固定集合来分配空间。  
class Test(object):  
    \# 用列表罗列所有的属性  
    \_\_slots\_\_ = \['name', 'value'\]  
    def \_\_init\_\_(self, name='test', value='0'):  
        self.name = name  
        self.value = value  
  
test = Test()  
\# 此时再增加新的属性则会报错  
test.new\_key = 'new\_value'  
\# AttributeError: 'Test' object has no attribute 'new\_key'

## \_\_call\_\_ ##

通过定义类中的\_\_call\_\_方法，可以使该类的实例能够像普通函数一样调用。  
class AddNumber(object):  
    def \_\_init\_\_(self):  
        self.num = 0  
  
    def \_\_call\_\_(self, num=1):  
        self.num += num  
  
add\_number = AddNumber()  
print(add\_number.num) \# 0  
add\_number() \# 像方法一样的调用  
print(add\_number.num) \# 1  
add\_number(3)  
print(add\_number.num) \# 4  
通过这种方式实现的好处是，可以通过类的属性来保存状态，而不必创建一个闭包或者全局变量。

from:[http://blog.csdn.net/pipisorry/article/details/50444769][blog.csdn.net_pipisorry_article_details_50444769]

ref:[ Python “黑魔法” 之 Meta Classes][Python _ _ Meta Classes]

\[Special method names[¶][Link 1]\]

[blog.csdn.net_pipisorry_article_details_50444769]: http://blog.csdn.net/pipisorry/article/details/50444769
[http_zh.wikipedia.org_wiki_E6_9F_AF_E9_87_8C_E5_8C_96]: http://zh.wikipedia.org/wiki/%E6%9F%AF%E9%87%8C%E5%8C%96
[Descriptor Protocol]: https://docs.python.org/3/howto/descriptor.html#id4
[blog]: http://blog.csdn.net/pipisorry
[Python]: http://blog.jobbole.com/61171/
[Python _ _ Meta Classes]: https://segmentfault.com/a/1190000004426130
[Link 1]: https://docs.python.org/3/reference/datamodel.html?highlight=slot#special-method-names