Python中一切皆对象：深入理解Python的对象模型

Python 中一切皆对象：深入理解 Python 的对象模型（2026 最新版）

“一切皆对象”（Everything is an object）是 Python 最核心的设计哲学之一。这句话不仅仅是口号，而是贯穿 Python 语言底层实现的关键原则。掌握它，你就能真正理解 Python 的类型系统、内存管理、函数、类甚至内置类型的工作机制。

1. “一切皆对象”到底意味着什么？

在 Python 中：

• 整数、字符串、列表、字典、函数、类、模块、甚至 None、type 本身……都是对象。
• 每个对象都有：
• 身份（identity）：id(obj) 返回的内存地址
• 类型（type）：type(obj) 返回对象的类
• 值（value）：对象的内容

示例：

>>> a = 42
>>> type(a)
<class 'int'>
>>> id(a)
140735674688896
>>> a.__class__
<class 'int'>

>>> def func(): pass
>>> type(func)
<class 'function'>
>>> func.__class__
<class 'function'>

>>> type(type)
<class 'type'>  # 元类：type 是自己的类！

结论：没有“原始类型 vs 对象类型”的区分，所有值都是对象实例。

2. Python 对象模型的核心组成

Python 的对象模型基于 C 结构体 PyObject 和 PyVarObject（变长对象）实现。

所有 Python 对象在 CPython 中都包含一个共同的头部：

typedef struct _object {
    PyObject_HEAD
} PyObject;

#define PyObject_HEAD               \
    _PyObject_HEAD_EXTRA            \
    Py_ssize_t ob_refcnt;           // 引用计数
    PyTypeObject *ob_type;          // 指向类型的指针

关键字段：

• ob_refcnt：引用计数，用于垃圾回收
• ob_type：指向该对象的类型对象（即类）

类型对象本身也是对象：

• int、str、list 等都是 PyTypeObject 的实例
• 类型对象也有自己的类型 → 元类（metaclass），默认是 type

3. 类型、类、实例的关系图解

          type (元类)
           ^
           | 创建
   +-------+-------+
   |       |       |
  int     str    list   ... (内置类型对象)
   ^       ^       ^
   |       |       |
实例     实例     实例
  42     "hi"    [1,2,3]

• type 是所有类型的“类”
• int 是 42 的类
• 42 是 int 的实例
• int 本身是 type 的实例

验证：

>>> isinstance(int, type)    # int 是 type 的实例
True
>>> isinstance(type, object) # type 继承自 object
True
>>> isinstance(object, type) # object 也是 type 的实例
True

4. 函数和类也是对象

函数是一等公民（first-class object）：

>>> def add(x, y): return x + y
>>> type(add)
<class 'function'>
>>> add.__code__        # 字节码
>>> add.__defaults__    # 默认参数
>>> add(3, 4)
7

类也是一等对象：

>>> class Person:
...     def say(self): print("hi")
...
>>> type(Person)
<class 'type'>  # 类由 type 创建
>>> Person.__dict__  # 类属性字典
>>> p = Person()
>>> type(p)
<class '__main__.Person'>

自定义元类示例：

class Meta(type):
    def __new__(cls, name, bases, dct):
        dct['created_at'] = '2026'
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=Meta):
    pass

print(MyClass.created_at)  # 输出: 2026

5. 内置类型也是对象（深入例子）

>>> (1).__add__(2)        # 等价于 1 + 2
3
>>> "hello".upper()       # 字符串方法
'HELLO'
>>> [1,2,3].append(4)     # 列表方法
>>> None is None          # None 是 singleton 对象
True
>>> type(None)
<class 'NoneType'>

甚至模块也是对象：

>>> import math
>>> type(math)
<class 'module'>
>>> math.__name__
'math'

6. 对象模型带来的实际影响

特性	说明	示例
可变 vs 不可变	取决于类型实现（int/str/tuple 不可变，list/dict 可变）	a = 1; a += 1 创建新对象
引用语义	赋值传递的是引用，不是值拷贝	b = a → b 和 a 指向同一对象
单例模式（interning）	小整数（-5~256）、小字符串被缓存	a = 256; b = 256; a is b → True
动态性	可以运行时修改对象属性、方法	obj.new_attr = 1、obj.method = func

7. 经典面试题解析

Q1：以下代码输出什么？

a = 256
b = 256
c = 257
d = 257
print(a is b)  # True（小整数缓存）
print(c is d)  # False（大整数不缓存）

Q2：为什么推荐用 is 比较 None 而不是 ==？

# 因为 None 是单例对象，is 更高效且语义明确
if x is None: pass

Q3：函数参数是值传递还是引用传递？

• 引用传递：传递的是对象引用
• 但由于不可变对象（如 int）行为像值传递，容易误解

def modify(x, lst):
    x = 100      # 不影响外部（不可变）
    lst.append(4)  # 影响外部（可变）

a = 1
b = [1,2,3]
modify(a, b)
print(a)  # 1
print(b)  # [1,2,3,4]

8. 总结：Python 对象模型的核心思想

1. 一切都是对象：包括基本类型、函数、类、模块
2. 类型也是对象：由元类 type 创建
3. 对象有身份、类型、值：id()、type()、value
4. 动态性强：运行时可修改对象行为
5. 引用语义 + 不可变性设计：决定了变量赋值、参数传递的行为

掌握了 Python 的对象模型，你就能：

• 理解为什么 is 和 == 不同
• 避免可变默认参数陷阱
• 深入理解装饰器、元类、描述器等高级特性
• 写出更 Pythonic、更高效的代码

这就是 Python “优雅、明确、简单”背后的深刻原因——一切皆对象！

如果你想继续深入元类（metaclass）、描述器（descriptor）、slots 优化，或 CPython 源码分析，随时告诉我，我带你继续探索 Python 的底层世界！🚀