# 7.10 【进阶】神奇的元类编程(metaclass)
## 1. 类是如何产生的
类是如何产生?这个问题也许你会觉得很傻。
实则不然,很多初学者只知道使用继承的表面形式来创建一个类,却不知道其内部真正的创建是由 `type` 来创建的。
type?这不是判断对象类型的函数吗?
是的,type通常用法就是用来判断对象的类型。但除此之外,他最大的用途是用来动态创建类。当Python扫描到class的语法的时候,就会调用type函数进行类的创建。
## 2. 如何使用type创建类
首先,`type()` 需要接收三个参数
1. 类的名称,若不指定,也要传入空字符串:`""`
2. 父类,注意以tuple的形式传入,若没有父类也要传入空tuple:`()`,默认继承object
3. 绑定的方法或属性,注意以dict的形式传入
来看个例子
```python
# 准备一个基类(父类)
class BaseClass:
def talk(self):
print("i am people")
# 准备一个方法
def say(self):
print("hello")
# 使用type来创建User类
User = type("User", (BaseClass, ), {"name":"user", "say":say})
```
## 3. 理解什么是元类
什么是类?可能谁都知道,类就是用来创建对象的「模板」。
那什么是元类呢?一句话通俗来说,元类就是创建类的「模板」。
为什么type能用来创建类?因为它本身是一个元类。使用元类创建类,那就合理了。
type是Python在背后用来创建所有类的元类,我们熟知的类的始祖 `object` 也是由type创建的。更有甚者,连type自己也是由type自己创建的,这就过份了。
```python
>>> type(type)
<class 'type'>
>>> type(object)
<class 'type'>
>>> type(int)
<class 'type'>
>>> type(str)
<class 'type'>
```
如果要形象的来理解的话,就看下面这三行话。
- str:用来创建字符串对象的类。
- int:是用来创建整数对象的类。
- type:是用来创建类对象的类。
反过来看
- 一个实例的类型,是类
- 一个类的类型,是元类
- 一个元类的类型,是type
写个简单的小示例来验证下
```python
>>> class MetaPerson(type):
... pass
...
>>> class Person(metaclass=MetaPerson):
... pass
...
>>> Tom = Person()
>>> print(type(Tom))
<class '__main__.Person'>
>>> print(type(Tom.__class__))
<class '__main__.MetaPerson'>
>>> print(type(Tom.__class__.__class__))
<class 'type'>
```
下面再来看一个稍微完整的
```python
# 注意要从type继承
class BaseClass(type):
def __new__(cls, *args, **kwargs):
print("in BaseClass")
return super().__new__(cls, *args, **kwargs)
class User(metaclass=BaseClass):
def __init__(self, name):
print("in User")
self.name = name
# in BaseClass
user = User("wangbm")
# in User
```
综上,我们知道了类是元类的实例,所以在创建一个普通类时,其实会走元类的 `__new__`。
同时,我们又知道在类里实现了 `__call__` 就可以让这个类的实例变成可调用。
所以在我们对普通类进行实例化时,实际是对一个元类的实例(也就是普通类)进行直接调用,所以会走进元类的 `__call__`
在这里可以借助 「单例的实现」举一个例子,你就清楚了
```python
class MetaSingleton(type):
def __call__(cls, *args, **kwargs):
print("cls:{}".format(cls.__name__))
print("====1====")
if not hasattr(cls, "_instance"):
print("====2====")
cls._instance = type.__call__(cls, *args, **kwargs)
return cls._instance
class User(metaclass=MetaSingleton):
def __init__(self, *args, **kw):
print("====3====")
for k,v in kw:
setattr(self, k, v)
```
验证结果
```python
>>> u1 = User('wangbm1')
cls:User
====1====
====2====
====3====
>>> u1.age = 20
>>> u2 = User('wangbm2')
cls:User
====1====
>>> u2.age
20
>>> u1 is u2
True
```
## 4. 使用元类的意义
正常情况下,我们都不会使用到元类。但是这并不意味着,它不重要。假如某一天,我们需要写一个框架,很有可能就需要你对元类要有进一步的研究。
元类有啥用,用我通俗的理解,元类的作用过程:
1. 拦截类的创建
2. 拦截下后,进行修改
3. 修改完后,返回修改后的类
所以,很明显,为什么要用它呢?不要它会怎样?
使用元类,是要对类进行定制修改。使用元类来动态生成元类的实例,而99%的开发人员是不需要动态修改类的,因为这应该是框架才需要考虑的事。
但是,这样说,你一定不会服气,到底元类用来干什么?其实元类的作用就是`创建API`,一个最典型的应用是 `Django ORM`。
## 5. 元类实战:ORM
使用过Django ORM的人都知道,有了ORM,使得我们操作数据库,变得异常简单。
ORM的一个类(User),就对应数据库中的一张表。id,name,email,password 就是字段。
```python
class User(BaseModel):
id = IntField('id')
name = StrField('username')
email = StrField('email')
password = StrField('password')
class Meta:
db_table = "user"
```
如果我们要插入一条数据,我们只需这样做
```python
# 实例化成一条记录
u = User(id=20180424, name="xiaoming",
email="xiaoming@163.com", password="abc123")
# 保存这条记录
u.save()
```
通常用户层面,只需要懂应用,就像上面这样操作就可以了。
但是今天我并不是来教大家如何使用ORM,我们是用来探究ORM内部究竟是如何实现的。我们也可以自己写一个简易的ORM。
从上面的`User`类中,我们看到`StrField`和`IntField`,从字段意思上看,我们很容易看出这代表两个字段类型。字段名分别是`id`,`username`,`email`,`password`。
`StrField`和`IntField`在这里的用法,叫做`属性描述符`。
简单来说呢,`属性描述符`可以实现对属性值的类型,范围等一切做约束,意思就是说变量id只能是int类型,变量name只能是str类型,否则将会抛出异常。
那如何实现这两个`属性描述符`呢?请看代码。
```python
import numbers
class Field:
pass
class IntField(Field):
def __init__(self, name):
self.name = name
self._value = None
def __get__(self, instance, owner):
return self._value
def __set__(self, instance, value):
if not isinstance(value, numbers.Integral):
raise ValueError("int value need")
self._value = value
class StrField(Field):
def __init__(self, name):
self.name = name
self._value = None
def __get__(self, instance, owner):
return self._value
def __set__(self, instance, value):
if not isinstance(value, str):
raise ValueError("string value need")
self._value = value
```
我们看到`User`类继承自`BaseModel`,这个`BaseModel`里,定义了数据库操作的各种方法,譬如我们使用的`save`函数,也可以放在这里面的。所以我们就可以来写一下这个`BaseModel`类
```python
class BaseModel(metaclass=ModelMetaClass):
def __init__(self, *args, **kw):
for k,v in kw.items():
# 这里执行赋值操作,会进行数据描述符的__set__逻辑
setattr(self, k, v)
return super().__init__()
def save(self):
db_columns=[]
db_values=[]
for column, value in self.fields.items():
db_columns.append(str(column))
db_values.append(str(getattr(self, column)))
sql = "insert into {table} ({columns}) values({values})".format(
table=self.db_table, columns=','.join(db_columns),
values=','.join(db_values))
pass
```
从`BaseModel`类中,save函数里面有几个新变量。
1. fields: 存放所有的字段属性
2. db_table:表名
我们思考一下这个`u`实例的创建过程:
`type` -> `ModelMetaClass` -> `BaseModel` -> `User` -> `u`
这里会有几个问题。
* init的参数是User实例时传入的,所以传入的id是int类型,name是str类型。看起来没啥问题,若是这样,我上面的数据描述符就失效了,不能起约束作用。所以我们希望init接收到的id是IntField类型,name是StrField类型。
* 同时,我们希望这些字段属性,能够自动归类到fields变量中。因为,做为BaseModel,它可不是专门为User类服务的,它还要兼容各种各样的表。不同的表,表里有不同数量,不同属性的字段,这些都要能自动类别并归类整理到一起。这是一个ORM框架最基本的。
* 我们希望对表名有两种选择,一个是User中若指定Meta信息,比如表名,就以此为表名,若未指定就以类名的小写 做为表名。虽然BaseModel可以直接取到User的db_table属性,但是如果在数据库业务逻辑中,加入这段复杂的逻辑,显然是很不优雅的。
上面这几个问题,其实都可以通过元类的`__new__`函数来完成。
下面就来看看,如何用元类来解决这些问题呢?请看代码。
```python
class ModelMetaClass(type):
def __new__(cls, name, bases, attrs):
if name == "BaseModel":
# 第一次进入__new__是创建BaseModel类,name="BaseModel"
# 第二次进入__new__是创建User类及其实例,name="User"
return super().__new__(cls, name, bases, attrs)
# 根据属性类型,取出字段
fields = {k:v for k,v in attrs.items() if isinstance(v, Field)}
# 如果User中有指定Meta信息,比如表名,就以此为准
# 如果没有指定,就默认以 类名的小写 做为表名,比如User类,表名就是user
_meta = attrs.get("Meta", None)
db_table = name.lower()
if _meta is not None:
table = getattr(_meta, "db_table", None)
if table is not None:
db_table = table
# 注意原来由User传递过来的各项参数attrs,最好原模原样的返回,
# 如果不返回,有可能下面的数据描述符不起作用
# 除此之外,我们可以往里面添加我们自定义的参数
attrs["db_table"] = db_table
attrs["fields"] = fields
return super().__new__(cls, name, bases, attrs)
```
## 6. \__new__ 有什么用?
在没有元类的情况下,每次创建实例,在先进入 `__init__` 之前都会先进入 ` __new__`。
```python
class User:
def __new__(cls, *args, **kwargs):
print("in BaseClass")
return super().__new__(cls)
def __init__(self, name):
print("in User")
self.name = name
```
使用如下
```python
>>> u = User('wangbm')
in BaseClass
in User
>>> u.name
'wangbm'
```
在有元类的情况下,每次创建类时,会都先进入 元类的 `__new__` 方法,如果你要对类进行定制,可以在这时做一些手脚。
综上,元类的`__new__`和普通类的不一样:
- 元类的`__new__` 在创建类时就会进入,它可以获取到上层类的一切属性和方法,包括类名,魔法方法。
- 而普通类的`__new__` 在实例化时就会进入,它仅能获取到实例化时外界传入的属性。
## 附录:参考文章
- [Python Cookbook - 元编程](http://python3-cookbook.readthedocs.io/zh_CN/latest/chapters/p09_meta_programming.html)
- [深刻理解Python中的元类](http://blog.jobbole.com/21351/)
- 第一章:安装运行
- 1.1 【环境】快速安装 Python 解释器
- 1.2 【环境】Python 开发环境的搭建
- 1.3 【基础】两种运行 Python 程序方法
- 第二章:数据类型
- 2.1 【基础】常量与变量
- 2.2 【基础】字符串类型
- 2.3 【基础】整数与浮点数
- 2.4 【基础】布尔值:真与假
- 2.5 【基础】学会输入与输出
- 2.6 【基础】字符串格式化
- 2.6 【基础】运算符(超全整理)
- 第三章:数据结构
- 3.1 【基础】列表
- 3.2 【基础】元组
- 3.3 【基础】字典
- 3.4 【基础】集合
- 3.5 【基础】迭代器
- 3.6 【基础】生成器
- 第四章:控制流程
- 4.1 【基础】条件语句:if
- 4.2 【基础】循环语句:for
- 4.3 【基础】循环语句:while
- 4.4 【进阶】五种推导式
- 第五章:学习函数
- 5.1 【基础】普通函数
- 5.2 【基础】匿名函数
- 5.3 【基础】高阶函数
- 5.4 【基础】反射函数
- 5.5 【基础】偏函数
- 5.6 【进阶】泛型函数
- 5.7 【基础】变量的作用域
- 5.8 【进阶】上下文管理器
- 5.9 【进阶】装饰器的六种写法
- 第六章:错误异常
- 6.1 【基础】什么是异常?
- 6.2 【基础】如何抛出和捕获异常?
- 6.3 【基础】如何自定义异常?
- 6.4 【进阶】如何关闭异常自动关联上下文?
- 6.5 【进阶】异常处理的三个好习惯
- 第七章:类与对象
- 7.1 【基础】类的理解与使用
- 7.2 【基础】静态方法与类方法
- 7.3 【基础】私有变量与私有方法
- 7.4 【基础】类的封装(Encapsulation)
- 7.5 【基础】类的继承(Inheritance)
- 7.6 【基础】类的多态(Polymorphism)
- 7.7 【基础】类的 property 属性
- 7.8 【进阶】类的 Mixin 设计模式
- 7.9 【进阶】类的魔术方法(超全整理)
- 7.10 【进阶】神奇的元类编程(metaclass)
- 7.11 【进阶】深藏不露的描述符(Descriptor)
- 第八章:包与模块
- 8.1 【基础】什么是包、模块和库?
- 8.2 【基础】安装第三方包的八种方法
- 8.3 【基础】导入单元的构成
- 8.4 【基础】导入包的标准写法
- 8.5 【进阶】常规包与空间命名包
- 8.6 【进阶】花式导包的八种方法
- 8.7 【进阶】包导入的三个冷门知识点
- 8.8 【基础】pip 的超全使用指南
- 8.9 【进阶】理解模块的缓存
- 8.10 【进阶】理解查找器与加载器
- 8.11 【进阶】实现远程导入模块
- 8.12 【基础】分发工具:distutils和setuptools
- 8.13 【基础】源码包与二进制包有什么区别?
- 8.14 【基础】eggs与wheels 有什么区别?
- 8.15 【进阶】超详细讲解 setup.py 的编写
- 8.16 【进阶】打包辅助神器 PBR 是什么?
- 8.17 【进阶】开源自己的包到 PYPI 上
- 第九章:调试技巧
- 9.1 【调试技巧】超详细图文教你调试代码
- 9.2 【调试技巧】PyCharm 中指定参数调试程序
- 9.3 【调试技巧】PyCharm跑完后立即进入调试模式
- 9.4 【调试技巧】脚本报错后立即进入调试模式
- 9.5 【调试技巧】使用 PDB 进行无界面调试
- 9.6 【调试技巧】如何调试已经运行的程序?
- 9.7 【调试技巧】使用 PySnopper 调试疑难杂症
- 9.8 【调试技巧】使用 PyCharm 进行远程调试
- 第十章:并发编程
- 10.1 【并发编程】从性能角度初探并发编程
- 10.2 【并发编程】创建多线程的几种方法
- 10.3 【并发编程】谈谈线程中的“锁机制”
- 10.4 【并发编程】线程消息通信机制
- 10.5 【并发编程】线程中的信息隔离
- 10.6 【并发编程】线程池创建的几种方法
- 10.7 【并发编程】从 yield 开始入门协程
- 10.8 【并发编程】深入理解yield from语法
- 10.9 【并发编程】初识异步IO框架:asyncio 上篇
- 10.10 【并发编程】深入异步IO框架:asyncio 中篇
- 10.11 【并发编程】实战异步IO框架:asyncio 下篇
- 10.12 【并发编程】生成器与协程,你分清了吗?
- 10.14 【并发编程】浅谈线程安全那些事儿
- 第十二章:虚拟环境
- 12.1 【虚拟环境】为什么要有虚拟环境?
- 12.2 【虚拟环境】方案一:使用 virtualenv
- 12.3 【虚拟环境】方案二:使用 pipenv
- 12.4 【虚拟环境】方案三:使用 pipx
- 12.5 【虚拟环境】方案四:使用 poetry
- 第十三章:绝佳工具
- 13.1 【静态检查】mypy 的使用
- 13.2 【代码测试】pytest 的使用
- 13.3 【代码提交】pre-commit hook
- 13.4 【项目生成】cookiecutter 的使用
- 第十四章:数据可视化
- 14.1 【可视化之matplotlib】一图带你入门matplotlib
- 14.2 【可视化之matplotlib】详解六种可视化图表
- 14.3 【可视化之matplotlib】 绘制正余弦函数图象
- 14.4 【可视化之matplotlib】难点:子图与子区
- 14.5 【可视化之matplotlib】绘制酷炫的gif动态图
- 14.6 【可视化之matplotlib】自动生成图像视频
- 14.7 【可视化神器】最高级的可视化神器: plotly_express