Python进阶之元类
目录
什么是元类？
元类的调用流程
根据类自定义元类
__new__方法以及参数----------cls
----------name
----------bases
----------attrs
__call__方法生成对象的完整代码
什么是元类？
在python面向对象中，我们知道所有的新式类都会继承object类，但是object类又是从何而来呢？是否所有的类在构建之前都会有一个框架呢？
为了方便理解我们直接上代码：
class MyClass(object):
pass
print(type(MyClass()))
# <class '__main__.MyClass'>
# 类的实例对象属于 MyClass
print(type(MyClass))
# <class 'type'>
# 发现类的对象属于 type
print(type(int))
# <class 'type'>
# 发现int类也属于 type
print(type.__base__)
# <class 'object'>
# 发现其父类是 object
根据我们已学的知识1和4不难理解，那么这个type又是什么呢？
object，class，type三者之间的关系：
-
object：object类是所有类(class)的父类，包括type类，并且object没有父类 -
class：class继承自object类，同时由type进行实例化。其中，type就是我们所要讲的元类(MetaClass) -
type：type类是所有类的类型，即为所有类(class)都可由type实例化而来，包括object类，甚至其type本身也是由它初始化的
元类的调用流程
知道了什么是元类，那么他的调用流程也必然是我们需要知道的
在我们平时构造类时，类就是实例化对象的模板，__init__初始化的则是对象的属性
那么相同的，类是由元类(MetaClass)创建的，那么元类便是类的模版
大致的调用流程图解：
根据类自定义元类
class MyMeta(type):
def __new__(cls, name, bases, attrs):
# 在类创建之前执行一些操作
# 可以修改类的属性和方法
# 可以添加额外的属性和方法
return super().__new__(cls, name, bases, attrs)
class MyClass(metaclass=MyMeta):
pass
在python中我们需要用到__new__()特殊方法来在对象创建之前让其经过自定义元类MyMeta(type)调用
大白话就是我们自建了一个元类，并且继承type以便调用它的特殊方法，上面的代码中我们重写了__new()__方法，接下来我们只需要在方法中对参数(cls, name, bases, attrs)进行操作即可
__new__方法以及参数
所有参数名
cls
class MyMeta(type):
def __new__(cls, name, bases, attrs):
print(cls) # 输出:<class '__main__.MyMeta'>
print(cls.__name__) # 输出:MyMeta
return super().__new__(cls, name, bases, attrs)
class My(object, metaclass=MyMeta):
def __init__(self, name):
self.name = name
m = My('张三')
name
class MyMeta(type):
def __new__(cls, name, bases, attrs):
print(name) # 输出:MyClass
if len(name) > 3:
print("你好", end='')
return super().__new__(cls, name, bases, attrs)
class MyClass(object, metaclass=MyMeta):
def __init__(self, name):
self.name = name
m = MyClass('张三')
print(m.name)
# MyClass
# 你好张三
bases
class MyMeta(type):
def __new__(cls, name, bases, attrs):
print(bases) # 输出:(<class '__main__.Parent'>,)
return super().__new__(cls, name, bases, attrs)
class Parent:
pass
class MyClass(Parent, metaclass=MyMeta):
def __init__(self, name):
self.name = name
m = MyClass('张三')
attrs
class MyMeta(type):
def __new__(cls, name, bases, attrs):
# 修改属性
attrs['modified_attr'] = 100 # 新增键modified_attr
print(attrs) # {'__module__': '__main__', '__qualname__': 'MyClass', 'original_method': <function MyClass.original_method at 0x000001B3618A1800>, 'modified_attr': 100}
# 修改方法
def modified_method(self):
return "方法2"
attrs['modified_method'] = modified_method
print(attrs)
return super().__new__(cls, name, bases, attrs)
class MyClass(metaclass=MyMeta):
def original_method(self):
return "方法1"
# 测试示例
my_obj = MyClass()
print(my_obj.modified_attr) # 输出: 100
print(my_obj.original_method()) # 输出: 方法1
print(my_obj.modified_method()) # 输出: 方法2
__call__方法
在实例化对象的时候，会自动触发类中的__new__方法执行其中的代码，并且触发__init__方法进行初始化属性。那么此时不得不思考一个问题：为什么类会先调用__new__再调用__init__？是谁在控制这个流程？
-----__call__
调用类就是调用类的 __call__方法，类调用后的运行逻辑，其实都是 call 方法来控制的
__call__方法可以将函数或者类都转换成可调用对象，也就是我们平时调用函数时在后面加的括号：
# 函数中使用__call__
def text():
print("你好")
text() # 你好
text.__call__() # 你好
# 类中使用__call__
class MyClass():
def __call__(self, *args, **kwargs):
print('你好')
my_obj = MyClass()
my_obj() # 你好
在元类中我们可以利用重写__call__方法来满足我们特定的需求：
class MyMeta(type):
def __call__(cls, *args, **kwargs):
print("重写__call__方法")
return 123123
class MyClass(metaclass=MyMeta):
pass
my_obj = MyClass()
print(my_obj)# 输出：123123
# 用__call__方法判断类名是否为大写
class MyMeta(type):
def __call__(cls, *args, **kwargs):
if cls.__name__.isupper():
print('is upper')
else:
print('is not upper')
return super().__call__(*args, **kwargs)
class MYCLASS(metaclass=MyMeta):
pass
class myclass(metaclass=MyMeta):
pass
my_obj = MYCLASS() # is upper
my_obj2 = myclass() # is not upper
__call__的执行流程：
生成对象的完整代码
class MyMeta(type):
def __new__(cls, *args, **kwargs):
print("type调用了MyMeta的__new__方法，并且返回了一个对象，该对象即MyClass")
return super().__new__(cls, *args, **kwargs)
def __call__(cls, *args, **kwargs):
print("这里调用了MyMeta的__call__方法，在这里可以对MyClass生成的对象a进行额外的操作，最终返回初始化好的对象a")
instance = super().__call__(*args, **kwargs)
return instance
def __init__(cls, what, bases=None, dict=None):
print("当前接受的cls对象即MyClass，这里不重写直接继承并初始化数据")
super(MyMeta, cls).__init__(what, bases, dict)
class MyClass(metaclass=MyMeta):
def __init__(self, age, name=None):
self.name = name
# 创建一个可调用对象
a = MyClass(18, name='张三')
t__(cls, what, bases=None, dict=None):
print("当前接受的cls对象即MyClass，这里不重写直接继承并初始化数据")
super(MyMeta, cls).__init__(what, bases, dict)
class MyClass(metaclass=MyMeta):
def __init__(self, age, name=None):
self.name = name
# 创建一个可调用对象
a = MyClass(18, name='张三')
