Photo byJoyous From Lofter

本文目录

类是如何产生的

如何使用type创建类

理解什么是元类

使用元类的意义

元类实战：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

3>>> type(object

4

5>>> type(int)

6

7>>> type(str)

8

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

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

11>>> print(type(Tom.__class__))

12

13>>> print(type(Tom.__class__.__class__))

14

上面是一个简单的示例。

下面看一个稍微完整的

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. 使用元类的意义

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

但是，为什么要用它呢？不要它会怎样？

经过我的总结，元类的作用过程如下

拦截类的创建

拦截下后，进行修改

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

很明显，使用元类，是要对类进行定制修改。使用元类来动态生成元类的实例，而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函数里面有几个新变量，

fields: 存放所有的字段属性

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就已经成型。