Python 变量赋值陷阱：浅拷贝与深拷贝解析

Python 变量赋值陷阱：浅拷贝与深拷贝解析 | 极客日志

# 示例 1：整数（不可变）
x = 10
y = x  # y 和 x 指向同一块内存（存储 10 的地址）
print(f"赋值后：x 的地址={id(x)}, y 的地址={id(y)}")  # 输出相同地址，如 2898567296528

# '修改'y：实际是创建新对象（存储 20），y 指向新地址
y = 20
print(f"修改后：x 的地址={id(x)}, y 的地址={id(y)}")  # x 地址不变，y 地址变化
print(f"x 的值={x}, y 的值={y}")  # 输出：x=10, y=20（x 不受影响）

# 示例 2：字符串（不可变）
s1 = "hello"
s2 = s1  # s2 和 s1 指向同一字符串
print(f"赋值后：s1 地址={id(s1)}, s2 地址={id(s2)}")  # 地址相同

# '修改's2：创建新字符串"hello world"，s2 指向新地址
s2 += " world"
print(f"修改后：s1={s1}, s2={s2}")  # 输出：s1=hello, s2=hello world（s1 不受影响）

# 示例 1：列表（可变）
a = [1, 2, 3]
b = a  # a 和 b 指向同一块内存（存储列表 [1,2,3] 的地址）
print(f"赋值后：a 地址={id(a)}, b 地址={id(b)}")  # 地址相同，如 2451458888256

# 修改 b 的元素：直接修改内存中的列表数据
b[0] = 100  # 改变列表第一个元素的值
print(f"修改后：a={a}, b={b}")  # 输出：a=[100,2,3], b=[100,2,3]（a 同步变化）
print(f"修改后：a 地址={id(a)}, b 地址={id(b)}")  # 地址仍相同（未创建新对象）

# 示例 2：字典（可变）
dict1 = {"name": "Alice", "age": 25}
dict2 = dict1  # 指向同一字典
dict2["age"] = 26  # 修改 dict2 的 age 字段
print(f"dict1={dict1}, dict2={dict2}")  # 输出：dict1={"name":"Alice","age":26}, dict2=...（同步变化）

# 小整数池示例：256 以内的整数复用内存
x = 100
y = 100
print(id(x) == id(y))  # 输出：True（指向同一对象）

x = 300  # 超出小整数池范围
y = 300
print(id(x) == id(y))  # 输出：False（创建两个不同对象）

# 字符串驻留示例：纯字母数字字符串复用
s1 = "python123"
s2 = "python123"
print(id(s1) == id(s2))  # 输出：True（复用缓存）

s1 = "python 123"  # 含空格，不满足驻留条件
s2 = "python 123"
print(id(s1) == id(s2))  # 输出：False（创建新对象）

对象类型	浅拷贝方法	示例
列表	1. `list.copy()` 2. 切片 `a[:]<br>3.` list(a)`	`a = [1,2,3]; b = a.copy()`
字典	1. `dict.copy()` 2. `dict(a)`	`a = {"k":1}; b = a.copy()`
集合	1. `set.copy()` 2. `set(a)`	`a = {1,2}; b = a.copy()`
通用对象	`copy` 模块的 `copy()` 函数	`import copy; b = copy.copy(a)`

import copy

# 原始列表（含嵌套列表，模拟'外层 + 内层'结构）
a = [1, 2, [3, 4]]  # 外层：[1,2, 内层列表]；内层：[3,4]

# 方法 1：list.copy()
b = a.copy()

# 方法 2：切片（最简洁，推荐）
c = a[:]

# 方法 3：list() 构造函数
d = list(a)

# 方法 4：copy 模块的 copy()（通用）
e = copy.copy(a)

# 验证：外层对象是新的（地址不同）
print(f"原列表 a 地址：{id(a)}")
print(f"拷贝后 b 地址：{id(b)}，与 a 是否相同：{id(b) == id(a)}")  # 输出：False
print(f"拷贝后 c 地址：{id(c)}，与 a 是否相同：{id(c) == id(a)}")  # 输出：False

import copy

# 原始列表：外层列表 + 内层嵌套列表（可变对象）
a = [1, 2, [3, 4]]
b = a.copy()  # 浅拷贝

# 场景 1：修改外层元素（互不影响）
b[0] = 100  # 修改 b 的外层元素（索引 0）
print(f"a 的外层：{a[0]}，b 的外层：{b[0]}")  # 输出：a=1，b=100（外层独立）
print(f"a 的完整列表：{a}，b 的完整列表：{b}")  # 输出：a=[1,2,[3,4]], b=[100,2,[3,4]]

# 场景 2：修改内层嵌套列表（同步变化）
b[2][0] = 300  # 修改 b 的内层列表（索引 2 是内层列表，再改索引 0）
print(f"\na 的内层列表：{a[2]}，b 的内层列表：{b[2]}")  # 输出：a=[300,4], b=[300,4]（同步变化）
print(f"a 的完整列表：{a}，b 的完整列表：{b}")  # 输出：a=[1,2,[300,4]], b=[100,2,[300,4]]

# 验证内层地址：a 和 b 的内层列表指向同一内存
print(f"\na 的内层列表地址：{id(a[2])}，b 的内层列表地址：{id(b[2])}")  # 地址相同

# 适用场景 1：单层列表（无嵌套）
a = [1, 2, 3]
b = a.copy()
b.append(4)  # 仅修改外层
print(f"a={a}, b={b}")  # 输出：a=[1,2,3], b=[1,2,3,4]（完全独立）

# 适用场景 2：内层是不可变对象（元组）
a = [1, "hi", (3,4)]
b = a.copy()
b[2] = (5,6)  # '修改'内层元组：实际创建新元组，不影响 a
print(f"a={a}, b={b}")  # 输出：a=[1,"hi",(3,4)], b=[1,"hi",(5,6)]（安全）

import copy

# 复杂嵌套对象：列表→字典→列表（多层可变对象）
a = [
    1,
    {"name": "Alice", "hobbies": ["reading", "coding"]},  # 内层字典 + 列表
    [5, 6, [7, 8]]  # 内层列表嵌套列表
]

# 深拷贝
b = copy.deepcopy(a)

# 验证：所有层级的地址均不同（完全独立）
print(f"外层地址：a={id(a)}, b={id(b)} → 不同")  # 外层不同
print(f"内层字典地址：a[1]={id(a[1])}, b[1]={id(b[1])} → 不同")  # 字典不同
print(f"字典内列表地址：a[1]['hobbies']={id(a[1]['hobbies'])}, b[1]['hobbies']={id(b[1]['hobbies'])} → 不同")  # 列表不同
print(f"深层列表地址：a[2][2]={id(a[2][2])}, b[2][2]={id(b[2][2])} → 不同")  # 深层列表不同

# 修改任意层级：均不影响原对象
b[0] = 100  # 修改外层
b[1]["name"] = "Bob"  # 修改内层字典
b[1]["hobbies"].append("running")  # 修改字典内的列表
b[2][2][0] = 700  # 修改深层列表

# 对比原对象和深拷贝对象
print(f"\n原对象 a：{a}")
print(f"深拷贝对象 b：{b}")  # 输出结果：a 的所有值未变，b 的修改完全独立

import copy
import time

# 构建复杂嵌套数据（1000 个内层列表，每层含 10 个元素）
complex_data = []
for i in range(1000):
    complex_data.append([j for j in range(10)])  # 外层列表 +1000 个内层列表

# 测试浅拷贝耗时
start = time.time()
shallow_copy = copy.copy(complex_data)
shallow_time = time.time() - start

# 测试深拷贝耗时
start = time.time()
deep_copy = copy.deepcopy(complex_data)
deep_time = time.time() - start

# 输出结果（单位：秒）
print(f"浅拷贝耗时：{shallow_time:.6f}")  # 约 0.0001 秒
print(f"深拷贝耗时：{deep_time:.6f}")  # 约 0.01 秒（慢 100 倍）
print(f"深拷贝比浅拷贝慢约{int(deep_time/shallow_time)}倍")

import copy

# 原始数据：多层嵌套字典（模拟配置文件场景）
original = {
    "app": "PythonCopyDemo",
    "settings": {
        "log": {
            "level": "INFO",
            "path": "./logs"
        },
        "timeout": [30, 60]  # 内层可变列表
    }
}

# 1. 赋值（引用传递）
assign_copy = original

# 2. 浅拷贝
shallow_copy = copy.copy(original)

# 3. 深拷贝
deep_copy = copy.deepcopy(original)

# 修改原始数据的 3 个层级
original["app"] = "ModifiedApp"  # 层级 1：外层字符串（不可变）
original["settings"]["log"]["level"] = "DEBUG"  # 层级 3：深层字典（可变）
original["settings"]["timeout"][0] = 10  # 层级 2：内层列表（可变）

# 对比结果
print("=== 1. 赋值（引用传递）===")
print(f"assign_copy['app']: {assign_copy['app']} → 同步修改（同对象）")
print(f"assign_copy['settings']['log']['level']: {assign_copy['settings']['log']['level']} → 同步修改")
print(f"assign_copy['settings']['timeout'][0]: {assign_copy['settings']['timeout'][0]} → 同步修改")

print("\n=== 2. 浅拷贝 ===")
print(f"shallow_copy['app']: {shallow_copy['app']} → 未修改（外层字符串不可变，创建新对象）")
print(f"shallow_copy['settings']['log']['level']: {shallow_copy['settings']['log']['level']} → 同步修改（内层共享）")
print(f"shallow_copy['settings']['timeout'][0]: {shallow_copy['settings']['timeout'][0]} → 同步修改（内层共享）")

print("\n=== 3. 深拷贝 ===")
print(f"deep_copy['app']: {deep_copy['app']} → 未修改")
print(f"deep_copy['settings']['log']['level']: {deep_copy['settings']['log']['level']} → 未修改（完全独立）")
print(f"deep_copy['settings']['timeout'][0]: {deep_copy['settings']['timeout'][0]} → 未修改（完全独立）")

特性维度	赋值（引用传递）	浅拷贝（copy()）	深拷贝（deepcopy()）
内存地址	与原对象完全相同	外层不同，内层相同	所有层级均不同
修改外层可变元素	原对象同步变化	原对象不变	原对象不变
修改内层可变元素	原对象同步变化	原对象同步变化	原对象不变
性能开销	无（仅复制引用）	小（仅复制外层）	大（递归复制所有层级）
适用场景	仅读数据，不修改	单层对象/内层不可变	多层嵌套可变对象
典型案例	函数传参（仅读）	单层列表去重	嵌套配置文件修改

import copy

def safe_modify(data):
    # 若 data 是单层对象，用浅拷贝
    # data_copy = data.copy()
    # 若 data 是嵌套对象，用深拷贝
    data_copy = copy.deepcopy(data)
    data_copy.append("modified")  # 修改拷贝后的对象
    return data_copy

# 测试嵌套列表
original = [1, 2, [3, 4]]
modified = safe_modify(original)
print(f"原列表：{original} → 未修改")  # 输出：[1,2,[3,4]]
print(f"修改后列表：{modified} → 已修改")  # 输出：[1,2,[3,4],"modified"]

import copy

# 默认配置（多层嵌套）
DEFAULT_CONFIG = {
    "db": {
        "host": "localhost",
        "port": 3306,
        "params": {"charset": "utf8"}
    },
    "timeout": 30
}

# 个性化配置：基于默认配置修改，不污染原配置
user_config = copy.deepcopy(DEFAULT_CONFIG)
user_config["db"]["host"] = "192.168.1.100"  # 修改数据库地址
user_config["db"]["params"]["charset"] = "utf8mb4"  # 修改内层参数

print(f"默认配置 db.host：{DEFAULT_CONFIG['db']['host']} → 仍为 localhost")
print(f"用户配置 db.host：{user_config['db']['host']} → 192.168.1.100")

def deduplicate(lst):
    # 浅拷贝：先复制列表，再去重（用集合去重后转列表）
    return list(set(lst.copy()))

original = [1, 2, 2, 3, 3, 3]
unique_lst = deduplicate(original)
print(f"原列表：{original} → 未修改")
print(f"去重后列表：{unique_lst} → [1,2,3]")

# 复杂数据：外层列表 +1000 个内层字典（仅需修改第 1 个内层字典）
big_data = [{"id": i, "value": i*10} for i in range(1000)]

# 手动部分拷贝：仅复制需要修改的内层字典，其他共享（性能高）
modified_data = big_data.copy()  # 浅拷贝外层
modified_data[0] = {"id": 0, "value": 999}  # 替换第 1 个内层字典（创建新对象）

print(f"原数据第 1 个元素：{big_data[0]} → 未修改")  # 输出：{"id":0,"value":0}
print(f"修改后第 1 个元素：{modified_data[0]} → 已修改")  # 输出：{"id":0,"value":999}

import copy

# 错误写法：默认参数是可变对象，多次调用共享
def add_item_wrong(item, lst=[]):
    lst.append(item)
    return lst

print(add_item_wrong(1))  # 输出：[1]
print(add_item_wrong(2))  # 输出：[1,2]（错误：共享列表）

# 正确写法：用 None+ 深拷贝，每次调用创建新对象
def add_item_correct(item, lst=None):
    if lst is None:
        lst = []
    lst_copy = copy.deepcopy(lst)  # 若 lst 是嵌套对象，用深拷贝
    lst_copy.append(item)
    return lst_copy

print(add_item_correct(1))  # 输出：[1]
print(add_item_correct(2))  # 输出：[2]（正确：独立列表）

Python 变量赋值陷阱：浅拷贝与深拷贝解析

1. 赋值的本质：不是值传递，而是引用传递

1.1 用 `id()` 函数看穿内存地址

场景 1：不可变对象的赋值（无副作用）

场景 2：可变对象的赋值（有副作用）

1.2 不可变对象的'特殊情况'：小整数池与字符串驻留

2. 浅拷贝（Shallow Copy）：只复制'外层壳子'

2.1 浅拷贝的 4 种实现方式

代码示例：列表的浅拷贝

2.2 浅拷贝的'隐形陷阱'：内层对象仍共享

代码演示：浅拷贝的内层共享问题

2.3 浅拷贝的适用场景

3. 深拷贝（Deep Copy）：复制'所有层级'的完全独立

3.1 深拷贝的实现：`copy.deepcopy()`

代码示例：深拷贝的完全独立性

3.2 深拷贝的性能代价：递归复制的开销

代码示例：浅拷贝 vs 深拷贝的性能对比

4. 浅拷贝 vs 深拷贝：3 分钟看懂核心区别

4.1 对比实验：修改不同层级的数据

4.2 核心区别总结表

5. 实战避坑：5 个高频场景的正确拷贝方式

场景 1：函数参数避免修改外部数据

场景 2：配置文件的个性化修改

场景 3：列表去重（单层对象，浅拷贝足够）

场景 4：性能敏感场景的'手动部分拷贝'

场景 5：避免'默认参数陷阱'

总结：3 步选择正确的拷贝方式

更多推荐文章

相关免费在线工具

Python 变量赋值陷阱：浅拷贝与深拷贝解析

1. 赋值的本质：不是值传递，而是引用传递

1.1 用 id() 函数看穿内存地址

场景 1：不可变对象的赋值（无副作用）

场景 2：可变对象的赋值（有副作用）

1.2 不可变对象的'特殊情况'：小整数池与字符串驻留

2. 浅拷贝（Shallow Copy）：只复制'外层壳子'

2.1 浅拷贝的 4 种实现方式

代码示例：列表的浅拷贝

2.2 浅拷贝的'隐形陷阱'：内层对象仍共享

代码演示：浅拷贝的内层共享问题

2.3 浅拷贝的适用场景

3. 深拷贝（Deep Copy）：复制'所有层级'的完全独立

3.1 深拷贝的实现：copy.deepcopy()

代码示例：深拷贝的完全独立性

3.2 深拷贝的性能代价：递归复制的开销

代码示例：浅拷贝 vs 深拷贝的性能对比

4. 浅拷贝 vs 深拷贝：3 分钟看懂核心区别

4.1 对比实验：修改不同层级的数据

4.2 核心区别总结表

5. 实战避坑：5 个高频场景的正确拷贝方式

场景 1：函数参数避免修改外部数据

场景 2：配置文件的个性化修改

场景 3：列表去重（单层对象，浅拷贝足够）

场景 4：性能敏感场景的'手动部分拷贝'

场景 5：避免'默认参数陷阱'

总结：3 步选择正确的拷贝方式

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具

1.1 用 `id()` 函数看穿内存地址

3.1 深拷贝的实现：`copy.deepcopy()`