Python 的 type 和 object 之間是怎麼一種關係？

type和object都是type的實例，而type是object的子類。

__class__是這兩個關係中更基本的一個。所有Python對象都有對應的class對象，而對一個Python的幾乎所有操作，即使是訪問對象屬性o.a這麼基本的，都是轉交給其class對象執行。唯二的例外，是__class__和id，這兩個操作的語義無法被class對象改變。在這方面，Python的可定製程度比絕大部分OOPL要高。

class C(object):
a = 1
def f(self):
pass
c = C()
c.f() # 行為由C決定
C.a # 行為由type決定


Python並未規定class一定要（直接或間接地）以type作為metaclass。

至於父類-子類關係，之所以說是兩個關係中較弱的一個，因為「一個class有父類」只是metaclass為type的那些class的行為。如果你自己不從type創建一個class（需要使用Python C API），它也可以沒有父類這個概念。

至於能否將type和object合併，回顧：

我先放張圖

#define PyVarObject_HEAD_INIT(type, size)
1, type, size,

PyTypeObject PyType_Type = {
PyVarObject_HEAD_INIT(PyType_Type, 0)
"type", /* tp_name */
sizeof(PyHeapTypeObject), /* tp_basicsize */
sizeof(PyMemberDef), /* tp_itemsize */
0, /* tp_base */
...
}


object 實際上是：

PyTypeObject PyBaseObject_Type = {
PyVarObject_HEAD_INIT(PyType_Type, 0)
"object", /* tp_name */
sizeof(PyObject), /* tp_basicsize */
0, /* tp_itemsize */
0, /* tp_base */
...
}


也就是說，type 和 object 的前兩個欄位是一樣的，都是1和 PyType_Type

ob_refcnt = 1 // 引用計數
ob_type = PyType_Type // 指向一個類型對象，用來指定當前對象的類型


即，type 和 object 的 ob_type 都是 PyType_Type，而PyType_Type就是 type，所以 type 的ob_type 是自己。

#define Py_TYPE(ob) (((PyObject*)(ob))-&>ob_type)

/* Quick test for an exact match */
if (Py_TYPE(inst) == (PyTypeObject *)cls)
return 1;
...
}


isinstance() 做的事情其實很簡單，就是判斷inst -&> ob_type 指向的類型是不是 (PyTypeObject *)cls。

================實例的關係說完了，下面說說繼承關係===================

[abstract.c]
PyObject_IsSubclass(PyObject *derived, PyObject *cls)
{
...
return recursive_issubclass(derived, cls);
}
//最終轉化成
[typeobject.c]
int PyType_IsSubtype(PyTypeObject *a, PyTypeObject *b)
{
mro = a-&>tp_mro;
if (mro != NULL) {
...
}
else{
do {
if (a == b)
return 1;
a = a-&>tp_base;
} while (a != NULL);
return b == PyBaseObject_Type; //這一句！
}
}


從上面我們也可以看出 python 的繼承機制。

object ：是一切類的基類
type ：一切類型都是它的實例


但實際上它的代碼實現並不符合這樣的思想，C 語言本身也沒有類和繼承的概念，開發者做了一些處理，讓他們看起來是符合思想的。

總結：type 和 object 其實並沒有繼承與實例化的關係，只是開發者為了保持 python 純正的思想，給他們添加了聯繫。添加聯繫的方式有兩種：一種是設置標誌位，如ob_type，一種是函數判斷中做特殊處理（就像 PyType_IsSubtype 函數那樣）。

1. 所有對象都一定是某一個類的實例
2. 在python中類也是對象，所有類都是type元類的實例

3. type元類也是對象，它是它自己的實例，它的父類是object

4. object是類，它是type的實例，object沒有父類

我想這大概是是為了完成完全的面向對象，既然萬物都是對象，那最源頭的對象又是誰的實例？type和object很好地解決了這個問題：抓著自己的鞋帶把自己提起來(bootstrap)。

/* PyObject_HEAD defines the initial segment of every PyObject. */
#define PyObject_HEAD
_PyObject_HEAD_EXTRA
Py_ssize_t ob_refcnt;
struct _typeobject *ob_type;


可以看到每一個object中都有一個 ob_type 的指針，指向了某一個具體的類型。

In [1]: a = 1

In [4]: type(type)
Out[4]: type


上面的代碼中可以看到 object a，*ob_type 會指向 int，int 是 1 的type，同時也是一個type，而int 本身的*ob_type 則指向了 type

Python中的對象按照比較方便的理解來區分的話，可以分為 普通對象 跟 類型對象，普通對象的 type 就是 int，str 之類的類型， 而類型對象的類型，則是type

In [1]: class NewData(object):
...: pass
...:

In [11]: object.__class__
Out[11]: type


之前讀過一篇討論這個問題文章，鏈接已經丟了。。。建議題主讀一讀《Ruby元編程》，這本書對類和對象有較清晰和深入的討論，要求不高，Ruby和Python的對象模型非常相似，不懂Ruby也能讀懂。

要搞懂這個問題，首先要先把類、類型、對象這些概念全部舍掉，重構世界觀。

首先，python裡面一切皆是對象，包括type、object、所有class，全部都是對象，

那對象之間靠什麼聯繫在一起呢？沒錯，靠的就是關係：

&>&>&> B.__base__
&


&>&>&> object.__base__
&>&>&> type.__base__
&


&>&>&> a.__class__
&


在python里，對象又可以分為三種：type object、class object和non-class object，

class TypeA(type): pass


則TypeA和type均屬於type object

class A(object)：pass


則object和A均屬於class object

a = A()


則a就是一個non-class object

三者的區別和聯繫在於：

&>&>&> object.__class__
&
&>&>&> type.__class__
&


首先了解2條規則

　　1.若x是A的一個實例，且A是B的子類，那麼x也是B的一個實例

　　2.若B是M的實例，且A是B的子類，那麼A也是M的一個實例

　　首先type為object的子類，（A=type,B=object）

　　&>&>&> issubclass(type,object) True

　　其次object是type的實例（x=object,A=type)

　　&>&>&> isinstance(object,type) True

　　規則1得出object是object的實例（B=object，M=object)

　　&>&>&> isinstance(object,object) True

　　規則2得出type是object的實例

　　&>&>&> isinstance(type,object) True

　　同樣可以得到type是type自己實例

　　&>&>&> isinstance(type,type) True

這個。。。怎麼說呢

我這裡說我比較熟的py3

在py3中「萬物皆對象」

py3中每個對象都有一個類型（類型也是個對象，也有類型）

object的類型是class name

在Python中每個對象中都包含一個類型對象

-----------------------

class A:

[ REPL ]：

嘿嘿，聽著是不是特絕望？

1,理解生活中的栗子

2. python metaclass,即我們說的 class type的兩面性

class type是類(本質是模具,作用是生產磨具),那麼你說他生產的磨具不是他的實例嗎? 而他生產的實例又是類.

[類與實例關係]class type是一種特殊的類,它的實例有兩面性
站在class type角度講, 他的實例有class str,class dict等,也就是class str, class dict是實例. 這些實例最高父類是object.
站在class str,class dict角度講,他們是類, 可以創造各自的實例. 這些實例不存在父類的概念


3.好了,理解了 class type創造出的類有兩面性,那麼在想想生活中的栗子吧. 很多人yy了,靠.越說越複雜.