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

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的实例）