详解Python中type与object的恩怨纠葛

在学习 python 的时候编程客栈，你肯定听过这么一句话：Python 中一切皆对象。没错，在 Python 世界里，一切都是对象。整数是一个对象、字符串是一个对象、字典是一个对象，甚至 int, str, list 等等，再加上我们使用 class 关键字自定义的类，它们也是对象。

像 int, str, list 等基本类型，以及我们自定义的类，由于它们可以表示类型，因此我们称之为类型对象；类型对象实例化得到的对象，我们称之为实例对象。但不管是哪种对象，它们都属于对象。

因此 Python 将面向对象理念贯彻的非常彻底，面向对象中的类和对象在 Python 中都是通过对象实现的。

在面向对象理论中，存在着类和对象两个概念，像 int、dict、tuple、以及使用 class 关键字自定义的类型对象实现了面向对象理论中类的概念，而 123、(1, 2, 3)，"xxx" 等等这些实例对象则实现了面向对象理论中对象的概念。但在 Python 里面，面向对象的类和对象都是通过对象实现的。

我们举个例子：

#dict 是一个类，因此它属于类型对象
#类型对象实例化得到的对象属于实例对象
print(dict)
"""
<class'dict'>
"""
print(dict(a=1,b=2))
"""
{'a':1,'b':2}
"""

因此可以用一张图来描述面向对象在Python中的体现：

而如果想查看一个对象的类型，可以使用 type，或者通过对象的 __class__ 属性。

numbpythoners=[1,2,3]
#查看类型
print(type(numbers))
"""
<class'list'>
"""
print(numbers.__class__)
"""
<class'list'>
"""

如果想判断一个对象是不是指定类型的实例对象，可以使用 isinstance。

numbers=[1,2,3]
#判断是不是指定类型的实例对象
print(isinstance(numbers,list))
"""
True
"""

但是问题来了，按照面向对象的理论来说，对象是由类实例化得到的，这在 Python 中也是适用的。既然是对象，那么就必定有一个类来实例化它，换句话说对象一定要有类型。

至于一个对象的类型是什么，就看这个对象是被谁实例化的，被谁实例化那么类型就是谁，比如列表的类型是 list，字典的类型是 dict 等等。

而我们说 Python 中一切皆对象，所以像 int, str, tuple 这些内置的类对象也是具有相应的类型的，那么它们的类型又是谁呢？

我们使用 tyZTZSrqcpe 查看一下。

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

我们看到类型对象的类型，无一例外都是 type。而 type 我们也称其为元类，表示类型对象的类型。至于 type 本身，它的类型还是 type，所以它连自己都没放过，把自己都变成自己的对象了。

因此在 Python 中，你能看到的任何对象都是有类型的，我们可以使用 type 查看，也可以获取该对象的 __class__ 属性查看。所以：实例对象、类型对象、元类，Python 中任何一个对象都逃不过这三种身份。

到这里可能有人会发现一个有意思的点，我们说 int 是一个类对象，这显然是没有问题的。因为站在整数（比如 123）的角度上，int 是一个不折不扣的类对象；但如果站在 type 的角度上呢？显然我们又可以将 int 理解为实例对象，因此 class 具有二象性。

至于 type 也是同理，虽然它是元类，但本质上也是一个类对象。

注：不仅 type 是元类，那些继承了 type 的类也可以叫做元类。

这些概念上的东西读起来可能会有一点绕，但如果实际动手敲一敲代码的话，还是很好理解的。

然后 Python 中还有一个关键的类型（对象），叫做 object，它是所有类型对象的基类。不管是什么类，内置的类也好，我们自定义的类也罢，它们都继承自 object。因此 object 是所有类型对象的基类、或者说父类。

那如果我们想获取一个类都继承了哪些基类，该怎么做呢？方式有三种：

classA:pass

classB:pass

classC(A):pass

classD(B,C):pass

#首先D继承自B和C,C又继承A
#我们现在要来查看D继承的父类

#方法一:使用__base__
print(D.__base__)
"""
<class'__main__.B'>
"""

#方法二:使用__bases__
print(D.__bases__)
"""
(<class'__main__.B'>,<class'__main__.C'>)
"""

#方法三:使用__mro__
print(D.__mro__)
"""
(<class'__main__.D'>,<class'__main__.B'>,
<class'__main__.C'>,<class'__main__.A'>,
<class'object'>)
"""

• __base__：如果继承了多个类，那么只显示继承的第一个类，没有显式继承则返回 <class 'object'>
• __bases__：返回一个元组，会显示所有直接继承的父类，没有显式继承, 则返回 (<class 'object'>,)
• __mro__: mro（Method Resolution Order）表示方法查找顺序，会从自身出发，找到最顶层的父类。因此返回自身、继承的基类、以及基类继承的基类, 一直找到 object

而如果想查看某个类型是不是另一个类型的子类，可以通过 issubclass。

print(issubclass(str,object))
"""
True
"""

因此，到目前为止，关于 type 和 object，我们可以得出以下两个结论：

• type站在类型金字塔的最顶端, 任何一个对象按照类型追根溯源, 最终得到的都是type；
• object站在继承金字塔的最顶端, 任何一个类型对象按照继承关系追根溯源, 最终得到的都是object；

但要注意的是，我们说 type 的类型还是 type，但 object 的基类则不再是 object，而是 None。

print(
type.__class__
)#<class'type'>

#注：以下打印结果容易让人产生误解
#它表达的含义是object的基类为空
#而不是说object继承None
print(
object.__base__
)#None

但为什么 object 的基类是 None，而不是它自身呢？其实答案很简单，Python 在查找属性或方法的时候，自身如果没有的话，会按照 __mro__ 指定的顺序去基类中查找。所以继承链一定会有一个终点，否则就会像没有出口的递归一样出现死循环了。

我们用一张图将对象之间的关系总结一下：

• 实例对象的类型是类型对象，类型对象的类型是元类；
• 所有类型对象的基类都收敛于 object；
• 所有对象的类型都收敛于 type；

因此 Python 算是将一切皆对象的理念贯彻到了极致，也正因为如此，Python 才具有如此优秀的动态特性。

但是还没结束，我们再重新审视一下上面那张图，会发现里面有两个箭头看起来非常的奇怪。object 的类型是 type，type 又继承了 object。

>>开发者_C入门;>type.__base__
<class'object'>
>>>object.__class__
<class'type'>

因为 type 是所有类的元类，而 object 是所有类的基类，这就说明 type 要继承自 object，而 object 的类型是 type。很多人都会对这一点感到奇怪，这难道不是一个先有鸡还是先有蛋的问题吗？其实不是的，这两个对象是共存的，它们之间的定义其实是互相依赖的。而具体是怎么一回事，我们一点一点分析。

首先在这里必须要澄清一个事实，类对象的类型是 type，这句话是没有问题的；但如果说类对象都是由 type 创建的，就有些争议了。因为 type 能够创建的是自定义的类，而内置的类在底层是预先定义好的。

#int、tuple、dict等内置类型
#在底层是预先定义好的，以全局变量的形式存在
#我们直接就可以拿来www.devze.com用
print(int)#<class'int'>
print(tuple)#<class'tuple'>

#但对于自定义的类，显然就需要在运行时动态创建了
#而创建这一过程，就交给type来做
classGirl:
pass

而 type 也只能对自定义类进行属性上的增删改，内置的类则不行。

classGirl:
pass

#给类对象增加一个成员函数
type.__setattr__(
Girl,
"info",
lambdaself:"name:古明地觉,age:17"
)
#实例化之后就可以调用了
print(Girl().info())#name:古明地觉,age:17

#但内置的类对象，type是无法修改的
try:
type.__setattr__(int,"a","b")
exceptTypeErrorase:
print(e)
"""
can'tsetattributesofbuilt-in/extensiontype'int'
"""

而 Python 所有内置的类对象，在解释器看来，都是同级别的。因为它们都是由同一个结构体实例化得到的。

所有内置的类对象都是 PyTypeObject 结构体实例，只不过结构体字段的值不同，得到的类也不同。所以元类 type 和普通的类对象，在解释器看来都是等价的。

在解释器看来，它们无一例外都是PyTypeObject结构体实例。换句话说，它们都是基于这个结构体创建出的全局变量罢了，这些变量代表的就是 Python 的类。

而每一个对象都有引用计数和类型，然后解释器将这些类对象的类型都设置成了 type，我们以 object 为例：

我们看到它的类型被设置成了 type，所以结论很清晰了，虽然内置类对象可以看做是 type 的实例对象，但它却不是由 type 实例化得到的。所有内置的类对象，在底层都是预定义好的，以静态全局变量的形式出现。

至于 type 也是同理：

解释器只是将 type 的类型设置成了它自身而已，所以内置的类对象之间不存在谁创建谁。它们都是预定义好的，只是在定义的时候，将自身的类型设置成 type 而已，包括 type 本身。这样一来，每一个对象都会具有一个类型，从而将面向对象理念贯彻的更加彻底。

printandroid(int.__class__)
print(tuple.__class__)
print(set.__class__)
print(type.__class__)
"""
<class'type'>
<class'type'>
<class'type'>
<class'type'>
"""

print(
type.__class__.__class__.__class__istype
)#True

print(
type(type(type(type(type(type)))))istype
)#True

现在 object 的类型是 type 我们已经搞清楚是怎么一回事了，然后是基类的问题。PyTypeObject 结构体内部有一个 tp_base，它表示的就是类对象继承的基类。

但令我们吃鲸的是，它的 tp_base 居然是个 0，如果为 0 的话则表示没有这个属性。不是说 type 的基类是 object 吗？为啥 tp_base 是 0 呢。

事实上如果你去看 PyFloat_Type 以及其它类型的话，会发现它们内部的 tp_base 也是 0。为 0 的原因就在于我们目前看到的类型对象是一个半成品，因为 Python 的动态性，显然不可能在定义的时候就将所有成员属性都设置好、然后解释器一启动就得到我们平时使用的类型对象。

目前看到的类型对象是一个半成品，有一部分成员属性是在解释器启动之后再动态完善的，而这个完善的过程被称为类型对象的初始化，它由函数 PyType_Ready 负责。

首先代码中的 type 只是一个普通的参数，当解释器发现一个类对象还没有初始化时，会将其作为参数传递进来，进行初始化。base 则显然是它的基类，然后如果基类为空，并且该类不是 object 的话，那么就将它的基类设置成 object。所以 Python3 中，所有的类默认都继承 object，当然除了 object 本身。

因此到目前为止，type 和 object 之间的恩怨纠葛算是真相大白了，总结一下：

1）和自定义类不同，内置的类不是由 type 实例化得到的，它们都是在底层预先定义好的，不存在谁创建谁。只是内置的类在定义的时候，它们的类型也都被设置成了 type。这样不管是内置的类，还是自定义类，在调用时都会执行 type 的 __call__ 方法，从而让它们的行为是一致的。

2）虽然内置的类在底层预定义好了，但还有一些瑕疵，因为有一部分逻辑无法以源码的形式体现，只能在解释器启动的时候再动态完善。而这个完善的过程，便包含了基类的填充，会将基类设置成 object。

所以 type 和 object 是同时出现的，它们的存在需要依赖彼此。首先这两者会以不完全体的形式定义在源码中，并且在定义的时候将 object 的类型设置成 type；然后当解释器启动的时候，再经过动态完善，进化成完全体，而进化的过程中会将 type 的基类设置成 object。

所以 object 的类型是 type，type 继承 object 就是这么来的。

以上就是详解Python中type与object的恩怨纠葛的详细内容，更多关于Python type object的资料请关注我们其它相关文章！