Python的内存模型是其动态类型系统的核心基础，理解它对于编写高效、正确的代码至关重要。其核心机制可概括为：**所有对象都分配在堆（Heap）上，而变量名（标识符）存储在栈（Stack）中，变量名实质上是到堆中对象的引用**[ref_1][ref_5]。 ### 1. 内存分配：堆与栈的角色 Python的内存管理主要涉及两个区域： * **堆 (Heap)**：用于存储所有Python对象，如整数、字符串、列表等。对象的大小和生命周期在运行时动态决定。 * **栈 (Stack)**：用于存储执行上下文，如函数调用栈帧。**变量名（如`a`, `my_list`）及其对堆中对象的引用存储在此处**[ref_1][ref_5]。 一个简单的赋值语句 `a = 10`，其内存模型如下： ```python # 栈帧中创建变量名 `a`，它持有一个指向堆中整数对象 `10` 的引用。 a = 10 # `b = a` 是将 `a` 持有的引用复制给 `b`，两者指向堆中同一个对象 `10`。 b = a ``` ### 2. 对象类型与内存行为：可变 vs 不可变 对象在内存中的行为由其**可变性 (Mutability)** 决定，这是理解内存模型的关键。 | 类型 | 示例 | 可变性 | 内存行为关键点 | | :--- | :--- | :--- | :--- | | **不可变对象** | `int`, `float`, `str`, `tuple`, `bytes`, `frozenset` | 不可变 | 对象内容一旦创建无法更改。任何“修改”操作（如`a += 1`）都会在堆中**创建新对象**，并让变量引用新对象[ref_1][ref_5]。 | | **可变对象** | `list`, `dict`, `set`, 用户自定义类实例 | 可变 | 对象内容可以原地修改，而对象在堆中的内存地址（身份）保持不变[ref_1][ref_5]。 | **代码示例：可变与不可变的差异** ```python # 不可变对象示例 x = 100 print(id(x)) # 输出对象地址，例如 140736053260736 x = x + 1 # `x+1` 创建了新对象 `101`，x 的引用被更新 print(id(x)) # 地址已改变 # 可变对象示例 lst1 = [1, 2, 3] print(id(lst1)) # 输出地址，例如 2818326986368 lst1.append(4) # 原地修改列表内容 print(id(lst1)) # 地址不变！仍然是 2818326986368 ``` ### 3. 内存优化机制：小整数池与字符串驻留 Python解释器为了提升性能，对一些常用的不可变对象进行了缓存优化。 * **小整数池**：Python在启动时会预先在堆中创建并缓存范围在 **-5 到 256** 之间的整数对象。当程序引用这些整数时，变量会直接指向缓存中的对象，无需重复创建[ref_1]。 ```python a = 10 b = 10 print(a is b) # 输出: True，id相同，指向同一个缓存对象 c = 257 d = 257 print(c is d) # 输出: False (在大多数交互式环境中)，id不同，是新创建的对象 ``` * **字符串驻留 (Interning)**：对于较短的、符合标识符规则的字符串（如变量名、函数名），Python也会进行缓存复用，以减少内存开销[ref_1][ref_6]。 ```python s1 = "hello" s2 = "hello" print(s1 is s2) # 输出: True，指向驻留的同一对象 s3 = "hello world!" s4 = "hello world!" print(s3 is s4) # 输出: False (在大多数情况下)，较长的字符串通常不驻留 ``` ### 4. 赋值、浅拷贝与深拷贝的内存差异 这是内存模型在实践中最容易出错的领域[ref_1][ref_2]。 | 操作 | 方法 | 内存效果 | 示意图与说明 | | :--- | :--- | :--- | :--- | | **赋值** | `b = a` | 仅复制**引用**。`a`和`b`指向堆中**同一个对象**。任何一方对可变对象的修改，另一方立即可见[ref_1][ref_5]。 | `栈[a] --> 堆[对象] <-- 栈[b]` | | **浅拷贝** | `copy.copy()` 或 `list.copy()` | 创建**新容器对象**，但仅拷贝容器内元素的**引用**。对于嵌套的可变对象，修改其内部元素会影响原对象[ref_1][ref_2]。 | `栈[a] --> 堆[列表A] --> [ref_obj1, ref_obj2]` <br> `栈[b] --> 堆[列表B] --> [ref_obj1, ref_obj2]` (复制了引用) | | **深拷贝** | `copy.deepcopy()` | 递归地创建**全新的对象**及其包含的所有子对象。新旧对象完全独立，互不影响[ref_1][ref_2]。 | `栈[a] --> 堆[列表A] --> [ref_obj1, ref_obj2]` <br> `栈[b] --> 堆[列表B] --> [ref_new_obj1, ref_new_obj2]` (创建了新对象) | **代码示例：拷贝陷阱** ```python import copy # 原始嵌套列表 original = [1, 2, [3, 4]] # 1. 赋值 assigned = original assigned[0] = 'X' print(original) # 输出: ['X', 2, [3, 4]]，原对象被修改！ # 2. 浅拷贝 shallow_copied = copy.copy(original) shallow_copied[2].append(5) # 修改嵌套的列表 print(original) # 输出: ['X', 2, [3, 4, 5]]，原对象的嵌套列表被修改了！ # 3. 深拷贝 deep_copied = copy.deepcopy(original) deep_copied[2].append(6) print(original) # 输出: ['X', 2, [3, 4, 5]]，原对象保持不变。 print(deep_copied) # 输出: ['X', 2, [3, 4, 5, 6]] ``` ### 5. 函数参数传递：共享传参 Python的函数参数传递既不是“值传递”，也不是“引用传递”，而是 **“共享传参”或“对象引用传递”**。函数接收的是实参对象引用的副本[ref_1][ref_5]。 * 这意味着，在函数内部**重新赋值**形参（改变其引用）不会影响外部实参。 * 但是，如果形参引用的是一个**可变对象**，并对其进行了**原地修改**，那么这个修改会反映到外部实参上。 **代码示例：函数传参的影响** ```python def modify_data(num, alist): num = 100 # 对不可变对象重新赋值，只改变局部引用，不影响外部 alist.append(99) # 对可变对象进行原地修改，外部可见 x = 10 my_list = [1, 2] modify_data(x, my_list) print(x) # 输出: 10 (未变) print(my_list) # 输出: [1, 2, 99] (已变) ``` ### 6. 内存管理与垃圾回收 Python通过自动内存管理来释放不再使用的堆内存，主要机制包括： * **引用计数**：每个对象都有一个计数器，记录指向它的引用数量。当引用计数降为0时，对象会被立即回收。这是最主要且及时的回收机制[ref_6]。 * **标记-清除**：用于解决**循环引用**问题（例如，两个对象互相引用，但已无外部引用）。垃圾回收器会定期扫描，标记无法从根对象访问到的对象，并清除它们[ref_6]。 * **分代回收**：基于“年轻对象更可能很快死去”的假设，将对象按存活时间分为不同代（0，1，2代）。年轻代（第0代）的回收频率最高，以提高回收效率[ref_6]。