python中的type和object详解

朱雀 2022-10-01 14:57 141阅读 0赞

这篇主要描述Python的新风格对象(new-style objects)，如下：

和分别是什么？

用户自定义的类和实例之间是怎么联系的？它们和内置类型又是怎么联系的？

什么是元类(metaclasses)？

New-style表明这篇博客所说的内容只适用于版本为2.2及以上的python。

**开始之前**

最主要，是理解type和object的区别与联系。我们平时用的最多的是Object，比如你定义一个类时，会继承object:

![1240][]

这里你定义了一个自定义类Test，不难看出，Test继承了object，也就是说，object是Test的超类(或者说基类)。

接下来，你可以再定义一个类：

![1240][1240 1]

subTest继承了Test,同时，因为Test继承了object，所以也可以说subTest继承了object。在这里涉及到一个重要的知识点，那就是**继承具有传递性**。如果你仔细观察，你会发现另外一个知识点，那就是：**object是所有类的超类**（这句话至关重要）。那type是什么呢？它是object的类型（也就是说object是type的实例），同时，object又是type的超类。

“**type是object的类型，同时，object又是type的超类**”这句话看起来就充满疑点：那到底是先有object还是先有type呢？其实，“先有object和还是type问题”就像“先有鸡还是先有蛋问题”。到底先有谁呢？不急，请继续看：

你要明白这些，先要知道，python是面向对象的语言。**在python里面，一切皆为对象**。

一切皆为对象？这里对于一部分人来说，可能不是很容易理解。这么说吧，在python里，int×××是对象，整数2也是对象，你定义的函数啊，类啊都是对象，你定义的变量也是对象。总之，你在python里能用到的都可以称之为对象。

好了，把python里一切皆为对象给整明白后，你要明白在**面向对象的体系**中，存在两种关系：

父子关系（图中以实线描述）：这种关系存在于**某个类（subclass）是另一个类（superclass）的特别版本**之中。通常描述为“子类是一种父类”。比如：蛇是一种爬行动物(Snake is a kind of reptile)。其中，蛇(snake)是子类,爬行动物(reptile)是父类。蛇拥有爬行动物的特征，同时，又拥有标志自己是一条蛇的特征。

类型实例关系（图中以虚线描述）：这种关系存在于两个对象之中，其中一个对象(实例)是另一个对象(类型)的具体实现。我有一条宠物蛇叫**Squasher**，那么**Squasher**就是蛇的一个实例。英文描述为："Squasher is an instance of snake".

![1240][1240 2]

用实线表示父子关系，是因为父与子的关系更加“贴实”。比如有人叫你列出有关蛇的词，你可能会说蛇是爬行动物，但你不会说出蛇是Squasher....

我想如果把上面的两种关系用代码表示出来你会更加直观：

![1240][1240 3]

class reptile(object)和class snake(reptile)就是代表父子关系。object是reptile的基类，reptile是snake的超类（基类）。这里有没有想起来 **object是所有类的超类**？

Squasher = snake()是类型实例关系。将类snake**实例化**就得到了Squasher。

这时候，有两条很有用的规则：

**Dashed Arrow Up Rule**:If X is an instance of A, and A is a subclass of B, then X is an instance of B as well.翻译过来应该是“虚线向上规则”:**如果X是A的实例，同时A又是B的子类，那么，X也是B的实例。**；

**Dashed Arrow Down Rule**:If B is an instance of M, and A is a subclass of B, then A is an instance of M as well.翻译过来应该是“虚线向下规则”：**如果B是M的实例，同时A是B的子类，那么，A也是M的实例**。其实这条规则很少会用到，但却和这篇博客要讲的内容息息相关。我来略作分析，从“如果B是M的实例”这句话得出，B是实例，“A是B的子类” --> B是一个（父）类。B是实例，同时又是一个类？怎么回事？看完这篇博客，你会知道答案的。

![1240][1240 4]

在这里，我来解释一下为什么叫"虚线向上规则"，通过观察上图右边，我们可以清晰地见到一个带箭头的虚线，从X端出发，射向A端，此时，A端为箭头端，虚线代表**类型实例关系**，所以A端是**类型**，即X是A的实例（换句话说，A是X的类型），通过命令X.\_\_class\_\_我们可查看X的类型。再看，一条带箭头的实线从A端射向B端，B端是箭头端，实线代表**父子关系**，所以B端是父类，即A是B的子类。**这时候，我们通过将X端射向A端的虚线，向上抬，射向B端（你应该可以看到上图右上方有一条标志为implied\[这个单词意思是隐藏\]的向上虚线），就实现了表述X也是是B的实例的目的。也名副其实，虚线向上嘛**。虚线向下规则也可以这样推出来，我就不演示了。

总的来说，面向对象体系里，有两种关系，一种是**父子关系**，通过父类与子类来描述，另一种是**类型实例关系**，通过类和实例来描述。而**两条规**则，是将类之间，类与实例之间的关系联系在一起。

到这里，可以进入主题了。

基本概念

对象内部：The Object Within

上面我们说了面向对象，那么对象（object）是什么呢？对象是python的重要核心之一：它是某个实体的抽象描述。**对象**拥有下面的特征：

身份（Identity）：给定两个名字，我可以肯定地说，要么它们是指向同一个对象，要么不是;

值（A value）：这意味着对象包含一堆属性。我们可以通过objectname.attributename的方式操作属性;

类型（A type）:每个对象都有一个确切地类型。例如，对象“2”的类型是int;

一个或多个“Bases”（One or more bases）：不是所有对象都有Bases，但一些特殊的对象会有，比如：**类**。Bases类似于面向对象语言中的“基类”，“超类”。

如果你想知道一个对象在内存中的位置，你可以调用id(对象)来查看。在这里，我再次强调，在python中，一切都有对象的概念。数字2是对象，类型int也是对象...

type和Bases（如果它们存在）非常重要，因为它们定义了一个对象和另一个对象之间的关系。请记住，type和Bases本身也是对象，稍后会提到。

你也许会认为，对象有名字，但名字并不是对象的组成部分。对象的名字存在于这个对象的命名空间（namespace）之外或者是另一个对象的属性。也就是说：**名字和这个对象不是存储在同一个“地方”**

**例子**：测试一个整数对象

![1240][1240 5]

(1):我们在当前命名空间给数字2分配一个名字。并将2和“two”绑定在起。

(2):这个对象的类型是<class 'int'>。你会在其它地方见到类似<type 'int'>，int这样的输出，其实它们都是一个意思。

(3):额，<class 'int'>的类型是<class 'type'>.

(4):输出“类int”的基类。

(5):列出整型这个对象所有的属性。

可能会觉得有点乱，我稍微总结一下：数字2是类型int（一般来讲，在python中“类”和“类型”是同一种东西）的一个实例。倒过来说，int是数字2的类型。元组(<class 'object'>,)是类型int的超类（或说父类）。一个类型的超类可能不止一个，所以用元组表示。

现在，我们引出第一条规则：

一切皆为对象

上面说的数字2，类型int，int的超类<class 'object'>都是对象。除此之外，你定义的函数，方法...都是对象。

一块干净的画板

现在我们来建立python的对象系统。从一块干净的画板开始...,画板分为三部分，从左到右，分别代表类的类，类，类的实例。

![1240][1240 6]

我们会在这个画板中开启我们的学习之旅...

关系（Relationships）

我们谈及对象时，用两种关系来连接各种对象，使得对象之间产生联系：

父子关系（ the subclass-superclass relationship）;

类型实例关系（ the type-instance relationship ）。

在文章开头已经详细讨论过这两种关系了。

进入对象( Bring In The Objects)

第一个对象

我们测试两个对象：object和type:

例子1：

![1240][1240 7]

(1),(2):python中的两个源对象的名字。我们先前说过type()是用来获对象的类型的。事实上，它既是一个**对象**，也是获取其它对象的类型的**方法**。

(3),(4):查看object的类型。看到**object是type的实例**，我们另外也用.\_\_class\_\_来核实它和type()的输出是一样的。

(5):object没有超类，因为它本身就是所有对象的超类。

(6),(7):分别输出type的类型和超类。即，**object是type的超类。type的类型是它自己**

我们把例子1获取的信息描述在画板上：

![1240][1240 8]

object和type是python中的两个源对象，当我们尝试介绍它们是就会陷入“先有鸡还是现有蛋”难题，到底先介绍谁？事实上，它们是互相依赖对方来定义，所以它们不能分开而论。

继续我们的python实验：

![1240][1240 9]

(1):发生了什么？其实这里利用了虚线向上规则，type是object的子类，type的实例自然也是object的实例。object是type的实例啊。

(2):这里我参考的英文文档解释是：同时应用虚线向上和虚线向下规则。但我看得一脸懵逼。因为我觉的这里和(1)一样啊：type是object的子类，type的实例自然也是object的实例。type也是type的实例啊。

如果你认为上面的解释很混乱，不用理会它。不影响你理解这篇文章的主要目的。

新概念： type objects

type和object都属于type objects。type objects翻译过来就是类型对象了。类型对象的特征：

它们用于表示程序中的抽象数据类型。例如，我们定义的一个类User会代表系统中所有的用户。int会代表系统中所有×××数字。

它们能被继承。这意味着你可以利用存在的**类型对象**创造出新的**类型对象**。已经存在的类型对象是新的类型对象的超类。

它们能被实例化。这意味着你可以利用已经存在的**类型对象**创造出新的**实例对象**。前者是后者的type。

类型对象的类型是type

它们有时会被成为**类型**有时会被称为**类**。

你没有看错。在新版本的python中类和类型已经是同一样东西了。由一个很明显的地方就可以看出来。\_\_class\_\_和type()的输出是一样的。

在旧版本的python中，类是特指用class语句创造出来的东西。而内置类型例如int一般不会被认为是类，而是被认为是类型。但在新版本中它们是同一样东西了。我觉得有必要为这个改变定义一条规则：

**类是类型，类型也是类（Class is Type is Class）**

**在>=2.3版本的python中，类和类型是同一样东西。**

The term type is equivalent to the term class in all version of Python >= 2.3.

类型和非类型（或者说类和非类）都是对象，但只有类型能够被继承。非类型拥有具体的值，所以被继承是毫无意义的，而且它也不能被继承。做简单的例子，就是类型int和它的实例2。int是类型，2是非类型。你说说，继承2有什么意义？

是否还是会疑惑到底社么是类型？什么是非类型？

这里有一条判断规则送给你：

如果一个对象，它的类型是“<class 'type'>”,那么，它是类型，否则不是。

还记得怎么判断一个对象的类型吗？没错的，\_\_class\_\_和type()随意你用。

小总结：

的类型是;

的父类为空;

的类型是它自己本身;

是的子类;

在python中只要两种对象：类型和非类型。非类型也被称为实例。这里有英文原句，我不知怎么翻译了，很容易看懂，但不知如何说：There are only two kinds of objects in Python: to be unambiguous let's call these types and non-types. Non-types could be called instances, but that term could also refer to a type, since a type is always an instance of another type. Types could also be called classes, and I do call them classes from time to time.

**注意我们在画板中只画出两个对象的直接关系，隐藏的关系就不画了，节省我们的精力和画板尺寸**。

更多内置对象

python这条船上可不止只有两个源对象。通过这两个源对象可以繁育出一堆对象：

Figure 2.2. 一些内置对象

![1240][1240 10]

上图中的一些内置类型，下面通过例子来测试：

![1240][1240 11]

(1):内置对象list;

(2):list的类型是;

(3):list的超类是(,);

(4):内置对象tuple.tuple的类型和超类分别是：, (,);

(5)list的一个实例mylist;

(6)实例mylist的类型是;

(7)实例没有超类。

我们可以创造一个tuple或dict的实例，但我们不能创造一个mylist的实例。因为mylist不是一个类型，它仅仅是一个实例。

通过继承产生新对象

内置类型是python本身就有的。那么我们如何创造一个新的类型呢？

新的类型不能够凭空产生，它必须依赖已经存在的类型，于是，**继承**就呼之欲出了。

例子：通过继承产生新对象

![1240][1240 12]

(1):class语句告诉python解释器要通过一个存在的类型创造一个新的类型;

(2):在python3.x可以省略掉(object)。

(3):多重继承;

(4):大多数内置类型可以被继承，但不是所有的都可以。

通过实例化产生新对象

Example 2.5.

![1240][1240 13]

(1),(2):利用类型名()的方式创造一个**类型**的实例。()中可能带参数;

(3):这是python利用内置类型创造实例的语法。没什么好说的。

**注意**：仅仅通过对<class 'object'>进行子类化，类型C就自动成为<class 'type'>的实例。原因在**常见疑问**的第二个问题中。

在以上的操作后，原本空白的画板可以画满了：

![1240][1240 14]

常见疑问

到这里你头脑中可能会有很多疑惑，下面列出其中一些问题以及答案，请酌情欣赏。有没有提到的请留言，我会努力搜索答案来解答：

Q: Python如何真正创建一个新对象?

A: 在python中，创造的新对象有两种：类型和非类型。类型可被继承和实例化。非类型本事就是一个实例。当python创造新对象时，它会用自己本身的类型作为新对象的类型。一般会用到两个方法\_\_new\_\_()和\_\_init\_\_()。所以。每个对象都有类型。

Q:实例化的时候要指定类型，但是当继承时python如何知道用哪个类型？

它查看你继承的超类，并且使用超类的类型来作为新对象的类型。

在大多数的情况下，<class 'object'>的子类（和<class 'object'>的子类的子类等等）的类型都是<class 'type'>

![1240][1240 15]

Q:我能够创造一个新的类型？

A:能，这就得元类出场了，通过属性\_\_metaclass\_\_你可以重新创造一个类型出来。这里我简单列一个例子。元类的话下面会简单介绍。

![1240][1240 16]

通过继承type,我们创造出新的类型<class '\_\_main\_\_.A'>。

Q:wow！那我可以使用任何的类型作为metaclass的参数吗？

A:不能。只有继承了type的类能够做为metaclass的参数。

Q:我应该使用metaclass吗？

不建议使用。高手除外。

准备结束

一幅描绘python对象的图

我们最后得到一幅由不同对象组成的地图：

![1240][1240 17]

在大多数情况之下，我们都是学习第二列和第三列的内容。至于第一列，那是元类的领域了。不是所有人都要深入学习。

来解释一下上图的东西：

虚线可以从一列穿过另一列，例如从实例所在列穿到类所在列。（例外）;

实线不可以穿过其他列。再一次地， -> 是例外。

第三列不允许出现实线。因为实线代表继承。第三列地实例无法子类化;

第三列地对象也不允许被实例化;

第一，二列包含类型，第三列包含非类型;

如果创造一个继承的对象，那么它会被放在第一列，即元类。这里继续强调，类和类型是一样的。<class 'type'>和<type 'type'>也是一样的。

**注意：<class 'type'>是所有类型的类型。<class 'object'>也是所有对象的超类（除了它自己）**。

总结

这些内容是对前面的总结：

在python中有两种对象：

类型对象：可以被实例化和继承；

非类型对象：不可以被实例和继承。

和是python中的两个源对象。

每个**对象**都有类型。用objectname.\_\_class\_\_查看。

每个**类型对象**都有超类（object除外），用objectname.\_\_bases\_\_可以查看。

通过继承产生的新对象都是**类型对象**。继承是用class语句来实现的。

通过实例化产生的新对象可能是**类型对象**，也可能是**非类型对象**。你看下图，虚线就表示实例化，第一列和第二列实例化产生的新对象就是**类型对象**。第三列实例化产生的新对象就是**非类型对象**。实例化是通过调用操作符()来实现的。比如你自定义了一个类myclass,实例化就是在myclass后增加()操作符完成的。也就是instance\_of\_myclass=myclass()。

![1240][1240 18]

一些python的非类型对象可以通过特殊的语法来创造。例如\[1, 2, 3\]是list的实例。

在内部，python总是使用类型对象来创造新对象。新创造的对象是该类型对象的**实例**。（在这里，**实例**有两种意思：一通过继承产生的子类，二是通过实例化产生的具体实例。但平时我们说的实例就是只第二种）。python通过class语句中指定的超类的类型来决定新对象的类型。

issubclass(A,B)返回true当且仅当：

B在A.\_\_bases\_\_输出的元组之中;

如果A在Z.\_\_bases\_\_输出的元组中，issubclass(Z,B)返回true.

isinstance(A,B)返回true当且仅当：

A.\_\_class\_\_是B，或者

issubclass(A.\_\_class\_\_,B)返回true.

完结

这篇文章很长。因为水平限制，可能会出现错误。请批判性阅读。还是建议阅读[英文原文][Link 1] （英语原文失效了，如果你能上世界互联网，请自行搜索，关键词：python types and objects）

转载于:https://blog.51cto.com/14246112/2385722

[1240]: /images/20220114/f32f772463d144f4b54e73bc7d827861.png
[1240 1]: /images/20220114/8688dc7c8c1d4e6b9fecabb685ad935b.png
[1240 2]: /images/20220114/bf1d72abe56e4c60b6509a7779523314.png
[1240 3]: /images/20220114/d7838e06ae57466ab0193186c6097755.png
[1240 4]: /images/20220114/30467b71675b4c42a9319e2129adce6f.png
[1240 5]: /images/20220114/e6a7c56d22264eabada975a59fabe57f.png
[1240 6]: /images/20220114/e1cb0455d00b489caa5966a9de2dd3e7.png
[1240 7]: /images/20220114/e175592ffe8e4cf99ba3af5efc3ecb1e.png
[1240 8]: /images/20220114/5140d594eeef468b872520510c2a26b1.png
[1240 9]: /images/20220114/893760f92a4e4bfba2b30472645b4339.png
[1240 10]: /images/20220114/075098e8f57e43fb94e297da3c0b3c82.png
[1240 11]: /images/20220114/777d8d4cc56b4c8fb6ed21b73a524d56.png
[1240 12]: /images/20220114/de1d0354f51242e39b16fbc33af615fe.png
[1240 13]: /images/20220114/13a2bb25815b47d790bcd3e4e4a70eeb.png
[1240 14]: /images/20220114/9a5492d413fd4fc6929138fc8332704a.png
[1240 15]: /images/20220114/51e0c9080cdd4d1e85eeff7f32a9f1f6.png
[1240 16]: /images/20220114/11694a7f5bf442bba34993847889cc7d.png
[1240 17]: /images/20220114/cbc19a1812ed49398de1775663188cf9.png
[1240 18]: /images/20220114/373cb6508d17428788227465af268c02.png
[Link 1]: http://www.cafepy.com/article/python_types_and_objects/python_types_and_objects.html