一 前言

元类属于python面向对象编程的深层魔法，99%的人都不得要领，一些自以为搞明白元类的人其实也只是自圆其说、点到为止，从对元类的控制上来看就破绽百出、逻辑混乱，今天我就来带大家来深度了解python元类的来龙去脉。

笔者深入浅出的背后是对技术一日复一日的执念，希望可以大家可以尊重原创，为大家能因此文而解开对元类所有的疑惑而感到开心！！！

二 什么是元类

一切源自于一句话：python中一切皆为对象。让我们先定义一个类，然后逐步分析

  1. class OldboyTeacher(object):
  2.     school='oldboy'
  3. <span style="color: #0000ff;">def</span> <span style="color: #800080;">__init__</span><span style="color: #000000;">(self,name,age):
  4.     self.name</span>=<span style="color: #000000;">name
  5.     self.age</span>=<span style="color: #000000;">age
  7. </span><span style="color: #0000ff;">def</span><span style="color: #000000;"> say(self):
  8.     </span><span style="color: #0000ff;">print</span>(<span style="color: #800000;">'</span><span style="color: #800000;">%s says welcome to the oldboy to learn Python</span><span style="color: #800000;">'</span> %self.name)</pre>
  9.  

所有的对象都是实例化或者说调用类而得到的（调用类的过程称为类的实例化），比如对象t1是调用类OldboyTeacher得到的

  1. t1=OldboyTeacher('egon',18)
  2. print(type(t1)) #查看对象t1的类是<class '__main__.OldboyTeacher'>

如果一切皆为对象，那么类OldboyTeacher本质也是一个对象，既然所有的对象都是调用类得到的，那么OldboyTeacher必然也是调用了一个类得到的，这个类称为元类

于是我们可以推导出===>产生OldboyTeacher的过程一定发生了：OldboyTeacher=元类(...)

  1. print(type(OldboyTeacher)) # 结果为<class 'type'>，证明是调用了type这个元类而产生的OldboyTeacher，即默认的元类为type

三 class关键字创建类的流程分析

上文我们基于python中一切皆为对象的概念分析出：我们用class关键字定义的类本身也是一个对象，负责产生该对象的类称之为元类（元类可以简称为类的类），内置的元类为type

class关键字在帮我们创建类时，必然帮我们调用了元类OldboyTeacher=type(...)，那调用type时传入的参数是什么呢？必然是类的关键组成部分，一个类有三大组成部分，分别是

1、类名class_name='OldboyTeacher'

2、基类们class_bases=(object,)

3、类的名称空间class_dic，类的名称空间是执行类体代码而得到的

调用type时会依次传入以上三个参数

综上，class关键字帮我们创建一个类应该细分为以下四个过程

补充：exec的用法
  1. #exec：三个参数
  2.  
  3. #参数一：包含一系列python代码的字符串
  4.  
  5. #参数二：全局作用域（字典形式），如果不指定，默认为globals()
  6.  
  7. #参数三：局部作用域（字典形式），如果不指定，默认为locals()
  8.  
  9. #可以把exec命令的执行当成是一个函数的执行，会将执行期间产生的名字存放于局部名称空间中

  10. g={

  11. 'x':1,

  12. 'y':2

  13. }

  14. l={}
  15.  
  16. exec('''

  17. global x,z

  18. x=100

  19. z=200
  20.  
  21. m=300

  22. ''',g,l)
  23.  
  24. print(g) #{'x': 100, 'y': 2,'z':200,......}

  25. print(l) #{'m': 300}

五 自定义元类控制类OldboyTeacher的创建

一个类没有声明自己的元类，默认他的元类就是type，除了使用内置元类type，我们也可以通过继承type来自定义元类，然后使用metaclass关键字参数为一个类指定元类

  1. class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
  2.     pass
  3.  
  4. class OldboyTeacher(object,metaclass=Mymeta): # OldboyTeacher=Mymeta('OldboyTeacher',(object),{...})

  5. school='oldboy'
  6. <span style="color: #0000ff;">def</span> <span style="color: #800080;">__init__</span><span style="color: #000000;">(self,name,age):
  7.     self.name</span>=<span style="color: #000000;">name
  8.     self.age</span>=<span style="color: #000000;">age
  10. </span><span style="color: #0000ff;">def</span><span style="color: #000000;"> say(self):
  11.     </span><span style="color: #0000ff;">print</span>(<span style="color: #800000;">'</span><span style="color: #800000;">%s says welcome to the oldboy to learn Python</span><span style="color: #800000;">'</span> %self.name)</pre>
  12.  

自定义元类可以控制类的产生过程，类的产生过程其实就是元类的调用过程,即OldboyTeacher=Mymeta('OldboyTeacher',(object),{...})，调用Mymeta会先产生一个空对象OldoyTeacher，然后连同调用Mymeta括号内的参数一同传给Mymeta下的__init__方法，完成初始化，于是我们可以

  1. class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
  2.     def __init__(self,class_name,class_bases,class_dic):
  3.         # print(self) #<class '__main__.OldboyTeacher'>
  4.         # print(class_bases) #(<class 'object'>,)
  5.         # print(class_dic) #{'__module__': '__main__', '__qualname__': 'OldboyTeacher', 'school': 'oldboy', '__init__': <function OldboyTeacher.__init__ at 0x102b95ae8>, 'say': <function OldboyTeacher.say at 0x10621c6a8>}
  6.         super(Mymeta, self).__init__(class_name, class_bases, class_dic)  # 重用父类的功能
  7.     <span style="color: #0000ff;">if</span><span style="color: #000000;"> class_name.islower():
  8.         </span><span style="color: #0000ff;">raise</span> TypeError(<span style="color: #800000;">'</span><span style="color: #800000;">类名%s请修改为驼峰体</span><span style="color: #800000;">'</span> %<span style="color: #000000;">class_name)
  10.     </span><span style="color: #0000ff;">if</span> <span style="color: #800000;">'</span><span style="color: #800000;">__doc__</span><span style="color: #800000;">'</span> <span style="color: #0000ff;">not</span> <span style="color: #0000ff;">in</span> class_dic <span style="color: #0000ff;">or</span> len(class_dic[<span style="color: #800000;">'</span><span style="color: #800000;">__doc__</span><span style="color: #800000;">'</span>].strip(<span style="color: #800000;">'</span><span style="color: #800000;"> \n</span><span style="color: #800000;">'</span>)) ==<span style="color: #000000;"> 0:
  11.         </span><span style="color: #0000ff;">raise</span> TypeError(<span style="color: #800000;">'</span><span style="color: #800000;">类中必须有文档注释，并且文档注释不能为空</span><span style="color: #800000;">'</span><span style="color: #000000;">)
  12.  
  13. class OldboyTeacher(object,metaclass=Mymeta): # OldboyTeacher=Mymeta('OldboyTeacher',(object),{...})

  14. """

  15. 类OldboyTeacher的文档注释

  16. """

  17. school='oldboy'
  18. <span style="color: #0000ff;">def</span> <span style="color: #800080;">__init__</span><span style="color: #000000;">(self,name,age):
  19.     self.name</span>=<span style="color: #000000;">name
  20.     self.age</span>=<span style="color: #000000;">age
  22. </span><span style="color: #0000ff;">def</span><span style="color: #000000;"> say(self):
  23.     </span><span style="color: #0000ff;">print</span>(<span style="color: #800000;">'</span><span style="color: #800000;">%s says welcome to the oldboy to learn Python</span><span style="color: #800000;">'</span> %self.name)</pre>
  24.  

六 自定义元类控制类OldboyTeacher的调用

储备知识：__call__

  1. class Foo:
  2.     def __call__(self, *args, **kwargs):
  3.         print(self)
  4.         print(args)
  5.         print(kwargs)
  6.  
  7. obj=Foo()

  8. #1、要想让obj这个对象变成一个可调用的对象，需要在该对象的类中定义一个方法__call__方法，该方法会在调用对象时自动触发
  9. 2、调用obj的返回值就是__call__方法的返回值
  10.  
  11. res=obj(1,2,3,x=1,y=2)

由上例得知，调用一个对象，就是触发对象所在类中的__call__方法的执行，如果把OldboyTeacher也当做一个对象，那么在OldboyTeacher这个对象的类中也必然存在一个__call__方法

  1. class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
  2.     def __call__(self, *args, **kwargs):
  3.         print(self) #<class '__main__.OldboyTeacher'>
  4.         print(args) #('egon', 18)
  5.         print(kwargs) #{}
  6.         return 123
  7.  
  8. class OldboyTeacher(object,metaclass=Mymeta):

  9. school='oldboy'
  10. <span style="color: #0000ff;">def</span> <span style="color: #800080;">__init__</span><span style="color: #000000;">(self,name,age):
  11.     self.name</span>=<span style="color: #000000;">name
  12.     self.age</span>=<span style="color: #000000;">age
  14. </span><span style="color: #0000ff;">def</span><span style="color: #000000;"> say(self):
  15.     </span><span style="color: #0000ff;">print</span>(<span style="color: #800000;">'</span><span style="color: #800000;">%s says welcome to the oldboy to learn Python</span><span style="color: #800000;">'</span> %<span style="color: #000000;">self.name)
  16.  
  17. # 调用OldboyTeacher就是在调用OldboyTeacher类中的__call__方法
  18. 然后将OldboyTeacher传给self,溢出的位置参数传给*，溢出的关键字参数传给**
  19. 调用OldboyTeacher的返回值就是调用__call__的返回值
  20. t1=OldboyTeacher('egon',18)

  21. print(t1) #

默认地，调用t1=OldboyTeacher('egon',18)会做三件事

1、产生一个空对象obj

2、调用__init__方法初始化对象obj

3、返回初始化好的obj

对应着，OldboyTeacher类中的__call__方法也应该做这三件事

  1. class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
  2.     def __call__(self, *args, **kwargs): #self=<class '__main__.OldboyTeacher'>
  3.         #1、调用__new__产生一个空对象obj
  4.         obj=self.__new__(self) # 此处的self是类OldoyTeacher，必须传参，代表创建一个OldboyTeacher的对象obj
  5.     <span style="color: #008000;">#</span><span style="color: #008000;">2、调用__init__初始化空对象obj</span>
  6.     self.<span style="color: #800080;">__init__</span>(obj,*args,**<span style="color: #000000;">kwargs)
  8.     </span><span style="color: #008000;">#</span><span style="color: #008000;">3、返回初始化好的对象obj</span>
  9.     <span style="color: #0000ff;">return</span><span style="color: #000000;"> obj
  10.  
  11. class OldboyTeacher(object,metaclass=Mymeta):

  12. school='oldboy'
  13. <span style="color: #0000ff;">def</span> <span style="color: #800080;">__init__</span><span style="color: #000000;">(self,name,age):
  14.     self.name</span>=<span style="color: #000000;">name
  15.     self.age</span>=<span style="color: #000000;">age
  17. </span><span style="color: #0000ff;">def</span><span style="color: #000000;"> say(self):
  18.     </span><span style="color: #0000ff;">print</span>(<span style="color: #800000;">'</span><span style="color: #800000;">%s says welcome to the oldboy to learn Python</span><span style="color: #800000;">'</span> %<span style="color: #000000;">self.name)
  19.  
  20. t1=OldboyTeacher('egon',18)

  21. print(t1.dict) #{'name': 'egon', 'age': 18}

上例的__call__相当于一个模板，我们可以在该基础上改写__call__的逻辑从而控制调用OldboyTeacher的过程，比如将OldboyTeacher的对象的所有属性都变成私有的

  1. class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
  2.     def __call__(self, *args, **kwargs): #self=<class '__main__.OldboyTeacher'>
  3.         #1、调用__new__产生一个空对象obj
  4.         obj=self.__new__(self) # 此处的self是类OldoyTeacher，必须传参，代表创建一个OldboyTeacher的对象obj
  5.     <span style="color: #008000;">#</span><span style="color: #008000;">2、调用__init__初始化空对象obj</span>
  6.     self.<span style="color: #800080;">__init__</span>(obj,*args,**<span style="color: #000000;">kwargs)
  8.     </span><span style="color: #008000;">#</span><span style="color: #008000;"> 在初始化之后，obj.__dict__里就有值了</span>
  9.     obj.<span style="color: #800080;">__dict__</span>={<span style="color: #800000;">'</span><span style="color: #800000;">_%s__%s</span><span style="color: #800000;">'</span> %(self.<span style="color: #800080;">__name__</span>,k):v <span style="color: #0000ff;">for</span> k,v <span style="color: #0000ff;">in</span> obj.<span style="color: #800080;">__dict__</span><span style="color: #000000;">.items()}
  10.     </span><span style="color: #008000;">#</span><span style="color: #008000;">3、返回初始化好的对象obj</span>
  11.     <span style="color: #0000ff;">return</span><span style="color: #000000;"> obj
  12.  
  13. class OldboyTeacher(object,metaclass=Mymeta):

  14. school='oldboy'
  15. <span style="color: #0000ff;">def</span> <span style="color: #800080;">__init__</span><span style="color: #000000;">(self,name,age):
  16.     self.name</span>=<span style="color: #000000;">name
  17.     self.age</span>=<span style="color: #000000;">age
  19. </span><span style="color: #0000ff;">def</span><span style="color: #000000;"> say(self):
  20.     </span><span style="color: #0000ff;">print</span>(<span style="color: #800000;">'</span><span style="color: #800000;">%s says welcome to the oldboy to learn Python</span><span style="color: #800000;">'</span> %<span style="color: #000000;">self.name)
  21.  
  22. t1=OldboyTeacher('egon',18)

  23. print(t1.dict) #{'_OldboyTeacher__name': 'egon', '_OldboyTeacher__age': 18}

上例中涉及到查找属性的问题，比如self.__new__，请看下一小节

六 再看属性查找

结合python继承的实现原理+元类重新看属性的查找应该是什么样子呢？？？

在学习完元类后，其实我们用class自定义的类也全都是对象（包括object类本身也是元类type的 一个实例，可以用type(object)查看），我们学习过继承的实现原理，如果把类当成对象去看，将下述继承应该说成是：对象OldboyTeacher继承对象Foo，对象Foo继承对象Bar，对象Bar继承对象object

  1. class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
  2.     n=444
  3. <span style="color: #0000ff;">def</span> <span style="color: #800080;">__call__</span>(self, *args, **kwargs): <span style="color: #008000;">#</span><span style="color: #008000;">self=&lt;class '__main__.OldboyTeacher'&gt;</span>
  4.     obj=self.<span style="color: #800080;">__new__</span><span style="color: #000000;">(self)
  5.     self.</span><span style="color: #800080;">__init__</span>(obj,*args,**<span style="color: #000000;">kwargs)
  6.     </span><span style="color: #0000ff;">return</span><span style="color: #000000;"> obj
  7.  
  8. class Bar(object):

  9. n=333
  10. class Foo(Bar):

  11. n=222
  12. class OldboyTeacher(Foo,metaclass=Mymeta):

  13. n=111
  14. school</span>=<span style="color: #800000;">'</span><span style="color: #800000;">oldboy</span><span style="color: #800000;">'</span>
  16. <span style="color: #0000ff;">def</span> <span style="color: #800080;">__init__</span><span style="color: #000000;">(self,name,age):
  17.     self.name</span>=<span style="color: #000000;">name
  18.     self.age</span>=<span style="color: #000000;">age
  20. </span><span style="color: #0000ff;">def</span><span style="color: #000000;"> say(self):
  21.     </span><span style="color: #0000ff;">print</span>(<span style="color: #800000;">'</span><span style="color: #800000;">%s says welcome to the oldboy to learn Python</span><span style="color: #800000;">'</span> %<span style="color: #000000;">self.name)
  22.  
  23. print(OldboyTeacher.n) #自下而上依次注释各个类中的n=xxx，然后重新运行程序，发现n的查找顺序为OldboyTeacher->Foo->Bar->object->Mymeta->type

于是属性查找应该分成两层，一层是对象层（基于c3算法的MRO）的查找，另外一个层则是类层（即元类层）的查找

  1. #查找顺序：
  2. #1、先对象层：OldoyTeacher->Foo->Bar->object
  3. #2、然后元类层：Mymeta->type

依据上述总结，我们来分析下元类Mymeta中__call__里的self.__new__的查找

  1. class Mymeta(type):
  2.     n=444
  3. <span style="color: #0000ff;">def</span> <span style="color: #800080;">__call__</span>(self, *args, **kwargs): <span style="color: #008000;">#</span><span style="color: #008000;">self=&lt;class '__main__.OldboyTeacher'&gt;</span>
  4.     obj=self.<span style="color: #800080;">__new__</span><span style="color: #000000;">(self)
  5.     </span><span style="color: #0000ff;">print</span>(self.<span style="color: #800080;">__new__</span> <span style="color: #0000ff;">is</span> object.<span style="color: #800080;">__new__</span>) <span style="color: #008000;">#</span><span style="color: #008000;">True</span>
  6.  
  7. class Bar(object):

  8. n=333
  9. <span style="color: #008000;">#</span><span style="color: #008000;"> def __new__(cls, *args, **kwargs):</span>
  10. <span style="color: #008000;">#</span><span style="color: #008000;">     print('Bar.__new__')</span>
  11.  
  12. class Foo(Bar):

  13. n=222
  14. <span style="color: #008000;">#</span><span style="color: #008000;"> def __new__(cls, *args, **kwargs):</span>
  15. <span style="color: #008000;">#</span><span style="color: #008000;">     print('Foo.__new__')</span>
  16.  
  17. class OldboyTeacher(Foo,metaclass=Mymeta):

  18. n=111
  19. school</span>=<span style="color: #800000;">'</span><span style="color: #800000;">oldboy</span><span style="color: #800000;">'</span>
  21. <span style="color: #0000ff;">def</span> <span style="color: #800080;">__init__</span><span style="color: #000000;">(self,name,age):
  22.     self.name</span>=<span style="color: #000000;">name
  23.     self.age</span>=<span style="color: #000000;">age
  25. </span><span style="color: #0000ff;">def</span><span style="color: #000000;"> say(self):
  26.     </span><span style="color: #0000ff;">print</span>(<span style="color: #800000;">'</span><span style="color: #800000;">%s says welcome to the oldboy to learn Python</span><span style="color: #800000;">'</span> %<span style="color: #000000;">self.name)
  28. </span><span style="color: #008000;">#</span><span style="color: #008000;"> def __new__(cls, *args, **kwargs):</span>
  29. <span style="color: #008000;">#</span><span style="color: #008000;">     print('OldboyTeacher.__new__')</span>
  30.  
  31. 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__则是直接跨过了他们三个

最后说明一点

  1. class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
  2.     n=444
  3. <span style="color: #0000ff;">def</span> <span style="color: #800080;">__new__</span>(cls, *args, **<span style="color: #000000;">kwargs):
  4.     obj</span>=type.<span style="color: #800080;">__new__</span>(cls,*args,**kwargs) <span style="color: #008000;">#</span><span style="color: #008000;"> 必须按照这种传值方式</span>
  5.     <span style="color: #0000ff;">print</span>(obj.<span style="color: #800080;">__dict__</span><span style="color: #000000;">)
  6.     </span><span style="color: #008000;">#</span><span style="color: #008000;"> return obj # 只有在返回值是type的对象时，才会触发下面的__init__</span>
  7.     <span style="color: #0000ff;">return</span> 123
  9. <span style="color: #0000ff;">def</span> <span style="color: #800080;">__init__</span><span style="color: #000000;">(self,class_name,class_bases,class_dic):
  10.     </span><span style="color: #0000ff;">print</span>(<span style="color: #800000;">'</span><span style="color: #800000;">run。。。</span><span style="color: #800000;">'</span><span style="color: #000000;">)
  11.  
  12. class OldboyTeacher(object,metaclass=Mymeta): #OldboyTeacher=Mymeta('OldboyTeacher',(object),{...})

  13. n=111
  14. school</span>=<span style="color: #800000;">'</span><span style="color: #800000;">oldboy</span><span style="color: #800000;">'</span>
  16. <span style="color: #0000ff;">def</span> <span style="color: #800080;">__init__</span><span style="color: #000000;">(self,name,age):
  17.     self.name</span>=<span style="color: #000000;">name
  18.     self.age</span>=<span style="color: #000000;">age
  20. </span><span style="color: #0000ff;">def</span><span style="color: #000000;"> say(self):
  21.     </span><span style="color: #0000ff;">print</span>(<span style="color: #800000;">'</span><span style="color: #800000;">%s says welcome to the oldboy to learn Python</span><span style="color: #800000;">'</span> %<span style="color: #000000;">self.name)
  22.  
  23. print(type(Mymeta)) #<class 'type'>
  24. 产生类OldboyTeacher的过程就是在调用Mymeta，而Mymeta也是type类的一个对象，那么Mymeta之所以可以调用，一定是在元类type中有一个__call__方法
  25. 该方法中同样需要做至少三件事：
  26. class type:
  27. def call(self, *args, **kwargs): #self=<class 'main.Mymeta'>
  28. obj=self.new(self,*args,**kwargs) # 产生Mymeta的一个对象
  29. self.init(obj,*args,**kwargs)
  30. return obj

七 练习题

练习一：在元类中控制把自定义类的数据属性都变成大写

  1. class Mymetaclass(type):
  2.     def __new__(cls,name,bases,attrs):
  3.         update_attrs={}
  4.         for k,v in attrs.items():
  5.             if not callable(v) and not k.startswith('__'):
  6.                 update_attrs[k.upper()]=v
  7.             else:
  8.                 update_attrs[k]=v
  9.         return type.__new__(cls,name,bases,update_attrs)
  10.  
  11. class Chinese(metaclass=Mymetaclass):

  12. country='China'

  13. tag='Legend of the Dragon' #龙的传人

  14. def walk(self):

  15. print('%s is walking' %self.name)
  16.  
  17. print(Chinese.dict)

  18. '''

  19. {'module': 'main',

  20. 'COUNTRY': 'China',

  21. 'TAG': 'Legend of the Dragon',

  22. 'walk': <function Chinese.walk at 0x0000000001E7B950>,

  23. 'dict': <attribute 'dict' of 'Chinese' objects>,

  24. 'weakref': <attribute 'weakref' of 'Chinese' objects>,

  25. 'doc': None}

  26. '''

练习二：在元类中控制自定义的类无需__init__方法

　　1.元类帮其完成创建对象，以及初始化操作；

　　2.要求实例化时传参必须为关键字形式，否则抛出异常TypeError: must use keyword argument

　　3.key作为用户自定义类产生对象的属性，且所有属性变成大写

  1. class Mymetaclass(type):
  2.     # def __new__(cls,name,bases,attrs):
  3.     #     update_attrs={}
  4.     #     for k,v in attrs.items():
  5.     #         if not callable(v) and not k.startswith('__'):
  6.     #             update_attrs[k.upper()]=v
  7.     #         else:
  8.     #             update_attrs[k]=v
  9.     #     return type.__new__(cls,name,bases,update_attrs)
  10. <span style="color: #0000ff;">def</span> <span style="color: #800080;">__call__</span>(self, *args, **<span style="color: #000000;">kwargs):
  11.     </span><span style="color: #0000ff;">if</span><span style="color: #000000;"> args:
  12.         </span><span style="color: #0000ff;">raise</span> TypeError(<span style="color: #800000;">'</span><span style="color: #800000;">must use keyword argument for key function</span><span style="color: #800000;">'</span><span style="color: #000000;">)
  13.     obj </span>= object.<span style="color: #800080;">__new__</span>(self) <span style="color: #008000;">#</span><span style="color: #008000;">创建对象，self为类Foo</span>
  15.     <span style="color: #0000ff;">for</span> k,v <span style="color: #0000ff;">in</span><span style="color: #000000;"> kwargs.items():
  16.         obj.</span><span style="color: #800080;">__dict__</span>[k.upper()]=<span style="color: #000000;">v
  17.     </span><span style="color: #0000ff;">return</span><span style="color: #000000;"> obj
  18.  
  19. class Chinese(metaclass=Mymetaclass):

  20. country='China'

  21. tag='Legend of the Dragon' #龙的传人

  22. def walk(self):

  23. print('%s is walking' %self.name)
  24. p=Chinese(name='egon',age=18,sex='male')

  25. print(p.dict)

练习三：在元类中控制自定义的类产生的对象相关的属性全部为隐藏属性

  1. class Mymeta(type):
  2.     def __init__(self,class_name,class_bases,class_dic):
  3.         #控制类Foo的创建
  4.         super(Mymeta,self).__init__(class_name,class_bases,class_dic)
  5. </span><span style="color: #0000ff;">def</span> <span style="color: #800080;">__call__</span>(self, *args, **<span style="color: #000000;">kwargs):
  6.     </span><span style="color: #008000;">#</span><span style="color: #008000;">控制Foo的调用过程，即Foo对象的产生过程</span>
  7.     obj = self.<span style="color: #800080;">__new__</span><span style="color: #000000;">(self)
  8.     self.</span><span style="color: #800080;">__init__</span>(obj, *args, **<span style="color: #000000;">kwargs)
  9.     obj.</span><span style="color: #800080;">__dict__</span>={<span style="color: #800000;">'</span><span style="color: #800000;">_%s__%s</span><span style="color: #800000;">'</span> %(self.<span style="color: #800080;">__name__</span>,k):v <span style="color: #0000ff;">for</span> k,v <span style="color: #0000ff;">in</span> obj.<span style="color: #800080;">__dict__</span><span style="color: #000000;">.items()}
  11.     </span><span style="color: #0000ff;">return</span><span style="color: #000000;"> obj
  12.  
  13. class Foo(object,metaclass=Mymeta):  # Foo=Mymeta(...)

  14. def init(self, name, age,sex):

  15. self.name=name

  16. self.age=age

  17. self.sex=sex
  18. obj=Foo('egon',18,'male')

  19. print(obj.dict)

练习四：基于元类实现单例模式

  1. #步骤五：基于元类实现单例模式
  2. # 单例：即单个实例，指的是同一个类实例化多次的结果指向同一个对象，用于节省内存空间
  3. # 如果我们从配置文件中读取配置来进行实例化，在配置相同的情况下，就没必要重复产生对象浪费内存了
  4. #settings.py文件内容如下
  5. HOST='1.1.1.1'
  6. PORT=3306
  7.  
  8. #方式一:定义一个类方法实现单例模式

  9. import settings
  10.  
  11. class Mysql:

  12. __instance=None

  13. def init(self,host,port):

  14. self.host=host

  15. self.port=port
  16. @classmethod
  17. </span><span style="color: #0000ff;">def</span><span style="color: #000000;"> singleton(cls):
  18.     </span><span style="color: #0000ff;">if</span> <span style="color: #0000ff;">not</span> cls.<span style="color: #800080;">__instance</span><span style="color: #000000;">:
  19.         cls.</span><span style="color: #800080;">__instance</span>=<span style="color: #000000;">cls(settings.HOST,settings.PORT)
  20.     </span><span style="color: #0000ff;">return</span> cls.<span style="color: #800080;">__instance</span><span style="color: #000000;">
  21.  
  22. obj1=Mysql('1.1.1.2',3306)

  23. obj2=Mysql('1.1.1.3',3307)

  24. print(obj1 is obj2) #False



  26. obj3=Mysql.singleton()

  27. obj4=Mysql.singleton()

  28. print(obj3 is obj4) #True
  29. #方式二：定制元类实现单例模式

  30. import settings
  31. class Mymeta(type):

  32. def init(self,name,bases,dic): #定义类Mysql时就触发
  33.     <span style="color: #008000;">#</span><span style="color: #008000;"> 事先先从配置文件中取配置来造一个Mysql的实例出来</span>
  34.     self.<span style="color: #800080;">__instance</span> = object.<span style="color: #800080;">__new__</span>(self)  <span style="color: #008000;">#</span><span style="color: #008000;"> 产生对象</span>
  35.     self.<span style="color: #800080;">__init__</span>(self.<span style="color: #800080;">__instance</span>, settings.HOST, settings.PORT)  <span style="color: #008000;">#</span><span style="color: #008000;"> 初始化对象</span>
  36.     <span style="color: #008000;">#</span><span style="color: #008000;"> 上述两步可以合成下面一步</span>
  37.     <span style="color: #008000;">#</span><span style="color: #008000;"> self.__instance=super().__call__(*args,**kwargs)</span>
  38.  
  39.     super().</span><span style="color: #800080;">__init__</span><span style="color: #000000;">(name,bases,dic)
  41. </span><span style="color: #0000ff;">def</span> <span style="color: #800080;">__call__</span>(self, *args, **kwargs): <span style="color: #008000;">#</span><span style="color: #008000;">Mysql(...)时触发</span>
  42.     <span style="color: #0000ff;">if</span> args <span style="color: #0000ff;">or</span> kwargs: <span style="color: #008000;">#</span><span style="color: #008000;"> args或kwargs内有值</span>
  43.         obj=object.<span style="color: #800080;">__new__</span><span style="color: #000000;">(self)
  44.         self.</span><span style="color: #800080;">__init__</span>(obj,*args,**<span style="color: #000000;">kwargs)
  45.         </span><span style="color: #0000ff;">return</span><span style="color: #000000;"> obj
  47.     </span><span style="color: #0000ff;">return</span> self.<span style="color: #800080;">__instance</span>
  48.  
  49. class Mysql(metaclass=Mymeta):

  50. def init(self,host,port):

  51. self.host=host

  52. self.port=port
  53. obj1=Mysql() # 没有传值则默认从配置文件中读配置来实例化，所有的实例应该指向一个内存地址

  54. obj2=Mysql()

  55. obj3=Mysql()
  56. print(obj1 is obj2 is obj3)
  57. obj4=Mysql('1.1.1.4',3307)
  58. #方式三:定义一个装饰器实现单例模式

  59. import settings
  60. def singleton(cls): #cls=Mysql

  61. _instance=cls(settings.HOST,settings.PORT)
  62. </span><span style="color: #0000ff;">def</span> wrapper(*args,**<span style="color: #000000;">kwargs):
  63.     </span><span style="color: #0000ff;">if</span> args <span style="color: #0000ff;">or</span><span style="color: #000000;"> kwargs:
  64.         obj</span>=cls(*args,**<span style="color: #000000;">kwargs)
  65.         </span><span style="color: #0000ff;">return</span><span style="color: #000000;"> obj
  66.     </span><span style="color: #0000ff;">return</span><span style="color: #000000;"> _instance
  68. </span><span style="color: #0000ff;">return</span><span style="color: #000000;"> wrapper
  69.  
  70. @singleton # Mysql=singleton(Mysql)

  71. class Mysql:

  72. def init(self,host,port):

  73. self.host=host

  74. self.port=port
  75. obj1=Mysql()

  76. obj2=Mysql()

  77. obj3=Mysql()

  78. print(obj1 is obj2 is obj3) #True



  80. obj4=Mysql('1.1.1.3',3307)

  81. obj5=Mysql('1.1.1.4',3308)

  82. print(obj3 is obj4) #False

转自：

元类metaclass - linhaifeng - 博客园

http://www.cnblogs.com/linhaifeng/articles/8029564.html

（转）元类metaclass的更多相关文章

  1. 深刻理解Python中的元类metaclass（转）

    本文由 伯乐在线 - bigship 翻译 英文出处:stackoverflow 译文:http://blog.jobbole.com/21351/ 译注:这是一篇在Stack overflow上很热 ...

  2. 深刻理解Python中的元类(metaclass)

    译注:这是一篇在Stack overflow上很热的帖子.提问者自称已经掌握了有关Python OOP编程中的各种概念,但始终觉得元类(metaclass)难以理解.他知道这肯定和自省有关,但仍然觉得 ...

  3. Python中的元类(metaclass)

    推荐+收藏:深刻理解Python中的元类(metaclass) 做一些笔记学习学习: 在大多数编程语言中,类就是用来描述如何生成一个对象的代码段,在Python中类也是一个对象,这个(类)对象自身拥有 ...

  4. [转] 深刻理解Python中的元类(metaclass)

    非常详细的一篇深入讲解Python中metaclass的文章,感谢伯乐在线-bigship翻译及作者,转载收藏. 本文由 伯乐在线 - bigship 翻译.未经许可,禁止转载!英文出处:stacko ...

  5. [转]深刻理解Python中的元类(metaclass)以及元类实现单例模式

    使用元类 深刻理解Python中的元类(metaclass)以及元类实现单例模式 在看一些框架源代码的过程中碰到很多元类的实例,看起来很吃力很晦涩:在看python cookbook中关于元类创建单例 ...

  6. 深刻理解Python中的元类(metaclass)【转】

    译注:这是一篇在Stack overflow上很热的帖子.提问者自称已经掌握了有关Python OOP编程中的各种概念,但始终觉得元类(metaclass)难以理解.他知道这肯定和自省有关,但仍然觉得 ...

  7. 深入理解Python中的元类(metaclass)

    原文 译注:这是一篇在Stack overflow上很热的帖子.提问者自称已经掌握了有关Python OOP编程中的各种概念,但始终觉得元类(metaclass)难以理解.他知道这肯定和自省有关,但仍 ...

  8. python——深刻理解Python中的元类(metaclass)

    译注:这是一篇在Stack overflow上 很热的帖子.提问者自称已经掌握了有关Python OOP编程中的各种概念,但始终觉得元类(metaclass)难以理解.他知道这肯定和自省有关,但仍然觉 ...

  9. python中的元类metaclass

    本文是一个转载的,因为原文写的太好了,所以直接copy过来吧. 原文请看:http://blog.jobbole.com/21351/ 译注:这是一篇在Stack overflow上 很热的帖子.提问 ...

  10. 谈谈Python中元类Metaclass(二)：ORM实践

    什么是ORM? ORM的英文全称是“Object Relational Mapping”,即对象-关系映射,从字面上直接理解,就是把“关系”给“对象”化. 对应到数据库,我们知道关系数据库(例如Mys ...

随机推荐

  1. python 获取手机设备号

    上代码 ##获取设备多台设备号列表 def get_deviceid(): str_init=' ' all_info= os.popen('adb devices').readlines() pri ...

  2. Dubbo入门到精通学习笔记（十七）：FastDFS集群的安装、FastDFS集群的配置

    文章目录 FastDFS集群的安装 FastDFS 介绍(参考:http://www.oschina.net/p/fastdfs) FastDFS 上传文件交互过程: FastDFS 下载文件交互过程 ...

  3. 浏览器获取自定义响应头response-headers

    原创作品版权归属本人所有,违者必究 https://blog.csdn.net/qq_37025445/article/details/82888731想在浏览器获取响应头里面自定义的响应头:file ...

  4. JAVA FileUtils(文件读写以及操作工具类)

    文件操作常用功能: package com.suning.yypt.business.report; import java.io.*; import java.util.*; @SuppressWa ...

  5. SQlite 学习资料

      很有用的开源跨平台数据库,可以作为客户端的小型内存数据库使用,据说它有N多用户(Nokia's Symbian,Mozilla,Abobe,Google,阿里旺旺,飞信,Chrome,FireFo ...

  6. Linux SSH证书登陆

    创建证书 ssh-keygen -t rsa -b 4096 -C "your_email@example.com" 证书导入以后,执行 eval "$(ssh-agen ...

  7. 一、数据库、SQL简介

    1.数据库简介 1.1数据库:保存有组织的数据的容器(通常是一个文件或一组文件) 数据库软件:称为数据库管理系统(DBMS),数据库是通过DBMS创建和操纵的.通常用户使用DBMS访问数据库. 表:表 ...

  8. java8如何对List<Bean>进行去重和覆盖

    背景:有一批数据源从kafka给过来,接收到后需要处理,然后入库,我们用一个线程消费下来,一次消费30000条, 按照对象的概念,可以用List<Person>来表示,因为某种原因,需要根 ...

  9. python学习10—迭代器、三元表达式与生成器

    python学习10—迭代器.三元表达式与生成器 1. 迭代器协议 定义:对象必须提供一个next方法,执行该方法或者返回迭代中的下一项,或者返回一个StopIteration异常,以终止迭代(只能往 ...

  10. Java中的数据结构有哪些？HashMap的工作原理是什么？

    Java中常用数据结构 常用的数据结构有哈希表,线性表,链表,java.util包中有三个重要的接口:List,Set,Map常用来实现基本的数据结构 HashMap的工作原理 HashMap基于ha ...