Python 类与元类的深度挖掘 I【经验】
上一篇介绍了Python枚举类型的标准库，除了考虑到其实用性，还有一个重要的原因是其实现过程是一个非常好的学习、理解Python类与元类的例子。因此接下来两篇就以此为例，深入挖掘Python中类与元类背后的机制。
翻开任何一本Python教程，你一定可以在某个位置看到下面这两句话：
Python中一切皆为对象(EverythinginPythonisanobject);
Python是一种面向对象编程(ObjectOrientedProgramming,OOP)的语言。
虽然在上面两句话的语境中，对象(Object)的含义可能稍有不同，但可以肯定的是对象在Python中具有非常重要的意义，也是我们接下来将要讨论的所有内容的基础。那么，对象到底是什么?
对象(Object)
对象是Python中对数据的一种抽象，Python程序中所有数据都是通过对象或对象之间的关系来表示的。[ref:DataModel]
港台将Object翻译为“物件”，可以将其看作是一个盛有数据的盒子，只不过除了纯粹的数据之外还有其它有用的属性信息，在Python中，所有的对象都具有id、type、value三个属性：
+---------------+ || |PythonObject| || +------+--------+ |ID|| +---------------+ |Type|| +---------------+ |Value|| +---------------+
其中id代表内存地址，可以通过内置函数id()查看，而type表示对象的类别，不同的类别意味着该对象拥有的属性和方法等，可以通过type()方法查看：
defwho(obj): print(id(obj),type(obj)) who(1) who(None) who(who) 4515088368 4514812344 4542646064
对象作为Python中的基本单位，可以被创建、命名或删除。Python中一般不需要手动删除对象，其垃圾回收机制会自动处理不再使用的对象，当然如果需要，也可以使用del语句删除某个变量;所谓命名则是指给对象贴上一个名字标签，方便使用，也就是声明或赋值变量;接下来我们重点来看如何创建一个对象。对于一些Python内置类型的对象，通常可以使用特定的语法生成，例如数字直接使用阿拉伯数字字面量，字符串使用引号''，列表使用[]，字典使用{}，函数使用def语法等，这些对象的类型都是Python内置的，那我们能不能创建其它类型的对象呢?
类与实例
既然说Python是面向对象编程语言，也就允许用户自己创建对象，通常使用class语句，与其它对象不同的是，class定义的对象(称之为类)可以用于产生新的对象(称之为实例)：
classA: pass a=A() who(A) who(a) 140477703944616 4542635424
上面的例子中A是我们创建的一个新的类，而通过调用A()可以获得一个A类型的实例对象，我们将其赋值为a，也就是说我们成功创建了一个与所有内置对象类型不同的对象a，它的类型为__main__.A!至此我们可以将Python中一切的对象分为两种：
可以用来生成新对象的类，包括内置的int、str以及自己定义的A等;
由类生成的实例对象，包括内置类型的数字、字符串以及自己定义的类型为__main__.A的a。
单纯从概念上理解这两种对象没有任何问题，但是这里要讨论的是在实践中不得不考虑的一些细节性问题：
需要一些方便的机制来实现面向对象编程中的继承、重载等特性;
需要一些固定的流程让我们可以在生成实例化对象的过程中执行一些特定的操作;
这两个问题主要关于类的一些特殊的操作，也就是这一篇后面的主要内容。如果再回顾一下开头提到的两句话，你可能会想到，既然类本身也是对象，那它们又是怎样生成的?这就是后一篇将主要讨论的问题：用于生成类对象的类，即元类(Metaclass)。
super,mro()
0x00Python之禅中提到的最后一条，命名空间(namespace)是个绝妙的理念，类或对象在Python中就承担了一部分命名空间的作用。比如说某些特定的方法或属性只有特定类型的对象才有，不同类型对象的属性和方法尽管名字可能相同，但由于隶属不同的命名空间，其值可能完全不同。在实现类的继承与重载等特性时同样需要考虑命名空间的问题，以枚举类型的实现为例，我们需要保证枚举对象的属性名称不能有重复，因此我们需要继承内置的dict类：
class_EnumDict(dict):
def__init__(self):
dict.__init__(self)
self._member_names=[]
defkeys(self):
keys=dict.keys(self)
returnlist(filter(lambdak: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()->sameassuper(__class__,) super(type)->unboundsuperobject super(type,obj)->boundsuperobject;requiresisinstance(obj,type) super(type,type2)->boundsuperobject;requiresissubclass(type2,type) Typicalusetocallacooperativesuperclassmethod: classC(B): defmeth(self,arg): super().meth(arg) Thisworksforclassmethodstoo: classC(B): @classmethod defcmeth(cls,arg): super().cmeth(arg)
我最初只是把super()当做指向父类对象的指针，但实际上它可以提供更多功能：给定一个对象及其子类(这里对象要求至少是类对象，而子类可以是实例对象)，从该对象父类的命名空间开始搜索对应的方法。
以下面的代码为例：
classA(object):
defmethod(self):
who(self)
print("A.method")
classB(A):
defmethod(self):
who(self)
print("B.method")
classC(B):
defmethod(self):
who(self)
print("C.method")
classD(C):
def__init__(self):
super().method()
super(__class__,self).method()
super(C,self).method()#callingC'sparent'smethod
super(B,self).method()#callingB'sparent'smethod
super(B,C()).method()#callingB'sparent'smethodwithinstanceofC
d=D()
print("\nInstanceofD:")
who(d)
4542787992
C.method
4542787992
C.method
4542787992
B.method
4542787992
A.method
4542788048
A.method
InstanceofD:
4542787992
当然我们也可以在外部使用super()方法，只是不能再用缺省参数的形式，因为在外部的命名空间中不再存在__class__和self：
super(D,d).method()#callingD'sparent'smethodwithinstanced 4542787992 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的顺序，如果是比较复杂的继承关系呢?
classA(object):
pass
classB(A):
defmethod(self):
print("B'smethod")
classC(A):
defmethod(self):
print("C'smethod")
classD(B,C):
def__init__(self):
super().method()
classE(C,B):
def__init__(self):
super().method()
d=D()
e=E()
B'smethod
C'smethod
Python中提供了一个类方法mro()可以指定搜寻的顺序，mro是MethodResolutionOrder的缩写，它是类方法而不是实例方法，可以通过重载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'smethod C'smethod super(C,e).method() super(B,d).method() B'smethod C'smethod