Python中的元类(metaclass) -阿里云开发者社区

一、什么是元类

1	`元类(metaclass) ：就是创建类的类。`

这么说可能不太好理解，下面我们来解释下上面这句话：

在⼤多数编程语⾔中，类就是⼀组⽤来描述如何⽣成⼀个对象的代码段，在python中也不例外。

实例对象是由类生成的，而python中，类本身也是可以被传递和自省的对象。

类对象是用什么创建和生成的呢？答案是元类，元类就是一种知道如何创建和管理类的对象，也可以叫做类生成器。

所有的对象都是实例化或者说调用类而得到的（调用类的过程称为类的实例化),python内置了一个方法可以看到类对象的类，就是type,：

查看对象的类型：

查看类的类型

结果为<class 'type'>，证明是调用了type这个元类而产生的StanfordTeacher，即默认的元类为type，是不是有些惊讶

于是我们可以推导出：

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

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

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

1、类名class_name='StanfordTeacher'

2、基类们class_bases=(object,)

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

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

type可以接受一个类的描述作为参数，然后返回一个类。type可以像这样工作：

type(类名, 由父类名称组成的元组（针对继承的情况，可以为空），包含属性的字典（名称和值）)

比如下面的代码：

可以手动像这样创建：

那么class关键字底层的做了哪些事?

# 1、先拿到一个类名

class_name = "StanfordTeacher"

# 2、然后拿到类的父类

class_bases = (object,)

# 3、再运行类体代码，将产生的名字放到名称空间中

class_dic = {}

class_body = """

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)

"""

exec(class_body,{},class_dic)

# print(class_dic)

# 4、调用元类（传入类的三大要素：类名、基类、类的名称空间）得到一个元类的对象，然后将元类的对象赋值给变量名StanfordTeacher,StanfordTeacher就是我们用class自定义的那个类

StanfordTeacher = type(class_name,class_bases,class_dic)

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

三、到底什么是元类

元类就是用来创建类的“东西”。你创建类就是为了创建类的实例对象，不是吗？但是我们已经学习到了Python中的类也是对象。

元类就是用来创建这些类（对象）的，元类就是类的类，你可以这样理解为：

1 2	`MyClass = MetaClass() #使用元类创建出一个对象，这个对象称为“类”` `MyObject = MyClass() #使用“类”来创建出实例对象`

你已经看到了type可以让你像这样做：　　

1	`MyClass = type('MyClass', (), {})`

这是因为函数type实际上是一个元类。type就是Python在背后用来创建所有类的元类。type就是创建类对象的类。你可以通过检查__class__属性来看到这一点。Python中所有的东西，注意，我是指所有的东西——都是对象。这包括整数、字符串、函数以及类。它们全部都是对象，而且它们都是从一个类创建而来，这个类就是type。　　

四、自定义元类控制类的创建

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

class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类

pass

# StanfordTeacher=Mymeta('StanfordTeacher',(object),{...})

class StanfordTeacher(object,metaclass=Mymeta):

school='Stanford'

def __init__(self,name,age):

self.name=name

self.age=age

def say(self):

print('%s says welcome to the Stanford to learn Python' %self.name)

自定义元类可以控制类的产生过程，类的产生过程其实就是元类的调用过程,即

StanfordTeacher=Mymeta('StanfordTeacher',(object),{...})，

调用Mymeta会先产生一个空对象StanfordTeacher，

然后连同调用Mymeta括号内的参数一同传给Mymeta下的__init__方法，完成初始化，　　

于是我们可以自定义元类来控制StanfordTeacher类的产生：如下示例

1.自定义元类来控制StanfordTeacher类的产生

import re

class Mymeta(type): # 只有继承了type类的类才是自定义的元类

def __init__(self, class_name, class_bases, class_dic):

# print(self) # 类<class '__main__.StanfordTeacher'>

# print(class_name)

# print(class_bases)

# print(class_dic)

if not re.match("[A-Z]", class_name):

raise BaseException("类名必须用驼峰体")

if len(class_bases) == 0:

raise BaseException("至少继承一个父类")

# print("文档注释：",class_dic.get('__doc__'))

doc=class_dic.get('__doc__')

if not (doc and len(doc.strip()) > 0):

raise BaseException("必须要有文件注释，并且注释内容不为空")

# StanfordTeacher = Mymeta("StanfordTeacher",(object,),{...})

class StanfordTeacher(object,metaclass=Mymeta):

"""

adsaf

"""

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)

自定义元类来控制StanfordTeacher类的调用:

储备知识：__call__

class Foo:

def __call__(self, *args, **kwargs):

print(self)

print(args)

print(kwargs)

obj=Foo()

#1、要想让obj这个对象变成一个可调用的对象，需要在该对象的类中定义一个方法__call__方法，该方法会在调用对象时自动触发

#2、调用obj的返回值就是__call__方法的返回值

res=obj(1,2,3,x=1,y=2)

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

class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类

def __call__(self, *args, **kwargs):

print(self) #<class '__main__.StanfordTeacher'>

print(args) #('lili', 18)

print(kwargs) #{}

return 123

class StanfordTeacher(object,metaclass=Mymeta):

school='Stanford'

def __init__(self,name,age):

self.name=name

self.age=age

def say(self):

print('%s says welcome to the Stanford to learn Python' %self.name)

# 调用StanfordTeacher就是在调用StanfordTeacher类中的__call__方法

# 然后将StanfordTeacher传给self,溢出的位置参数传给*，溢出的关键字参数传给**

# 调用StanfordTeacher的返回值就是调用__call__的返回值

t1=StanfordTeacher('lili',18)

print(t1) #123

默认地，调用t1=StanfordTeacher('lili',18)会做三件事:

1、产生一个空对象obj

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

3、返回初始化好的obj

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

class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类

def __call__(self, *args, **kwargs): #self=<class '__main__.StanfordTeacher'>

#1、调用__new__产生一个空对象obj

obj=self.__new__(self) # 此处的self是类StanfordTeacher，必须传参，代表创建一个StanfordTeacher的对象obj

#2、调用__init__初始化空对象obj

self.__init__(obj,*args,**kwargs)

#3、返回初始化好的对象obj

return obj

class StanfordTeacher(object,metaclass=Mymeta):

school='Stanford'

def __init__(self,name,age):

self.name=name

self.age=age

def say(self):

print('%s says welcome to the Stanford to learn Python' %self.name)

t1=StanfordTeacher('lili',18)

print(t1.__dict__) #{'name': 'lili', 'age': 18}

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

import re

class Mymeta(type): # 只有继承了type类的类才是自定义的元类

def __init__(self, class_name, class_bases, class_dic):

# print(self) # 类<class '__main__.StanfordTeacher'>

# print(class_name)

# print(class_bases)

# print(class_dic)

if not re.match("[A-Z]", class_name):

raise BaseException("类名必须用驼峰体")

if len(class_bases) == 0:

raise BaseException("至少继承一个父类")

# print("文档注释：",class_dic.get('__doc__'))

doc = class_dic.get('__doc__')

if not (doc and len(doc.strip()) > 0):

raise BaseException("必须要有文件注释，并且注释内容不为空")

# res = StanfordTeacher('egon',18)

def __call__(self, *args, **kwargs):

# 1、先创建一个老师的空对象

tea_obj = object.__new__(self)

# 2、调用老师类内的__init__函数，然后将老师的空对象连同括号内的参数的参数一同传给__init__

self.__init__(tea_obj, *args, **kwargs)

tea_obj.__dict__ = {"_%s__%s" %(self.__name__,k): v for k, v in tea_obj.__dict__.items()}

# 3、将初始化好的老师对象赋值给变量名res

return tea_obj

# StanfordTeacher = Mymeta("StanfordTeacher",(object,),{...})

class StanfordTeacher(object, metaclass=Mymeta):

"""

adsaf

"""

school = 'oldboy'

# tea_obj,'egon',18

def __init__(self, name, age):

self.name = name # tea_obj.name='egon'

self.age = age # tea_obj.age=18

def say(self):

print('%s says welcome to the oldboy to learn Python' % self.name)

res = StanfordTeacher('egon', 18)

print(res.__dict__)

# print(res.name)

# print(res.age)

# print(res.say)

# 调用StanfordTeacher类做的事情：

# 1、先创建一个老师的空对象

# 2、调用老师类内的__init__方法，然后将老师的空对象连同括号内的参数的参数一同传给__init__

# 3、将初始化好的老师对象赋值给变量名res

最后说明一点

class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类

n=444

def __new__(cls, *args, **kwargs):

obj=type.__new__(cls,*args,**kwargs) # 必须按照这种传值方式

print(obj.__dict__)

# return obj # 只有在返回值是type的对象时，才会触发下面的__init__

return 123

def __init__(self,class_name,class_bases,class_dic):

print('run。。。')

class StanfordTeacher(object,metaclass=Mymeta): #StanfordTeacher=Mymeta('StanfordTeacher',(object),{...})

n=111

school='Stanford'

def __init__(self,name,age):

self.name=name

self.age=age

def say(self):

print('%s says welcome to the Stanford to learn Python' %self.name)

print(type(Mymeta)) #<class 'type'>

# 产生类StanfordTeacher的过程就是在调用Mymeta，而Mymeta也是type类的一个对象，那么Mymeta之所以可以调用，一定是在元类type中有一个__call__方法

# 该方法中同样需要做至少三件事：

# class type:

# def __call__(self, *args, **kwargs): #self=<class '__main__.Mymeta'>

# obj=self.__new__(self,*args,**kwargs) # 产生Mymeta的一个对象

# self.__init__(obj,*args,**kwargs)

# return obj

五、元类冲突

假如有两个不同的元类，要生成一个继承这两个类的子类，会产生什么情况呢？

这时会报错，元类冲突。

我们需要手动构造新的子类元类，让新的子类元类继承自A和B的元类：

六、元类的应用

应用元类之前我们首先要知道使用元类编程的缺点：

实现麻烦

代码可读性不高

不易维护

其实在开头引用TimPeters的话就说明，不要随意在生产代码中使用元类，而且现有的编码规范也极不推荐使用。

就元类本身而言，它的作用是：

拦截类的创建

修改类

返回修改之后的类

使用元类还是有一些好处的：

意图更加明确。当然你的metaclass名字要起好

面向对象。可以隐式继承到子类

可以更好地组织代码

可以用__new__，__init__,__call__等方法更好地控制

七、在Python当中，call,new,init三者之间的关系

在类实例化的过程当中，哪个对象加()就寻找产生这个对象的类的__call__方法，只要是__call__方法，一定会做三件事情：

第一：调用__new__方法，构造新的对象，相当于Java当中的构造函数.（对象自己的__new__）

第二：调用__init__方法,去初始化这个对象（对象自己的__init__）

第三：返回这个对象.

注意:__new__更像是其他语言当中的构造函数，必须有返回值，返回值实例化的对象，__init__只是初始化构造函数，必须没有返回值，仅仅只是初始化功能，并不能new创建对象.

也就是说,一个类在实例化的时候实际上是做了三件事情：

第一：触发元类中（造出这个类的类）的__call__方法

第二：通过__new__产生一个空对象

第三：通过__init__初始化这个对象

第四：返回这个对象

类在实例化对象的时候函数的调用顺序依次是:

1	`__call__==>__new__==>__init__`

八、练习：　　

1、在元类中控制把自定义类的数据属性都变成大写

class Mymetaclass(type):

def __new__(cls,name,bases,attrs):

update_attrs={}

for k,v in attrs.items():

if not callable(v) and not k.startswith('__'):

update_attrs[k.upper()]=v

else:

update_attrs[k]=v

return type.__new__(cls,name,bases,update_attrs)

class Chinese(metaclass=Mymetaclass):

country='China'

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

def walk(self):

print('%s is walking' %self.name)

print(Chinese.__dict__)

'''

{'__module__': '__main__',

'COUNTRY': 'China',

'TAG': 'Legend of the Dragon',

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

'__dict__': <attribute '__dict__' of 'Chinese' objects>,

'__weakref__': <attribute '__weakref__' of 'Chinese' objects>,

'__doc__': None}

'''

2、在元类中控制自定义的类不使用init方法完成以下

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

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

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

class Mymetaclass(type):

# def __new__(cls,name,bases,attrs):

# update_attrs={}

# for k,v in attrs.items():

# if not callable(v) and not k.startswith('__'):

# update_attrs[k.upper()]=v

# else:

# update_attrs[k]=v

# return type.__new__(cls,name,bases,update_attrs)

def __call__(self, *args, **kwargs):

if args:

raise TypeError('must use keyword argument for key function')

obj = object.__new__(self) #创建对象，self为类Foo

for k,v in kwargs.items():

obj.__dict__[k.upper()]=v

return obj

class Chinese(metaclass=Mymetaclass):

country='China'

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

def walk(self):

print('%s is walking' %self.name)

p=Chinese(name='lili',age=18,sex='male')

print(p.__dict__)

3、在元类中控制自定义的类产生的对象相关的属性全部为隐藏属性　　

class Mymeta(type):

def __init__(self,class_name,class_bases,class_dic):

#控制类Foo的创建

super(Mymeta,self).__init__(class_name,class_bases,class_dic)

def __call__(self, *args, **kwargs):

#控制Foo的调用过程，即Foo对象的产生过程

obj = self.__new__(self)

self.__init__(obj, *args, **kwargs)

obj.__dict__={'_%s__%s' %(self.__name__,k):v for k,v in obj.__dict__.items()}

return obj

class Foo(object,metaclass=Mymeta): # Foo=Mymeta(...)

def __init__(self, name, age,sex):

self.name=name

self.age=age

self.sex=sex

obj=Foo('lili',18,'male')

print(obj.__dict__)

4、基于元类实现单例模式

# 单例：即单个实例，指的是同一个类实例化多次的结果指向同一个对象，用于节省内存空间

# 如果我们从配置文件中读取配置来进行实例化，在配置相同的情况下，就没必要重复产生对象浪费内存了

#settings.py文件内容如下

HOST='1.1.1.1'

PORT=3306　　

方式一:定义一个类方法实现单例模式

import settings

class Mysql:

__instance=None

def __init__(self,host,port):

self.host=host

self.port=port

@classmethod

def singleton(cls):

if not cls.__instance:

cls.__instance=cls(settings.HOST,settings.PORT)

return cls.__instance

obj1=Mysql('1.1.1.2',3306)

obj2=Mysql('1.1.1.3',3307)

print(obj1 is obj2) #False

obj3=Mysql.singleton()

obj4=Mysql.singleton()

print(obj3 is obj4) #True

方式二：定制元类实现单例模式

import settings

class Mymeta(type):

def __init__(self,name,bases,dic): #定义类Mysql时就触发

# 事先先从配置文件中取配置来造一个Mysql的实例出来

self.__instance = object.__new__(self) # 产生对象

self.__init__(self.__instance, settings.HOST, settings.PORT) # 初始化对象

def __call__(self, *args, **kwargs): #Mysql(...)时触发

if args or kwargs: # args或kwargs内有值

obj=object.__new__(self)

self.__init__(obj,*args,**kwargs)

return obj

return self.__instance

class Mysql(metaclass=Mymeta):

def __init__(self,host,port):

self.host=host

self.port=port

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

obj2=Mysql()

obj3=Mysql()

print(obj1 is obj2 is obj3)

obj4=Mysql('1.1.1.4',3307)

方式三:定义一个装饰器实现单例模式

import settings

def singleton(cls): #cls=Mysql

_instance=cls(settings.HOST,settings.PORT)

def wrapper(*args,**kwargs):

if args or kwargs:

obj=cls(*args,**kwargs)

return obj

return _instance

return wrapper

@singleton # Mysql=singleton(Mysql)

class Mysql:

def __init__(self,host,port):

self.host=host

self.port=port

obj1=Mysql()

obj2=Mysql()

obj3=Mysql()

print(obj1 is obj2 is obj3) #True

obj4=Mysql('1.1.1.3',3307)

obj5=Mysql('1.1.1.4',3308)

print(obj3 is obj4) #False　　

Python中的元类(metaclass)

一、什么是元类

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

那么class关键字底层的做了哪些事?

三、到底什么是元类

四、自定义元类控制类的创建

五、元类冲突

六、元类的应用

七、在Python当中，call,new,init三者之间的关系

八、练习：

1、在元类中控制把自定义类的数据属性都变成大写

2、在元类中控制自定义的类不使用init方法完成以下

3、在元类中控制自定义的类产生的对象相关的属性全部为隐藏属性

4、基于元类实现单例模式

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Python中的元类(metaclass)

一、什么是元类

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

那么class关键字底层的做了哪些事?

三、到底什么是元类

四、 自定义元类控制类的创建

五、元类冲突

六、元类的应用

七、在Python当中，__call__,__new__,__init__三者之间的关系

八、练习：

1、在元类中控制把自定义类的数据属性都变成大写

2、在元类中控制自定义的类不使用__init__方法完成以下

3、在元类中控制自定义的类产生的对象相关的属性全部为隐藏属性

4、基于元类实现单例模式

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

四、自定义元类控制类的创建

七、在Python当中，call,new,init三者之间的关系

八、练习：　　

2、在元类中控制自定义的类不使用init方法完成以下

3、在元类中控制自定义的类产生的对象相关的属性全部为隐藏属性　　