3.2 深入理解Python元类


3.2.1 类是如何产生的

类是如何产生?

这个问题肯定很傻。实则不然,很多初学者只知道使用继承的表面形式来创建一个类,却不知道其内部真正的创建是由type来创建的。

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

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

3.2.2 如何使用type创建类

首先,type()需要接收三个参数

1. 类的名称,若不指定,也要传入空字符串:""
2. 父类,注意以tuple的形式传入,若没有父类也要传入空tuple:(),默认继承object
3. 绑定的方法或属性,注意以dict的形式传入

来看个例子

# 准备一个基类(父类)
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.2.3 理解什么是元类

什么是类?可能谁都知道,类就是用来创建对象的「模板」。

那什么是元类呢?一句话通俗来说,元类就是创建类的「模板」。

为什么type能用来创建类?因为它本身是一个元类。使用元类创建类,那就合理了。

type是Python在背后用来创建所有类的元类,我们熟知的类的始祖 object 也是由type创建的。更有甚者,连type自己也是由type自己创建的,这就过份了。

>>> type(type)
<class 'type'>

>>> type(object)
<class 'type'>

>>> type(int)
<class 'type'>

>>> type(str)
<class 'type'>

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

str:用来创建字符串对象的类。
int:是用来创建整数对象的类。
type:是用来创建类对象的类。

反过来看

一个实例的类型,是类
一个类的类型,是元类
一个元类的类型,是type

写个简单的小示例来验证下

# Python3.7
>>> 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'>

下面再来看一个稍微完整的

# 注意要从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__

在这里可以借助 「单例的实现」举一个例子,你就清楚了

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)

验证结果

>>> u1 = User('wangbm1')
cls:User
====1====
====2====
====3====
>>> u1.age = 20
>>> u2 = User('wangbm2')
cls:User
====1====
>>> u2.age
20
>>> u1 is u2
True

3.3.4 使用元类的意义

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

元类有啥用,用我通俗的理解,元类的作用过程:

  1. 拦截类的创建

  2. 拦截下后,进行修改

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

所以,很明显,为什么要用它呢?不要它会怎样?

使用元类,是要对类进行定制修改。使用元类来动态生成元类的实例,而99%的开发人员是不需要动态修改类的,因为这应该是框架才需要考虑的事。

但是,这样说,你一定不会服气,到底元类用来干什么?其实元类的作用就是创建API,一个最典型的应用是 Django ORM

3.3.5 元类实战:ORM

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

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

class User(BaseModel):
    id = IntField('id')
    name = StrField('username')
    email = StrField('email')
    password = StrField('password')

    class Meta:
        db_table = "user"

如果我们要插入一条数据,我们只需这样做

# 实例化成一条记录
u = User(id=20180424, name="xiaoming",
         email="xiaoming@163.com", password="abc123")

# 保存这条记录
u.save()

通常用户层面,只需要懂应用,就像上面这样操作就可以了。

但是今天我并不是来教大家如何使用ORM,我们是用来探究ORM内部究竟是如何实现的。我们也可以自己写一个简易的ORM。

从上面的User类中,我们看到StrFieldIntField,从字段意思上看,我们很容易看出这代表两个字段类型。字段名分别是id,username,email,password

StrFieldIntField在这里的用法,叫做属性描述符。 简单来说呢,属性描述符可以实现对属性值的类型,范围等一切做约束,意思就是说变量id只能是int类型,变量name只能是str类型,否则将会抛出异常。

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

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

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

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

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)

3.2.6 __new__ 有什么用?

在没有元类的情况下,每次创建实例,在先进入 __init__ 之前都会先进入 __new__

class User:
    def __new__(cls, *args, **kwargs):
        print("in BaseClass")
        return super().__new__(cls)

    def __init__(self, name):
        print("in User")
        self.name = name

使用如下

>>> u = User('wangbm')
in BaseClass
in User
>>> u.name
'wangbm'

在有元类的情况下,每次创建类时,会都先进入 元类的 __new__ 方法,如果你要对类进行定制,可以在这时做一些手脚。

综上,元类的__new__和普通类的不一样:

  • 元类的__new__ 在创建类时就会进入,它可以获取到上层类的一切属性和方法,包括类名,魔法方法。

  • 而普通类的__new__ 在实例化时就会进入,它仅能获取到实例化时外界传入的属性。