python3-元类
原文出处：http://www.cnblogs.com/linhaifeng/articles/8029564.html
exec的使用
#可以把exec命令的执行当成是一个函数的执行，会将执行期间产生的名字存放于局部名称空间中 g={ 'x':1, 'y':2 } l={} exec(''' global x,z x=100 z=200 m=300 ''',g,l) print(g) #{'x': 100, 'y': 2,'z':200,......} print(l) #{'m': 300}
引子（类也是对象）
class Foo: pass f1=Foo() #f1是通过Foo类实例化的对象
python中一切皆对象，类本身也是一个对象，当使用关键字class的时候，python解释器在加载class的时候就会创建一个对象(这里的对象指的是类而非类的实例)， 因而我们可以将类当做一个对象去使用。
对象的使用：
1、都可以被引用，x=obj
2、都可以当做函数的参数传入
3、都可以当做函数的返回值
4、都可以当做容器类的元素， l = [func, obj, 1]
上例可以看出f1是由Foo这个类产生的对象，而Foo本身也是对象，那它又是由哪个类产生的呢？
print(type(f1)) # 输出：<class '__main__.Foo'> 表示，obj 对象由Foo类创建 print(type(Foo)) # 输出：<type 'type'>
什么是元类？
元类是类的类， 是类的模板
元类是用来控制如何创建类的， 正如类是创建对象的模板一样，而元类的主要目的是为了控制类的创建行为
元类的实例化结果是我们用class定义的类，正如类的实例为对象（f1对象是Foo类的一个实例， Foo类是type类的一个实例）
type是python的一个内建元类， 用来直接控制生成类， python中任何class定义的类其实都是type类实例化的对象
创建类的两种方式
方式一：使用class关键字
class Chinese(object): country='China' def __init__(self,name,age): self.name=name self.age=age def talk(self): print('%s is talking' %self.name)
方式二：就是手动模拟class创建类的过程）：将创建类的步骤拆分开，手动去创建
#准备工作： #创建类主要分为三部分 1 类名 2 类的父类 3 类的__dict__ #类名 class_name='Chinese' #类的父类 class_bases=(object,) #类体 class_body=""" country='China' def __init__(self,name,age): self.name=name self.age=age def talk(self): print('%s is talking' %self.name) """
步骤一（先处理类体 --> 名称空间）：类定义的名字都会存放于类的名称空间中（一个局部的名称空间），我们可以实现定义一个空字典，然后用exec去执行类体的代码（exec产生名称空间的过程与真正的class过程相似，只是后者将__开头的属性变形），生成类的局部空间名称，即填充字典
class_dic={} exec(class_body,globals(),class_dic) print(class_dic) #{'country': 'China', 'talk': <function talk at 0x101a560c8>, '__init__': <function __init__ at 0x101a56668>}
步骤二：调用元类type（也可以自定义）来产生类Chinense
Foo=type(class_name,class_bases,class_dic) #实例化type得到对象Foo，即我们用class定义的类Foo print(Foo) print(type(Foo)) print(isinstance(Foo,type)) ''' <class '__main__.Chinese'> <class 'type'> True '''
我们看到，type接收三个参数：
- 第一个参数是字符串'Foo', 表示类名
- 第二个参数是元组（object,）,表示所有的父类
- 第三个参数是字典，这里是一个空字典，表示没有定义属性和方法
补充：若Foo类有继承，即class Foo(Bar):.... 则等同于type('Foo',(Bar,),{})
类的几个常用方法
1.__new__方法
__new__方法接受的参数和__init__一样，但__init__实在类对象（创建一个空对象）创建之后调用，而__new__方法正式创建这个空对象的方法。__init__方法里面的self实际都是__new__所创建的空对象，__new__返回值就是已经实例化完的对象（__init__）,属于类级别方法
2.__init__方法
__init__通常用于初始化一个实例，控制这个初始化的过程，比如添加一属性，做一些额外的操作，发生在类实例（__new__创建出来的空对象）被创建完之后。它是实例级别的方法。无返回值。
3.__call__方法
构造方法的执行是创建对象出发的，即：对象=类名（）；而对于__call__方法的执行是实例化的时候‘对象=类名（）’触发的。
自定义元类控制（实例化）类的行为
type是所有新式类的类,所有类都可以说是type创建的
object是所有新式类的父类
# 一个类没有定义自己的元类，默认他的元类就是type， 除了使用元类type， 用户也可以通过继承type来自定义元类
#步骤一：如果说People=type(类名,类的父类们,类的名称空间)，那么我们定义元类如下，来控制类的创建 class Mymeta(type): # 继承默认元类的一堆属性 def __init__(self, class_name, class_bases, class_dic): # 实例化类的时候，必须给 元类传入 class_name, class_bases, class_dic三个参数， 我们就可以根据传入的这三个参数来控制类的创建（实例化） if '__doc__' not in class_dic or not class_dic.get('__doc__').strip(): raise TypeError('必须为类指定文档注释') if not class_name.istitle(): raise TypeError('类名首字母必须大写') super(Mymeta, self).__init__(class_name, class_bases, class_dic) class People(object, metaclass=Mymeta): country = 'China' def __init__(self, name, age): self.name = name self.age = age def talk(self): print('%s is talking' % self.name) # People这个类在创建的时候注明了他的元类是Mymeta，也就是我们定义的元类， 所以必须满足我们的控制条件，类名首字母必须大写， 必须要有文档注释切不能为空， 否则报出错误信息。
自定义元类控制类的调用 ---> （实例化）类的实例化对象的行为
#如果我们想控制类实例化的行为，那么需要先储备知识__call__方法的使用
class People(object,metaclass=type): def __init__(self,name,age): self.name=name self.age=age def __call__(self, *args, **kwargs): print(self,args,kwargs) # 调用类People，并不会触发__call__ obj=People('egon',18) # 调用对象obj(1,2,3,a=1,b=2,c=3)，才会出发对象的绑定方法obj.__call__(1,2,3,a=1,b=2,c=3) obj(1,2,3,a=1,b=2,c=3) #打印：<__main__.People object at 0x10076dd30> (1, 2, 3) {'a': 1, 'b': 2, 'c': 3} #总结：如果说类People是元类type的实例，那么在元类type内肯定也有一个__call__，会在调用People('egon',18)时触发执行，然后返回一个初始化好了的对象obj
开始自定义class Mymeta(type): #继承默认元类的一堆属性
class Mymeta(type): #继承默认元类的一堆属性
def __init__(self,class_name,class_bases,class_dic):
if not class_name.istitle():
raise TypeError('类名首字母必须大写')
super(Mymeta,self).__init__(class_name,class_bases,class_dic)
def __call__(self, *args, **kwargs):
#self=People
print(self,args,kwargs) #<class '__main__.People'> ('egon', 18) {}
#1、产生空对象obj
obj=object.__new__(self)
#2、调用People下的函数__init__，初始化obj
self.__init__(obj,*args,**kwargs)
#3、返回初始化好了的obj
return objclass Chinese(object,metaclass=Mymeta):
'''
中文人的类
'''
country='China'
def __init__(self,namem,age):
self.name=namem
self.age=age
def talk(self):
print('%s is talking' %self.name)
obj=Chinese('egon',age=18) #Chinese.__call__(Chinese,'egon',18)
print(obj.__dict__)
自定义元类来实现单例模式
实现方式一
class MySQL: __instance=None #__instance=obj1 def __init__(self): self.host='127.0.0.1' self.port=3306 @classmethod def singleton(cls): if not cls.__instance: obj=cls() cls.__instance=obj return cls.__instance def conn(self): pass def execute(self): pass # obj1=MySQL() # obj2=MySQL() # obj3=MySQL() # # print(obj1) # print(obj2) # print(obj3) obj1=MySQL.singleton() obj2=MySQL.singleton() obj3=MySQL.singleton() print(obj1 is obj3)
实现方式二：
class Mymeta(type): def __init__(self,class_name,class_bases,class_dic): if not class_name.istitle(): raise TypeError('类名的首字母必须大写') if '__doc__' not in class_dic or not class_dic['__doc__'].strip(): raise TypeError('必须有注释，且注释不能为空') super(Mymeta,self).__init__(class_name,class_bases,class_dic) self.__instance=None def __call__(self, *args, **kwargs): #obj=Chinese('egon',age=18) if not self.__instance: obj=object.__new__(self) self.__init__(obj) self.__instance=obj return self.__instance class Mysql(object,metaclass=Mymeta): ''' mysql xxx ''' def __init__(self): self.host='127.0.0.1' self.port=3306 def conn(self): pass def execute(self): pass obj1=Mysql() obj2=Mysql() obj3=Mysql() print(obj1 is obj2 is obj3)
再看属性查找
在学习完元类后，其实我们用class自定义的类也全都是对象（包括object类本身也是元类type的 一个实例，可以用type(object)查看），我们学习过继承的实现原理，如果把类当成对象去看，将下述继承应该说成是：对象OldboyTeacher继承对象Foo，对象Foo继承对象Bar，对象Bar继承对象object
class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类 n=444 def __call__(self, *args, **kwargs): #self=<class '__main__.OldboyTeacher'> obj=self.__new__(self) self.__init__(obj,*args,**kwargs) return obj class Bar(object): n=333 class Foo(Bar): n=222 class OldboyTeacher(Foo,metaclass=Mymeta): n=111 school='oldboy' def __init__(self,name,age): self.name=name self.age=age def say(self): print('%s says welcome to the oldboy to learn Python' %self.name) print(OldboyTeacher.n) #自下而上依次注释各个类中的n=xxx，然后重新运行程序，发现n的查找顺序为OldboyTeacher->Foo->Bar->object->Mymeta->type
于是属性查找应该分成两层，一层是对象层（基于c3算法的MRO）的查找，另外一个层则是类层（即元类层）的查找
#查找顺序： #1、先对象层：OldoyTeacher->Foo->Bar->object #2、然后元类层：Mymeta->type
依据上述总结，我们来分析下元类Mymeta中__call__里的self.__new__的查找
class Mymeta(type): n=444 def __call__(self, *args, **kwargs): #self=<class '__main__.OldboyTeacher'> obj=self.__new__(self) print(self.__new__ is object.__new__) #True class Bar(object): n=333 # def __new__(cls, *args, **kwargs): # print('Bar.__new__') class Foo(Bar): n=222 # def __new__(cls, *args, **kwargs): # print('Foo.__new__') class OldboyTeacher(Foo,metaclass=Mymeta): n=111 school='oldboy' def __init__(self,name,age): self.name=name self.age=age def say(self): print('%s says welcome to the oldboy to learn Python' %self.name) # def __new__(cls, *args, **kwargs): # print('OldboyTeacher.__new__') OldboyTeacher('egon',18) #触发OldboyTeacher的类中的__call__方法的执行，进而执行self.__new__开始查找
总结，Mymeta下的__call__里的self.__new__在OldboyTeacher、Foo、Bar里都没有找到__new__的情况下，会去找object里的__new__，而object下默认就有一个__new__，所以即便是之前的类均未实现__new__,也一定会在object中找到一个，根本不会、也根本没必要再去找元类Mymeta->type中查找__new__
我们在元类的__call__中也可以用object.__new__(self)去造对象
但我们还是推荐在__call__中使用self.__new__（self）去创造空对象，因为这种方式会检索三个类OldboyTeacher->Foo->Bar,而object.__new__则是直接跨过了他们三个
