Python对象拷贝案例如何深浅拷贝

本文目录导读：

1. 基础示例：包含可变对象的情况
2. 直观理解示意图
3. 不同拷贝方式的对比
4. 不可变对象的行为
5. 实际应用场景
6. 总结要点

我来用一个简单的例子来说明Python中的深拷贝和浅拷贝：

基础示例：包含可变对象的情况

import copy
# 创建一个包含列表的字典（可变对象）
original = {
    'name': 'Alice',
    'hobbies': ['reading', 'swimming'],
    'scores': {'math': 95, 'english': 88}
}
# 1. 浅拷贝
shallow_copy = copy.copy(original)
# 2. 深拷贝
deep_copy = copy.deepcopy(original)
# 修改原始数据中的可变对象
original['hobbies'].append('coding')
original['scores']['math'] = 100
print("原始数据:", original)
print("浅拷贝结果:", shallow_copy)
print("深拷贝结果:", deep_copy)

输出结果：

原始数据: {'name': 'Alice', 'hobbies': ['reading', 'swimming', 'coding'], 'scores': {'math': 100, 'english': 88}}
浅拷贝结果: {'name': 'Alice', 'hobbies': ['reading', 'swimming', 'coding'], 'scores': {'math': 100, 'english': 88}}
深拷贝结果: {'name': 'Alice', 'hobbies': ['reading', 'swimming'], 'scores': {'math': 95, 'english': 88}}

直观理解示意图

# 原始对象
original = {
    'name': 'Alice',       # 不可变对象 (字符串)
    'hobbies': ['reading']  # 可变对象 (列表)
}
# 浅拷贝：只拷贝第一层，内部引用共享
shallow = original  # ❌ 这是赋值，不是拷贝
shallow = original.copy()  # ✅ 浅拷贝：新字典，但hobbies指向同一个列表
# 深拷贝：完全独立的新对象
deep = copy.deepcopy(original)  # ✅ 新字典，新列表

不同拷贝方式的对比

import copy
class Person:
    def __init__(self, name, friend=None):
        self.name = name
        self.friend = friend
    def __repr__(self):
        return f"Person({self.name})"
# 创建循环引用示例
alice = Person("Alice")
bob = Person("Bob", alice)
alice.friend = bob  # 循环引用
# 四种拷贝方式
print("=== 不同拷贝方式对比 ===")
# 1. 普通赋值
assignment = alice
print(f"赋值: {assignment is alice}")  # True - 同一个对象
# 2. 浅拷贝
shallow = copy.copy(alice)
print(f"浅拷贝: {shallow is alice}")  # False - 新对象
print(f"浅拷贝friend: {shallow.friend is alice.friend}")  # True - 内部引用相同
# 3. 深拷贝
deep = copy.deepcopy(alice)
print(f"深拷贝: {deep is alice}")  # False - 新对象
print(f"深拷贝friend: {deep.friend is alice.friend}")  # False - 全部新对象

不可变对象的行为

# 对于只包含不可变对象的容器
immutable_data = (1, 2, 3)
string_data = "hello"
int_data = 42
# 浅拷贝和深拷贝结果相同
shallow_tuple = copy.copy(immutable_data)
deep_tuple = copy.deepcopy(immutable_data)
print(f"元组浅拷贝相同: {shallow_tuple is immutable_data}")  # True

实际应用场景

# 场景1：保护原始数据
def process_data(data):
    # 不想修改原始数据
    data_copy = copy.deepcopy(data)
    # 处理副本...
    return data_copy
# 场景2：快速复制（性能考量）
def quick_duplicate(config):
    # 如果config只有一层，用浅拷贝更高效
    if all(isinstance(v, (str, int, float)) for v in config.values()):
        return copy.copy(config)  # 快速
    else:
        return copy.deepcopy(config)  # 安全
# 场景3：拷贝自定义对象
class GameState:
    def __init__(self, level, inventory):
        self.level = level
        self.inventory = inventory  # 列表
    def clone(self):
        return copy.deepcopy(self)
# 使用
state = GameState(1, ["sword", "potion"])
saved_state = state.clone()  # 保存存档
state.inventory.append("shield")  # 不影响存档

总结要点

# 何时用浅拷贝？
# - 对象只有一层，没有嵌套可变对象
# - 不需要修改内部对象
# - 性能敏感，需要快速拷贝
# 何时用深拷贝？
# - 有嵌套可变对象
# - 需要完全独立的副本
# - 修改副本不影响原始数据
# 性能对比
import time
# 浅拷贝快
start = time.time()
for _ in range(10000):
    copy.copy(original)
print(f"浅拷贝: {time.time() - start:.4f}s")
# 深拷贝慢（递归复制所有层）
start = time.time()
for _ in range(10000):
    copy.deepcopy(original)
print(f"深拷贝: {time.time() - start:.4f}s")

简单记忆：

• 浅拷贝：新瓶子，旧酒（内部引用不变）
• 深拷贝：新瓶子，新酒（完全独立）