Python进阶开发之元类编程

Photo by Joyous From Lofter

本文目录

1. 类是如何产生的

2. 如何使用type建立类

3. 理解什么是元类

4. 使用元类的意义

5. 元类实战：ORM

---

. 1. 类是如何产生的

类是如何产生？这个问题确定很傻。实则否则，不少人只知道使用继承的表面形式来建立一个类，殊不知道其内部真正的建立是由type来建立的。

type？这不是判断对象类型的函数吗？

是的，type一般用法就是用来判断对象的类型。但除此以外，他最大的用途是用来动态建立类。当Python扫描到class的语法的时候，就会调用type函数进行类的建立。

. 2. 如何使用type建立类

首先，type()须要接收三个参数

• 类的名称：若不指定，也要传入空字符串：""

• 父类：注意以tuple的形式传入，若没有父类也要传入空tuple：()，默认继承object

• 绑定的方法或属性：注意以dict的形式传入

来看个例子

 1# 准备一个基类（父类）
 2class BaseClass:
 3    def talk(self):
 4        print("i am people")
 5
 6# 准备一个方法
 7def say(self):
 8    print("hello")
 9
10# 使用type来建立User类
11User = type("User", (BaseClass, ), {"name":"user", "say":say})

. 3. 理解什么是元类

什么是类？可能谁都知道，类就是用来建立对象的「模板」。

那什么是元类呢？一句话通俗来讲，元类就是建立类的「模板」。

为何type能用来建立类？由于它自己是一个元类。使用元类建立类，那就合理了。

type是Python在背后用来建立全部类的元类，咱们熟知的类的始祖object 也是由type建立的。更有甚者，连type本身也是由type本身建立的，这就过份了。

1>>> type(type)
2<class 'type'>
3>>> type(object
4<class 'type'>
5>>> type(int)
6<class 'type'>
7>>> type(str)
8<class 'type'>

若是要形象的来理解的话，就看下面这三行话。

1str：用来建立字符串对象的类。
2int：是用来建立整数对象的类。
3type：是用来建立类对象的类。

反过来看

1一个实例的类型，是类
2一个类的类型，是元类
3一个元类的类型，是type

来看下实例

 1# Python3.7
 2>>> class MetaPerson(type):
 3...     pass
 4...
 5>>> class Person(metaclass=MetaPerson):
 6...     pass
 7...
 8>>> Tom = Person()
 9>>> print(type(Tom))
10<class '__main__.Person'>
11>>> print(type(Tom.__class__))
12<class '__main__.MetaPerson'>
13>>> print(type(Tom.__class__.__class__))
14<class 'type'>

上面是一个简单的示例。

下面看一个稍微完整的

 1# 注意要从type继承
 2class BaseClass(type):
 3    def __new__(cls, *args, **kwargs):
 4        print("in BaseClass")
 5        return super().__new__(cls, *args, **kwargs)
 6
 7class User(metaclass=BaseClass):
 8    def __init__(self, name):
 9        self.name = name
10
11user = User("wangbm")

. 4. 使用元类的意义

正常状况下，咱们都不会使用到元类。可是这并不意味着，它不重要。假如某一天，咱们须要写一个框架，颇有可能就须要用到元类。

可是，为何要用它呢？不要它会怎样？

通过个人总结，元类的做用过程以下

1. 拦截类的建立

2. 拦截下后，进行修改

3. 修改完后，返回修改后的类

很明显，使用元类，是要对类进行定制修改。使用元类来动态生成元类的实例，而99%的开发人员是不须要动态修改类的，由于这应该是框架才须要考虑的事。

可是，这样说，你必定不会服气，到底元类用来干什么？其实元类的做用就是建立API，一个最典型的应用是 Django ORM。

. 5. 元类实战：ORM

使用过Django ORM的人都知道，有了ORM，使得咱们操做数据库，变得异常简单。

ORM的一个类(User)，就对应数据库中的一张表。id,name,email,password 就是字段。

1class User(BaseModel):
2    id = IntField('id')
3    name = StrField('username')
4    email = StrField('email')
5    password = StrField('password')
6
7    class Meta:
8        db_table = "user"

若是咱们要插入一条数据，咱们只需这样作

1# 实例化成一条记录
2u = User(id=20180424, name="xiaoming", 
3         email="xiaoming@163.com", password="abc123")
4
5# 保存这条记录
6u.save()

一般用户层面，只须要懂应用，就像上面这样操做就能够了。

可是今天我并非来教你们如何使用ORM，咱们是用来探究ORM内部到底是如何实现的。咱们也能够本身写一个简易的ORM。

从上面的User类中，咱们看到StrField和IntField，从字段意思上看，咱们很容易看出这表明两个字段类型。字段名分别是id,username,email,password。

StrField和IntField在这里的用法，叫作属性描述符，若是对这个不了解的能够查看文章底部的参考文章，也是我写的。
简单来讲呢，属性描述符能够实现对属性值的类型，范围等一切作约束，意思就是说变量id只能是int类型，变量name只能是str类型，不然将会抛出异常。

那如何实现这两个属性描述符呢？请看代码。

 1import numbers
 2
 3class Field:
 4    pass
 5
 6class IntField(Field):
 7    def __init__(self, name):
 8        self.name = name
 9        self._value = None
10
11    def __get__(self, instance, owner):
12        return self._value
13
14    def __set__(self, instance, value):
15        if not isinstance(value, numbers.Integral):
16            raise ValueError("int value need")
17        self._value = value
18
19class StrField(Field):
20    def __init__(self, name):
21        self.name = name
22        self._value = None
23
24    def __get__(self, instance, owner):
25        return self._value
26
27    def __set__(self, instance, value):
28        if not isinstance(value, str):
29            raise ValueError("string value need")
30        self._value = value

咱们看到User类继承自BaseModel，这个BaseModel里，定义了数据库操做的各类方法，譬如咱们使用的save函数，也能够放在这里面的。因此咱们就能够来写一下这个BaseModel类

 1class BaseModel(metaclass=ModelMetaClass):
 2    def __init__(self, *args, **kw):
 3        for k,v in kw.items():
 4            # 这里执行赋值操做，会进行数据描述符的__set__逻辑
 5            setattr(self, k, v)
 6        return super().__init__()
 7
 8    def save(self):
 9        db_columns=[]
10        db_values=[]
11        for column, value in self.fields.items():
12            db_columns.append('`'+str(column)+'`')
13            _value=str(getattr(self, column))
14            db_values.append('\''+_value+'\'')
15        sql = "insert into `{table}` ({columns}) values({values})".format(
16                table=self.db_table,
17                columns=','.join(db_columns),
18                values=','.join(db_values))
19        # mysql_execute 函数能够本身写。调用驱动插入到数据库
20        # 查看完整代码请点击文章底部查看原文
21        mysql_execute(sql)

从BaseModel类中，save函数里面有几个新变量，

1. fields: 存放全部的字段属性

2. db_table：表名

注意：上面代码中class BaseModel(metaclass=ModelMetaClass)请替换成class BaseModel(object) 再阅读。这样更贴合思考顺序。

咱们思考一下这个u实例的建立过程：

type -> object -> 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__函数来完成。

元类的__new__和普通类的可不同，元类的__new__，能够获取到上层类的一切属性和方法，包括类名，魔法方法。
而普通类的__new__ 只能获取到实例化时外界传入的属性。

下面就来看看，如何用元类来解决这些问题呢？请看代码。

 1class ModelMetaClass(type):
 2    def __new__(cls, name, bases, attrs):
 3        if name == "BaseModel":
 4            # 第一次进入__new__是建立BaseModel类，name="BaseModel"
 5            # 第二次进入__new__是建立User类及其实例，name="User"
 6            return super().__new__(cls, name, bases, attrs)
 7
 8        # 根据属性类型，取出字段
 9        fields = {k:v for k,v in attrs.items() if isinstance(v, Field)}
10
11        # 若是User中有指定Meta信息，好比表名，就以此为准
12        # 若是没有指定，就默认以 类名的小写 作为表名，好比User类，表名就是user
13        _meta = attrs.get("Meta", None)
14        db_table = name.lower()
15        if _meta is not None:
16            table = getattr(_meta, "db_table", None)
17            if table is not None:
18                db_table = table
19
20        # 注意原来由User传递过来的各项参数attrs，最好原模原样的返回，
21        # 若是不返回，有可能下面的数据描述符不起做用
22        # 除此以外，咱们能够往里面添加咱们自定义的参数
23        attrs["db_table"] = db_table
24        attrs["fields"] = fields
25        return super().__new__(cls, name, bases, attrs)

至此，咱们的简易ORM就已经成型。