17-Python类机制深度解析-回顾Python中的对象模型

楔子

这一次我们就来看看Python中类是怎么实现的，我们知道C不是一个面向对 象语言，而Python却是一个面向对象的语言，那么在Python的底层，是如何使用C来支持Python实现面向对象的功能呢？带着这些疑问，我们下面开始剖析python中类的实现机制。另外，在Python2中存在着经典类(classic class)和新式类(new style class)，但是到Python3中，经典类已经消失了。并且python2官方都不维护了，因此我们这一章只会介绍新式类。

另外关于类，我们在最开始介绍对象关系模型的时候其实说了不少，这里会再简单温习一遍。

Python中的对象模型

我们在最开始介绍对象的时候就说了，在面向对象的理论中，有两个核心的概念：类和实例。类可以看成是一个模板，那么实例就是根据这个模板创建出来的对象。可以想象成docker的镜像和容器。但是在Python中，一切都是对象，所以类和实例都是对象，类叫做类对象，实例叫做实例对象。如果想用大白话来描述清楚的话，这无疑是一场灾难，我们还是需要使用一些专业术语来描述：

首先我们这里把python中的对象分为三种：

  • 内建对象: Python中的内建对象、或者叫内置对象, 比如int、str、list、type、object等等;
  • class对象: 程序员通过Python中的class关键字定义的类。当然后面我们也会把内建对象和class对象统称为类对象;
  • 实例对象：由类对象(内建对象或者class对象)创建的实例;

而对象之间存在着以下两种关系：

  • is-kind-of: 对应面向对象理论中父类和子类之间的关系;
  • is-instance-of: 对应面向对象理论中类和实例之间的关系;
1
2
3
4
5
6
7
8
class Girl(object):

    def say(self):
        return "まつりさんじょう"


girl = Girl()
print(girl.say())  # まつりさんじょう

这段代码中便包含了上面的三种对象：object(内建对象)，Girl(class对象)，girl(实例对象)。显然Girl和object之间是is-kind-of关系，即object是Girl的父类。另外值得一提的是，在python3中所有定义的类都是默认继承自object，即便我们这里不显式继承object，也会默认继承的，为了说明，我们就写上了。除了object是Girl的父类，我们还能看出girl和Girl存在is-instance-of关系，即girl是Girl的实例。当然如果再进一步的话，girl和object之间也存在is-instance-of关系，girl也是object的实例。

1
2
3
4
5
6
7
8
9
10
11
12
13
class Girl(object):

    def say(self):
        return "まつりさんじょう"


girl = Girl()
print(girl.say())  # まつりさんじょう

print(issubclass(Girl, object))  # True
print(type(girl))  # <class '__main__.Girl'>
print(isinstance(girl, Girl))  # True
print(isinstance(girl, object))  # True

girl是Girl这个类实例化得到的，所以type(girl)得到的是类对象Girl，但girl也是object的实例对象，因为Girl继承了object，至于这其中的原理，我们会慢慢介绍到。

Python中的类型检测

Python提供了一些方法可以探测这些关系，除了我们上面的type之外，还可以使用对象的__class__属性探测一个对象和其它的哪些对象之间存在is-instance-of关系，而通过对象的__bases__属性则可以探测一个对象和其它的哪些对象之间存在着is-kind-of关系。此外python还提供了两个方法issubclass和isinstance来验证两个对象之间是否存在着我们期望的关系。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Girl(object):

    def say(self):
        return "まつりさんじょう"


girl = Girl()
print(girl.say())  # まつりさんじょう

print(girl.__class__)  # <class '__main__.Girl'>
print(Girl.__class__)  # <class 'type'>
# 另外__class__是查看自己的类型是什么,也就是生成自己的类。
# 而在介绍Python对象的时候,我们就看到了,任何一个对象都至少具备两个东西: 一个是引用计数、一个是类型
# 所以__class__在Python中，是所有的对象都具备的


# __base__只显示继承的第一个类
print(Girl.__base__)  # <class 'object'>
# __bases__会显示继承的所有类
print(Girl.__bases__)  # (<class 'object'>,)

img

关于type和object的关系，我们在最开始介绍Python中的对象模型的时候已经说过了。我们type底层的结构是PyType_Type、object底层的结构体是PyBaseObject_Type，在创建object的时候，将内部的ob_type设置成了PyType_Type；在创建type的时候，将内部的tp_base设置成为了PyBaseObject_Type。因此这两者的定义是彼此依赖的，两者是同时出现的，我们后面还会看到。

紧接着我们考察一下类Girl的行为，我们看到它支持属性设置：

1
2
3
4
5
6
7
8
9
10
class Girl(object):

    def say(self):
        return "まつりさんじょう"


print(hasattr(Girl, "name"))  # False
Girl.name = "夏色祭"
print(hasattr(Girl, "name"))  # True
print(Girl.name)  # 夏色祭

一个类都已经定义完了，我们后续还可以进行属性的添加，这在其它的静态语言中是不可能做到的。那么Python是如何做到的呢？我们说能够对于属性进行动态添加，你会想到什么？是不是字典呢？正如global名字空间一样，我们猜测类应该也有自己的属性字典，往类里面设置一些属性的时候，等价于向字典中添加一个键值对，同理其它操作也是如此。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Girl(object):

    def say(self):
        return "まつりさんじょう"


# 我们看到确实如此, 每一个类都有自己的属性字典
print(Girl.__dict__)  # {'__module__': '__main__', 'say': <function Girl.say at 0x0000015CE71E1160>, ...}

print(Girl.__dict__.get("name", "不存在"))  # 不存在
Girl.name = "夏色祭"
print(Girl.__dict__.get("name"))  # 夏色祭


# 我们看到和操作全局变量是类似的, 但是有一点需要注意: 我们不能直接通过类的属性字典来设置属性
# Girl.name = "夏色祭" 是可以的, 但是 Girl.__dict__["name"] = "夏色祭" 则不可以, 虽然这两者是等价的
try:
    Girl.__dict__["name"] = "神乐mea"
except Exception as e:
    print(e)  # 'mappingproxy' object does not support item assignment

# 但是通过字典访问是可以的

除了设置属性之外，我们还可以设置函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Girl(object):

    def say(self):
        return "まつりさんじょう"


Girl.info = lambda name, age: f"我叫{name!r}, 今年{age}岁"
print(Girl.info("神乐mea", 38))  # 我叫'神乐mea', 今年38岁

# 但是此时实例对象调用的话, 会和我们想象的不太一样
# 因为实例调用的话会将函数包装成方法(后面会重点说, 以及为什么实例调用的时候会自动将自身作为self传进去)
try:
    print(Girl().info("神乐mea", 38))
except Exception as e:
    print(e)  # <lambda>() takes 2 positional arguments but 3 were given

# 我们看到实例在调用的时候会将自身也作为参数传进去, 所以第一个参数name实际上接收的是Girl的实例对象
# 只不过第一个参数按照规范来讲应该叫做self, 但即便你起别的名字也是无所谓的
print(Girl().info(38))  # 我叫<__main__.Girl object at 0x00000164B90782B0>, 今年38岁

# 所以我们应该这么做, 将其包装成一个静态方法, 这样类和实例都可以调用了
Girl.info = staticmethod(lambda name, age: f"我叫{name!r}, 今年{age}岁")
print(Girl.info("神乐mea", 38))  # 我叫'神乐mea', 今年38岁
print(Girl().info("神乐mea", 38))  # 我叫'神乐mea', 今年38岁

此外我们还可以通过type来动态地往类里面进行属性的增加、修改和删除。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Girl(object):

    def say(self):
        return "まつりさんじょう"


print(hasattr(Girl, "say"))  # True
# 等价于delattr(Girl, "say")
type.__delattr__(Girl, "say")
print(hasattr(Girl, "say"))  # False

# 我们看到Girl这个类里面已经没有"say"这个属性或者函数了
# 事实上调用getattr、setattr、delattr等价于调用其类型对象的__getattr__、__setattr__、__delattr__

# 我们设置一个属性吧, 等价于Girl.name = "神乐mea"
setattr(Girl, "name", "神乐mea")
print(Girl.name)  # 神乐mea

所以我们说过，一个对象有哪些行为，取决于其类型对象中定义了哪些操作。此外我们通过对象的类型对象，可以动态地给该对象进行属性的设置。所以Python中所有的类型对象的类型对象都是type，通过type我们便可以控制类的生成过程，即便类已经创建完毕了，也依旧可以进行属性设置。但是注意：这些仅仅针对于我们自己自定义的类，内置的类是不行的。

1
2
3
4
5
6
7
8
9
try:
    int.name = "夏色祭"
except Exception as e:
    print(e)  # can't set attributes of built-in/extension type 'int'
    
try:
    int.__add__ = "xxx"
except Exception as e:
    print(e)  # can't set attributes of built-in/extension type 'int'

因为内建对象在解释器启动之后，就已经初始化好了。所以内建的类和使用class定义的类本质上是一样的，都是PyTypeObject对象，它们的类型都是type，但区别就是内建的类在底层是静态初始化的，我们不能进行属性的动态设置。

这里多提一句，我们看到报错信息提示：不可以设置内建类和扩展类的属性，这里的扩展类就是我们使用Python/C API编写的扩展模块中的类，它和内建类是等价的。

但是为什么不可以对内建类和扩展类进行属性的设置呢？首先我们要知道Python的动态特性是解释器(虚拟机)赐予的，而虚拟机的工作就是将Python的PyCodeObject对象解释成C的代码进行执行，所以Python的动态特性就是在这一步发生的。而内建的类(int、str、list等等)在解释器启动之后就已经静态初始化好了，直接指向C一级的数据结构，同理扩展类也是如此。它们相当于绕过了解释执行这一步，所以它们的属性是没有办法动态添加的。

不光内建的类，其实例对象也是如此。

1
2
a = 123
print(hasattr(a, "__dict__"))  # False

我们看到它连自己的属性字典都没有，因为整数在底层对应的是PyLongObject对象，像这些实例对象都有哪些属性，解释器记得清清楚楚。

小结

这次我们介绍了Python中的对象模型，比较简单，主要之前也说过了，相当于再温习一遍。

关于类，要说的内容还是非常非常多的，我们分几个部分来说吧，下一篇介绍类的继承和属性查找。