在學習 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__ 屬性。

numbers?=?[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 這些內置的類對象也是具有相應的類型的，那么它們的類型又是誰呢？

我們使用 type 查看一下。

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

我們看到類型對象的類型，無一例外都是 type。而 type 我們也稱其為元類，表示類型對象的類型。至于 type 本身，它的類型還是 type，所以它連自己都沒放過，把自己都變成自己的對象了。

因此在 Python 中，你能看到的任何對象都是有類型的，我們可以使用 type 查看，也可以獲取該對象的 __class__ 屬性查看。所以：實例對象、類型對象、元類，Python 中任何一個對象都逃不過這三種身份。

到這里可能有人會發(fā)現一個有意思的點，我們說 int 是一個類對象，這顯然是沒有問題的。因為站在整數（比如 123）的角度上，int 是一個不折不扣的類對象；但如果站在 type 的角度上呢？顯然我們又可以將 int 理解為實例對象，因此 class 具有二象性。

至于 type 也是同理，雖然它是元類，但本質上也是一個類對象。

注：不僅 type 是元類，那些繼承了 type 的類也可以叫做元類。

這些概念上的東西讀起來可能會有一點繞，但如果實際動手敲一敲代碼的話，還是很好理解的。

然后 Python 中還有一個關鍵的類型（對象），叫做 object，它是所有類型對象的基類。不管是什么類，內置的類也好，我們自定義的類也罷，它們都繼承自 object。因此 object 是所有類型對象的基類、或者說父類。

那如果我們想獲取一個類都繼承了哪些基類，該怎么做呢？方式有三種：

class?A:?pass

class?B:?pass

class?C(A):?pass

class?D(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）表示方法查找順序，會從自身出發(fā)，找到最頂層的父類。因此返回自身、繼承的基類、以及基類繼承的基類, 一直找到 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__ 指定的順序去基類中查找。所以繼承鏈一定會有一個終點，否則就會像沒有出口的遞歸一樣出現死循環(huán)了。

我們用一張圖將對象之間的關系總結一下：

• 實例對象的類型是類型對象，類型對象的類型是元類；
• 所有類型對象的基類都收斂于 object；
• 所有對象的類型都收斂于 type；

因此 Python 算是將一切皆對象的理念貫徹到了極致，也正因為如此，Python 才具有如此優(yōu)秀的動態(tài)特性。

但是還沒結束，我們再重新審視一下上面那張圖，會發(fā)現里面有兩個箭頭看起來非常的奇怪。object 的類型是 type，type 又繼承了 object。

>>>?type.__base__
<class?'object'>
>>>?object.__class__
<class?'type'>

因為 type 是所有類的元類，而 object 是所有類的基類，這就說明 type 要繼承自 object，而 object 的類型是 type。很多人都會對這一點感到奇怪，這難道不是一個先有雞還是先有蛋的問題嗎？其實不是的，這兩個對象是共存的，它們之間的定義其實是互相依賴的。而具體是怎么一回事，我們一點一點分析。

首先在這里必須要澄清一個事實，類對象的類型是 type，這句話是沒有問題的；但如果說類對象都是由 type 創(chuàng)建的，就有些爭議了。因為 type 能夠創(chuàng)建的是自定義的類，而內置的類在底層是預先定義好的。

#?int、tuple、dict?等內置類型
#?在底層是預先定義好的，以全局變量的形式存在
#?我們直接就可以拿來用
print(int)??#?<class?'int'>
print(tuple)??#?<class?'tuple'>

#?但對于自定義的類，顯然就需要在運行時動態(tài)創(chuàng)建了
#?而創(chuàng)建這一過程，就交給?type?來做
class?Girl:
????pass

而 type 也只能對自定義類進行屬性上的增刪改，內置的類則不行。

class?Girl:
????pass

#?給類對象增加一個成員函數
type.__setattr__(
????Girl,
????"info",
????lambda?self:?"name:?古明地覺,?age:?17"
)
#?實例化之后就可以調用了
print(Girl().info())??#?name:?古明地覺,?age:?17

#?但內置的類對象，type?是無法修改的
try:
????type.__setattr__(int,?"a",?"b")
except?TypeError?as?e:
????print(e)
"""
can't?set?attributes?of?built-in/extension?type?'int'
"""

而 Python 所有內置的類對象，在解釋器看來，都是同級別的。因為它們都是由同一個結構體實例化得到的。

所有內置的類對象都是 PyTypeObject 結構體實例，只不過結構體字段的值不同，得到的類也不同。所以元類 type 和普通的類對象，在解釋器看來都是等價的。

在解釋器看來，它們無一例外都是PyTypeObject結構體實例。換句話說，它們都是基于這個結構體創(chuàng)建出的全局變量罷了，這些變量代表的就是 Python 的類。

而每一個對象都有引用計數和類型，然后解釋器將這些類對象的類型都設置成了 type，我們以 object 為例：

我們看到它的類型被設置成了 type，所以結論很清晰了，雖然內置類對象可以看做是 type 的實例對象，但它卻不是由 type 實例化得到的。所有內置的類對象，在底層都是預定義好的，以靜態(tài)全局變量的形式出現。

至于 type 也是同理：

解釋器只是將 type 的類型設置成了它自身而已，所以內置的類對象之間不存在誰創(chuàng)建誰。它們都是預定義好的，只是在定義的時候，將自身的類型設置成 type 而已，包括 type 本身。這樣一來，每一個對象都會具有一個類型，從而將面向對象理念貫徹的更加徹底。

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

print(
????type.__class__.__class__.__class__?is?type
)??#?True

print(
????type(type(type(type(type(type)))))?is?type
)??#?True

現在 object 的類型是 type 我們已經搞清楚是怎么一回事了，然后是基類的問題。PyTypeObject 結構體內部有一個 tp_base，它表示的就是類對象繼承的基類。

但令我們吃鯨的是，它的 tp_base 居然是個 0，如果為 0 的話則表示沒有這個屬性。不是說 type 的基類是 object 嗎？為啥 tp_base 是 0 呢。

事實上如果你去看 PyFloat_Type 以及其它類型的話，會發(fā)現它們內部的 tp_base 也是 0。為 0 的原因就在于我們目前看到的類型對象是一個半成品，因為 Python 的動態(tài)性，顯然不可能在定義的時候就將所有成員屬性都設置好、然后解釋器一啟動就得到我們平時使用的類型對象。

目前看到的類型對象是一個半成品，有一部分成員屬性是在解釋器啟動之后再動態(tài)完善的，而這個完善的過程被稱為類型對象的初始化，它由函數 PyType_Ready 負責。

首先代碼中的 type 只是一個普通的參數，當解釋器發(fā)現一個類對象還沒有初始化時，會將其作為參數傳遞進來，進行初始化。base 則顯然是它的基類，然后如果基類為空，并且該類不是 object 的話，那么就將它的基類設置成 object。所以 Python3 中，所有的類默認都繼承 object，當然除了 object 本身。

因此到目前為止，type 和 object 之間的恩怨糾葛算是真相大白了，總結一下：

1）和自定義類不同，內置的類不是由 type 實例化得到的，它們都是在底層預先定義好的，不存在誰創(chuàng)建誰。只是內置的類在定義的時候，它們的類型也都被設置成了 type。這樣不管是內置的類，還是自定義類，在調用時都會執(zhí)行 type 的 __call__ 方法，從而讓它們的行為是一致的。

2）雖然內置的類在底層預定義好了，但還有一些瑕疵，因為有一部分邏輯無法以源碼的形式體現，只能在解釋器啟動的時候再動態(tài)完善。而這個完善的過程，便包含了基類的填充，會將基類設置成 object。

所以 type 和 object 是同時出現的，它們的存在需要依賴彼此。首先這兩者會以不完全體的形式定義在源碼中，并且在定義的時候將 object 的類型設置成 type；然后當解釋器啟動的時候，再經過動態(tài)完善，進化成完全體，而進化的過程中會將 type 的基類設置成 object。

所以 object 的類型是 type，type 繼承 object 就是這么來的。

以上就是詳解Python中type與object的恩怨糾葛的詳細內容，更多關于Python type object的資料請關注腳本之家其它相關文章！