Python 内存模型深度解析：从地址、堆栈到深浅拷贝

• 栈：存储局部变量、函数参数，由操作系统自动分配/释放，速度快；
• 堆：存储动态分配的对象，由程序员手动管理，速度慢。

但Python 的内存模型是'栈存引用，堆存对象'：

• 所有 Python 对象（整数、字符串、列表、字典等）都存储在堆上；
• 栈上只存储对象的内存地址（引用/指针）；
• Python 的自动垃圾回收（GC）机制统一管理堆上对象的生命周期，程序员无需手动管理。

代码验证：

def func():
    a = [1,2,3] # 栈上存储 a 指向的内存地址，堆上存储 [1,2,3] 对象
    print(f"函数内 a 的地址：{id(a)}") # 示例：140703383221696

func() # 函数执行完毕后，栈上的 a 被销毁，但堆上的 [1,2,3] 对象若没有其他引用，会被 GC 回收

a = [1,2,3] # 堆上再次创建 [1,2,3] 对象，但地址与函数内不同
print(f"函数外 a 的地址：{id(a)}") # 示例：140703383221760

1.3 Python 的内存优化：小整数池与字符串驻留

为了节省内存和提高性能，Python 会对部分对象进行预创建或缓存。

小整数池

Python 启动时会预创建 -5 到 256 的整数对象，这些对象会被所有代码共享，永远不会被 GC 回收。

代码验证：

x = 256
y = 256
print(f"x 的地址：{id(x)}") # 示例：140703383430720
print(f"y 的地址：{id(y)}") # 与 x 相同：140703383430720
print(f"x is y：{x is y}") # True

x = 257
y = 257
print(f"x 的地址：{id(x)}") # 示例：140703383430752
print(f"y 的地址：{id(y)}") # 示例：140703383430784（不同地址）
print(f"x is y：{x is y}") # False（257 不在小整数池内）

字符串驻留

Python 会对满足条件的字符串进行'驻留'（缓存），避免重复创建。条件是：

• 字符串仅包含字母、数字、下划线；
• 字符串长度一般不超过 20 个字符。

代码验证：

x = "abc123"
y = "abc123"
print(f"x is y：{x is y}") # True（满足驻留条件）

x = "abc 123" # 包含空格，不满足驻留条件
y = "abc 123"
print(f"x is y：{x is y}") # False

注意：不要用 is 比较字符串的相等性，永远用 ==—— 字符串驻留的规则复杂且依赖 Python 版本，无法保证。

二、可变类型 VS 不可变类型 ——Python 最核心的特性

2.1 定义与分类

• 不可变类型：对象创建后，值无法修改，修改时会创建新的对象，原对象的内存地址不变；
• 可变类型：对象创建后，值可以修改，修改时不会创建新的对象，原对象的内存地址不变。

分类表：

2.2 不可变类型：修改即创建新对象

代码验证（int 类型）：

x = 10
print(f"x=10 的地址：{id(x)}") # 示例：140703383430720
x += 5 # 修改不可变类型，创建新对象
print(f"x=15 的地址：{id(x)}") # 示例：140703383430880（新地址）
print(f"x 的当前值：{x}") # 15

代码验证（str 类型）：

s = "hello"
print(f"s='hello'的地址：{id(s)}") # 示例：140703383221696
s += " world" # 创建新字符串对象
print(f"s='hello world'的地址：{id(s)}") # 示例：140703383221760（新地址）

代码验证（tuple 类型）：

t = (1,2)
print(f"t=(1,2)的地址：{id(t)}") # 示例：140703383221824
# t[0] = 3 → 报错：TypeError: 'tuple' object does not support item assignment（不可修改）

2.3 可变类型：修改即更新原对象

代码验证（list 类型）：

a = [1,2,3]
print(f"a=[1,2,3]的地址：{id(a)}") # 示例：140703383221888
a.append(4) # 修改可变类型，更新原对象
print(f"a=[1,2,3,4]的地址：{id(a)}") # 仍然是 140703383221888
a[0] = 10 # 修改元素，地址不变
print(f"a=[10,2,3,4]的地址：{id(a)}") # 140703383221888

代码验证（dict 类型）：

d = {"name": "张三", "age": 20}
print(f"d 的地址：{id(d)}") # 示例：140703383221952
d["age"] = 21 # 修改值，地址不变
print(f"d 的地址：{id(d)}") # 140703383221952
d["city"] = "北京" # 添加键值对，地址不变
print(f"d 的地址：{id(d)}") # 140703383221952

2.4 特殊案例：tuple 里的 list（最容易踩的坑！）

tuple 是不可变类型，但如果 tuple 的元素是可变类型（比如 list），则可以修改这个可变元素的内容—— 这是因为 tuple 的'不可变'是指元素的引用不可变，而非元素本身的内容不可变。

代码验证：

t = ([1,2], 3) # tuple 包含一个 list
print(f"t 的地址：{id(t)}") # 示例：140703383222080
print(f"t 的内容：{t}") # ([1,2], 3)

# 修改 tuple 里的 list 内容
t[0].append(3)
print(f"t 的地址：{id(t)}") # 仍然是 140703383222080
print(f"t 的内容：{t}") # ([1,2,3], 3)（内容变了！）

# 尝试修改 tuple 的元素引用 → 报错
# t[0] = [4,5] → TypeError: 'tuple' object does not support item assignment

避坑指南：永远不要在 tuple 里放可变类型，否则会导致'不可变'的语义失效。

三、引用与赋值 ——Python 没有'值赋值'！

3.1 引用是什么？

在 Python 中，'引用'是指向堆上对象的内存地址（类比 C/C++ 的指针，但 Python 不允许直接操作指针）。所有赋值操作都是引用赋值—— 没有'值赋值'的概念。

3.2 赋值的本质：拷贝引用，而非拷贝值

代码验证：

a = [1,2,3]
b = a # 拷贝 a 的引用，b 与 a 指向同一个对象
print(f"a 的地址：{id(a)}") # 示例：140703383222144
print(f"b 的地址：{id(b)}") # 140703383222144
print(f"a is b：{a is b}") # True

# 修改 b，a 也会变
b.append(4)
print(f"a 的内容：{a}") # [1,2,3,4]
print(f"b 的内容：{b}") # [1,2,3,4]

3.3 函数传参的本质：引用传递

Python 的函数传参是引用传递—— 不是值传递，也不是指针传递。也就是说，函数内部的参数是外部对象的引用，修改这个参数会影响外部对象（如果是可变类型）。

代码验证（可变类型）：

def modify_list(lst):
    lst.append(4) # 修改原对象

a = [1,2,3]
modify_list(a)
print(f"外部 a 的内容：{a}") # [1,2,3,4]（被修改了！）

代码验证（不可变类型）：

def modify_int(x):
    x += 5 # 创建新对象，不会影响外部

b = 10
modify_int(b)
print(f"外部 b 的内容：{b}") # 10（未被修改）

避坑指南：若不想让函数修改外部可变对象，需在函数内部拷贝参数。

3.4 值相等（==）VS 身份相等（is）的区别

• ==：值相等—— 比较两个对象的内容是否相同；
• is：身份相等—— 比较两个对象的内存地址是否相同。

代码验证：

a = [1,2,3]
b = [1,2,3]
print(f"a == b：{a == b}") # True（内容相同）
print(f"a is b：{a is b}") # False（不同内存地址）

x = None
y = None
print(f"x is y：{x is y}") # True（None 是单例对象，只有一个内存地址）

最佳实践：

• 用 == 比较字符串、列表、字典等的内容；
• 用 is 比较 None、True、False 等单例对象。

四、浅拷贝与深拷贝 —— 解决'牵一发而动全身'的问题

4.1 为什么需要拷贝？

因为 Python 的赋值是引用赋值，当我们需要修改一个对象，但不想影响原对象时，就需要拷贝。常见场景：

• 函数传参时，避免修改外部对象；
• 保存对象的历史状态；
• 处理嵌套数据结构时，避免内层修改影响外层。

4.2 浅拷贝：copy.copy ()—— 只拷贝第一层结构

浅拷贝仅拷贝对象的第一层结构，对于嵌套对象（如 [[1,2], [3,4]]），只会拷贝它们的引用，不会拷贝实际内容。

代码验证：

import copy

# 嵌套列表
a = [[1,2], [3,4]]
b = copy.copy(a) # 浅拷贝

print(f"a 的地址：{id(a)}") # 示例：140703383222208
print(f"b 的地址：{id(b)}") # 示例：140703383222272（新地址，浅拷贝成功）
print(f"a is b：{a is b}") # False

# 嵌套对象的引用仍然相同
print(f"a[0] 的地址：{id(a[0])}") # 示例：140703383222336
print(f"b[0] 的地址：{id(b[0])}") # 140703383222336（同一个地址）
print(f"a[0] is b[0]：{a[0] is b[0]}") # True

# 修改 b 的嵌套对象，a 也会变
b[0][0] = 5
print(f"a 的内容：{a}") # [[5,2], [3,4]]（a 被修改了！）
print(f"b 的内容：{b}") # [[5,2], [3,4]]

4.3 深拷贝：copy.deepcopy ()—— 递归拷贝所有层级

深拷贝会递归拷贝对象的所有层级，包括嵌套的对象，拷贝后的对象与原对象完全独立，修改任何层级的内容都不会影响原对象。

代码验证：

import copy

a = [[1,2], [3,4]]
c = copy.deepcopy(a) # 深拷贝

print(f"a 的地址：{id(a)}") # 示例：140703383222208
print(f"c 的地址：{id(c)}") # 示例：140703383222400（新地址）
print(f"a is c：{a is c}") # False

# 嵌套对象也被拷贝了
print(f"a[0] 的地址：{id(a[0])}") # 示例：140703383222336
print(f"c[0] 的地址：{id(c[0])}") # 示例：140703383222464（新地址）
print(f"a[0] is c[0]：{a[0] is c[0]}") # False

# 修改 c 的嵌套对象，a 不变
c[0][0] = 1
print(f"a 的内容：{a}") # [[5,2], [3,4]]（a 未被修改）
print(f"c 的内容：{c}") # [[1,2], [3,4]]

4.4 哪些操作是浅拷贝？

除了 copy.copy()，Python 还有以下内置的浅拷贝操作：

• 列表的 copy() 方法：a.copy()；
• 字典的 copy() 方法：d.copy()；
• 切片操作：a[:]；
• 构造函数：list(a)、dict(d)、set(s)。

代码验证：

a = [[1,2], [3,4]]
b = a.copy() # 浅拷贝
c = a[:] # 浅拷贝
d = list(a) # 浅拷贝

print(f"b[0] is a[0]：{b[0] is a[0]}") # True
print(f"c[0] is a[0]：{c[0] is a[0]}") # True
print(f"d[0] is a[0]：{d[0] is a[0]}") # True

4.5 深浅拷贝的性能对比

深拷贝需要递归拷贝所有层级的对象，因此比浅拷贝慢很多。在不需要深拷贝的场景下，应尽量使用浅拷贝或赋值。

代码验证：

import copy
import time

# 创建一个复杂的嵌套列表（1000×1000）
a = [[i for i in range(1000)] for _ in range(1000)]

# 浅拷贝时间
start = time.time()
b = copy.copy(a)
end = time.time()
print(f"浅拷贝时间：{end - start:.4f}秒") # 约 0.0001 秒

# 深拷贝时间
start = time.time()
c = copy.deepcopy(a)
end = time.time()
print(f"深拷贝时间：{end - start:.4f}秒") # 约 0.1 秒（慢 1000 倍！）

五、工程化应用与避坑指南

5.1 函数传参的拷贝策略

代码验证（嵌套结构传参）：

import copy

def process_config(config):
    # 深拷贝，避免修改外部配置
    config_copy = copy.deepcopy(config)
    config_copy["db"]["port"] = 3307 # 修改数据库端口
    return config_copy

# 原配置
config = {"db": {"host": "localhost", "port": 3306}}
service_config = process_config(config)

print(f"原配置端口：{config['db']['port']}") # 3306（未被修改）
print(f"服务配置端口：{service_config['db']['port']}") # 3307

5.2 避免将可变类型作为函数默认参数

坑点：函数默认参数在函数定义时就创建，而非在调用时创建。如果默认参数是可变类型，会导致所有调用共享同一个对象。

错误示例：

def func(lst=[]):
    lst.append(1)
    return lst

print(func()) # [1]
print(func()) # [1,2]（共享同一个列表！）
print(func()) # [1,2,3]

正确示例：

def func(lst=None):
    if lst is None:
        lst = [] # 每次调用都创建新列表
    lst.append(1)
    return lst

print(func()) # [1]
print(func()) # [1]
print(func()) # [1]

5.3 嵌套数据结构的处理

• 若需要完全独立的副本：用深拷贝；
• 若只需要第一层独立：用浅拷贝；
• 若允许共享所有层级：用引用赋值。

代码验证（配置文件场景）：

# 全局配置
global_config = {
    "server": {"port": 8080},
    "log": {"level": "INFO"}
}

# 服务 1 配置：完全独立，修改不影响全局
import copy
service1_config = copy.deepcopy(global_config)
service1_config["server"]["port"] = 8081

# 服务 2 配置：仅第一层独立，日志配置与全局共享
service2_config = copy.copy(global_config)
service2_config["server"]["port"] = 8082

print(f"全局端口：{global_config['server']['port']}") # 8080
print(f"服务 1 端口：{service1_config['server']['port']}") # 8081
print(f"服务 2 端口：{service2_config['server']['port']}") # 8082

5.4 常见坑点总结

六、总结

Python 的内存模型是其所有核心特性的基础，理解这些概念，可以帮助你：

1. 彻底解决'修改 A 导致 B 变'等诡异问题；
2. 写出更高效、更安全的代码；
3. 快速定位内存相关的 bug；
4. 理解 Python 的垃圾回收机制。

核心口诀：

• 所有对象在堆，栈存引用；
• 不可变类型修改即创建新对象，可变类型修改即更新原对象；
• 赋值是引用赋值，不是值赋值；
• 浅拷贝只拷贝第一层，深拷贝拷贝所有层级；
• 用 == 比内容，用 is 比身份。