Python中的“老祖宗”與“造物主”：object和type的那些事兒

目錄

1. 先搞懂一個核心：Python里“萬物皆對象”
2. object類：所有對象的“老祖宗”
3. type類：所有類的“造物主”
4. 繞不暈的關系：object和type的“互相成就”
5. 關鍵機制：實例關系的“傳遞性”
6. 總結：為什么它們是Python的“基石”

1. 先搞懂一個核心：Python里“萬物皆對象”

在Python的世界里，有句名言叫“萬物皆對象”。這話啥意思？簡單說就是：不管你看到的是數字、字符串、列表，還是類本身、函數，甚至是代碼里的if、for關鍵字（背后也是對象），全都是“對象”。

比如：

• 你寫a = 123，a是int類的對象；
• 你定義class MyClass: pass，MyClass本身也是一個對象（只不過它是“類對象”）；
• 連object和type這倆“大佬”，自己也是對象。

對象都有兩個核心特征：“類型”（它是誰創建的）和“父類”（它從誰那里繼承特征）。而object和type，就是管這倆特征的“終極Boss”。

2. object類：所有對象的“老祖宗”

object類就像家族里的“老祖宗”——不管你是哪一輩的（哪個類），往上數祖宗十八代，最后都會追到它頭上。

為啥叫“老祖宗”？

• 所有類（包括你自定義的MyClass、內置的int、list，甚至后面要說的type），都直接或間接繼承自object。
  就像你寫class MyClass: pass，其實默認是class MyClass(object): pass——偷偷繼承了object。
• 它定義了所有對象的“基礎技能”：比如__init__（初始化）、__str__（轉字符串）、__eq__（比較是否相等）等。不管你是數字還是類對象，這些基礎技能都從object那繼承來的。

看看代碼里的證據：

class MyClass: pass

# 所有類都是object的“后代”（子類）
print(issubclass(MyClass, object))  # True（MyClass是object的子類）
print(issubclass(int, object))      # True（int也是object的子類）
print(issubclass(object, object))   # True（老祖宗自己也是自己的子類，合理）

3. type類：所有類的“造物主”

如果說object是“老祖宗”，那type就是“造物主”——所有的“類”（包括object和type自己），都是type創造出來的。

啥是“造物主”？

在Python里，“類”本身也是對象（叫“類對象”）。比如MyClass這個類，它能創建實例（obj = MyClass()），但MyClass自己也是個對象——那誰創建了MyClass？答案就是type。

type是“元類”（創造類的類），就像上帝創造物種：

• 上帝（type）創造了“人類”（MyClass這個類）；
• “人類”（MyClass）創造了具體的人（obj = MyClass()這個實例）。

看看代碼里的證據：

class MyClass: pass

# 所有類的“類型”都是type（都是type創造的）
print(type(MyClass))   # <class 'type'>（MyClass是type創造的）
print(type(object))    # <class 'type'>（連object都是type創造的）
print(type(int))       # <class 'type'>（int也不例外）
print(type(type))      # <class 'type'>（造物主自己創造了自己，不然誰創造造物主呢？）
print(isinstance(MyClass, type))        # True（MyClass是type的實例）
print(isinstance(object, type))         # True（object是type的實例）
print(isinstance(type, type))           # True（type是自身的實例）

4. 繞不暈的關系：object和type的“互相成就”

object和type的關系，就像“先有雞還是先有蛋”——看似矛盾，實則互相成就：

• 從“繼承”看：type是object的“后代”
  issubclass(type, object)返回True，因為type作為一個“類”，也要認object這個老祖宗，繼承它的基礎技能。

• 從“創造”看：object是type的“孩子”
  isinstance(object, type)返回True，因為object這個類，是type創造出來的（造物主的作品）。

簡單說就是：造物主（type）雖然創造了老祖宗（object），但造物主自己也要認老祖宗當長輩。這就形成了一個閉環，避免了“誰創造造物主”“誰是老祖宗的老祖宗”的無限循環。

5. 關鍵機制：實例關系的“傳遞性”

前面說“萬物皆對象”，那為啥所有對象（包括類本身）最終都是object的實例？這就要靠“實例關系的傳遞性”。

啥是“傳遞性”？

就像“如果你是張三的孩子，張三是爺爺的孩子，那你也是爺爺的孩子”——實例關系也這樣：
如果A是B的實例，且B是C的子類，那么A一定是C的實例。

分兩種情況理解：

• 普通對象（類的實例）：
  比如obj = MyClass()，obj是MyClass的實例；而MyClass是object的子類，所以obj也是object的實例（isinstance(obj, object) → True）。

• 類對象（比如MyClass、object、type）：
  類對象是type的實例（比如MyClass是type創造的）；而type是object的子類（issubclass(type, object) → True），所以類對象也是object的實例。
  比如：

  print(isinstance(MyClass, object))  # True（MyClass是type的實例，type是object的子類）
  print(isinstance(object, object))   # True（object是type的實例，type是object的子類）
  print(isinstance(type, object))     # True（type是自己的實例，自己又是object的子類）
  
  

這就是為啥“萬物皆對象”——不管是普通實例還是類本身，順著“實例→類→父類”的鏈條往上找，最后都會落到object上。

6. 總結：為什么它們是Python的“基石”

• object是“繼承鏈的頂端”：所有類都繼承它，所有對象最終都是它的實例，保證了Python中“對象”的統一性。
• type是“元類的頂端”：所有類都由它創造，包括它自己和object，支撐了Python“動態創建類”的能力（元編程的基礎）。

理解了這倆“大佬”，你就看透了Python面向對象的底層邏輯——原來不管多復雜的類和對象，最終都逃不開“老祖宗”和“造物主”的手掌心～

下面是代碼匯總：

class MyClass:
    pass
def func():
    pass
obj = MyClass()

print(issubclass(object, object))       # True（object是自身的子類）
print(issubclass(type, object))         # True（type是object的子類）
print(issubclass(MyClass, object))      # True（MyClass是object的子類）
# print(issubclass(func, object))         # TypeError: issubclass() arg 1 must be a class
# print(issubclass(obj, object))          # TypeError: issubclass() arg 1 must be a class
print(issubclass(int, object))          # True（int是object的子類）

print(type(MyClass))                    # <class 'type'>（MyClass的類型是type）
print(type(object))                     # <class 'type'>（object的類型是type）
print(type(type))                       # <class 'type'>（type的類型是自身）
print(type(func))                       # <class 'function'>（func的類型是function）
print(type(type(func)))                 # <class 'type'>（type(func)的類型是type）
print(type(obj))                        # <class '__main__.MyClass'>（obj的類型是MyClass）
print(type(type(obj)))                  # <class 'type'>（obj的類型是MyClass的類型）
print(type(int))                        # <class 'type'>（int的類型是type）

print(isinstance(MyClass, type))        # True（MyClass是type的實例）
print(isinstance(object, type))         # True（object是type的實例）
print(isinstance(type, type))           # True（type是自身的實例）
print(isinstance(obj, type))                # False（obj不是type的實例）
print(isinstance(func, type))               # False（func不是type的實例）
print(isinstance(int, type))            # True（int是type的實例）

#實例關系的傳遞性
print(isinstance(MyClass, object))      # True（MyClass是object的實例）
print(isinstance(object, object))       # True（object是自身的實例）
print(isinstance(type, object))         # True（type是object的實例）
print(isinstance(func, object))         # True（func是object的實例）
print(isinstance(obj, object))          # True（obj是object的實例）
print(isinstance(int, object))          # True（int是object的實例）
#實例關系傳遞時，可以有多級繼承，但只能有一級實例化
print(isinstance(func, type))               # False（func不是type的實例）
print(isinstance(obj, type))               # False（obj不是type的實例） 

import types
# types.FunctionType就是function類
function_type = type(func)
print(types.FunctionType is function_type)  # True（function_type是types.FunctionType）
print(issubclass(function_type, object))    # True（function_type是object的子類）
print(isinstance(func, function_type))      # True（func是function_type的實例）
print(isinstance(function_type, type))      # True（function_type是type的實例）