Python 类与元类的深度挖掘 I

上一篇介绍了 Python 枚举类型的标准库，除了考虑到其实用性，还有一个重要的缘由是其实现过程是一个很是好的学习、理解 Python 类与元类的例子。所以接下来两篇就以此为例，深刻挖掘 Python 中类与元类背后的机制。

翻开任何一本 Python 教程，你必定能够在某个位置看到下面这两句话：

1. Python 中一切皆为对象（Everything in Python is an object）；
2. Python 是一种面向对象编程（Object Oriented Programming, OOP）的语言。

虽然在上面两句话的语境中，对象（Object）的含义可能稍有不一样，但能够确定的是对象在 Python 中具备很是重要的意义，也是咱们接下来将要讨论的全部内容的基础。那么，对象究竟是什么？

对象（Object）

对象是 Python 中对数据的一种抽象，Python 程序中全部数据都是经过对象或对象之间的关系来表示的。[ref: Data Model]

港台将 Object 翻译为“物件”，能够将其看做是一个盛有数据的盒子，只不过除了纯粹的数据以外还有其它有用的属性信息，在 Python 中，全部的对象都具备id、type、value三个属性：

+---------------+
|               |
| Python Object |
|               |
+------+--------+
| ID   |        |
+---------------+
| Type |        |
+---------------+
| Value|        |
+---------------+

其中 id 表明内存地址，能够经过内置函数 id() 查看，而 type 表示对象的类别，不一样的类别意味着该对象拥有的属性和方法等，能够经过 type() 方法查看：

def who(obj):
    print(id(obj), type(obj))
    
who(1)
who(None)
who(who)

4515088368 <class 'int'>
4514812344 <class 'NoneType'>
4542646064 <class 'function'>

对象做为 Python 中的基本单位，能够被建立、命名或删除。Python 中通常不须要手动删除对象，其垃圾回收机制会自动处理再也不使用的对象，固然若是须要，也可使用 del 语句删除某个变量；所谓命名则是指给对象贴上一个名字标签，方便使用，也就是声明或赋值变量；接下来咱们重点来看如何建立一个对象。对于一些 Python 内置类型的对象，一般可使用特定的语法生成，例如数字直接使用阿拉伯数字字面量，字符串使用引号 ''，列表使用 []，字典使用 {} ，函数使用 def 语法等，这些对象的类型都是 Python 内置的，那咱们能不能建立其它类型的对象呢？

类与实例

既然说 Python 是面向对象编程语言，也就容许用户本身建立对象，一般使用 class 语句，与其它对象不一样的是，class 定义的对象（称之为类）能够用于产生新的对象（称之为实例）：

class A:
    pass
a = A()
who(A)
who(a)

140477703944616 <class 'type'>
4542635424 <class '__main__.A'>

上面的例子中 A 是咱们建立的一个新的类，而经过调用 A() 能够得到一个 A 类型的实例对象，咱们将其赋值为 a，也就是说咱们成功建立了一个与全部内置对象类型不一样的对象 a，它的类型为 __main__.A！至此咱们能够将 Python 中一切的对象分为两种：

1. 能够用来生成新对象的类，包括内置的 int、str 以及本身定义的 A 等；
2. 由类生成的实例对象，包括内置类型的数字、字符串以及本身定义的类型为 __main__.A 的 a。

单纯从概念上理解这两种对象没有任何问题，可是这里要讨论的是在实践中不得不考虑的一些细节性问题：

1. 须要一些方便的机制来实现面向对象编程中的继承、重载等特性；
2. 须要一些固定的流程让咱们能够在生成实例化对象的过程当中执行一些特定的操做；

这两个问题主要关于类的一些特殊的操做，也就是这一篇后面的主要内容。若是再回顾一下开头提到的两句话，你可能会想到，既然类自己也是对象，那它们又是怎样生成的？这就是后一篇将主要讨论的问题：用于生成类对象的类，即元类（Metaclass）。

super, mro()

0x00 Python 之禅中提到的最后一条，命名空间（namespace）是个绝妙的理念，类或对象在 Python 中就承担了一部分命名空间的做用。好比说某些特定的方法或属性只有特定类型的对象才有，不一样类型对象的属性和方法尽管名字可能相同，但因为隶属不一样的命名空间，其值可能彻底不一样。在实现类的继承与重载等特性时一样须要考虑命名空间的问题，以枚举类型的实现为例，咱们须要保证枚举对象的属性名称不能有重复，所以咱们须要继承内置的 dict 类：

class _EnumDict(dict):
    def __init__(self):
        dict.__init__(self)
        self._member_names = []
    def keys(self):
        keys = dict.keys(self)
        return list(filter(lambda k: k.isupper(), keys))

ed = _EnumDict()
ed['RED'] = 1
ed['red'] = 2
print(ed, ed.keys())

{'RED': 1, 'red': 2} ['RED']

在上面的例子中 _EnumDict 重载同时调用了父类 dict 的一些方法，上面的写法在语法上是没有错误的，可是若是咱们要改变 _EnumDict 的父类，再也不是继承自 dict，则必须手动修改全部方法中 dict.method(self) 的调用形式，这样就不是一个好的实践方案了。为了解决这一问题，Python 提供了一个内置函数 super()：

print(super.__doc__)

super() -> same as super(__class__, <first argument>)
super(type) -> unbound super object
super(type, obj) -> bound super object; requires isinstance(obj, type)
super(type, type2) -> bound super object; requires issubclass(type2, type)
Typical use to call a cooperative superclass method:
class C(B):
    def meth(self, arg):
        super().meth(arg)
This works for class methods too:
class C(B):
    @classmethod
    def cmeth(cls, arg):
        super().cmeth(arg)

我最初只是把 super() 当作指向父类对象的指针，但实际上它能够提供更多功能：给定一个对象及其子类（这里对象要求至少是类对象，而子类能够是实例对象），从该对象父类的命名空间开始搜索对应的方法。

如下面的代码为例：

class A(object):
    def method(self):
        who(self)
        print("A.method")
class B(A):
    def method(self):
        who(self)
        print("B.method")
class C(B):
    def method(self):
        who(self)
        print("C.method")
class D(C):
    def __init__(self):
        super().method()
        super(__class__, self).method()
        
        super(C, self).method() # calling C's parent's method
        super(B, self).method() # calling B's parent's method
        
        super(B, C()).method()  # calling B's parent's method with instance of C

d = D()

print("\nInstance of D:")
who(d)

4542787992 <class '__main__.D'>
C.method
4542787992 <class '__main__.D'>
C.method
4542787992 <class '__main__.D'>
B.method
4542787992 <class '__main__.D'>
A.method
4542788048 <class '__main__.C'>
A.method

Instance of D:
4542787992 <class '__main__.D'>

固然咱们也能够在外部使用 super() 方法，只是不能再用缺省参数的形式，由于在外部的命名空间中再也不存在 __class__ 和 self：

super(D, d).method() # calling D's parent's method with instance d

4542787992 <class '__main__.D'>
C.method

上面的例子能够用下图来描述：

+----------+
| A        |
+----------+
| method() <---------------+ super(B,self)
+----------+               |
                           |
+----------+               +----------+
| B        |               | D        |
+----------+ super(C,self) +----------+
| method() <---------------+ method() |
+----------+               +----------+
                           |
+----------+               |
| C        |               |
+----------+               | super(D,self)
| method() <---------------+
+----------+

能够认为 super() 方法经过向父类方向回溯给咱们找到了变量搜寻的起点，可是这个回溯的顺序是如何肯定的呢？上面的例子中继承关系是 object->A->B->C->D 的顺序，若是是比较复杂的继承关系呢？

class A(object):
    pass
class B(A):
    def method(self):
        print("B's method")
class C(A):
    def method(self):
        print("C's method")
class D(B, C):
    def __init__(self):
        super().method()
class E(C, B):
    def __init__(self):
        super().method()
        
d = D()
e = E()

B's method
C's method

Python 中提供了一个类方法 mro() 能够指定搜寻的顺序，mro 是Method Resolution Order 的缩写，它是类方法而不是实例方法，能够经过重载 mro() 方法改变继承中的方法解析顺序，但这须要在元类中完成，在这里只看一下其结果：

D.mro()

[__main__.D, __main__.B, __main__.C, __main__.A, object]

E.mro()

[__main__.E, __main__.C, __main__.B, __main__.A, object]

super() 方法就是沿着 mro() 给出的顺序向上寻找起点的：

super(D, d).method()
super(E, e).method()

B's method
C's method

super(C, e).method()
super(B, d).method()

B's method
C's method

总结

super() 方法解决了类->实例实践过程当中关于命名空间的一些问题，而关于生成对象的流程，咱们知道初始化实例是经过类的 __init__() 方法完成的，在此以前可能涉及到一些其它的准备工做，包括上面提到的 mro() 方法以及关键的元类->类的过程，将在后面一篇中继续介绍。

---

关注公众号 PyHub 每日推送