12、解刨深浅拷贝

1、直接赋值 =

完全不创建对象，只是创建一个新的引用指向同一个对象，修改任何一个对象会影响其他变量

2、浅拷贝copy

• 只复制第一层对象
• 内部的可变对象仍然共享引用

     # 以下四种方式效果相同

     import copy

     old_list=[1,2,3]
     new_list = old_list.copy()
     new_list = copy.copy(old_list)
     new_list = list(old_list)
     new_list = old_list[:]

3 深拷贝 deepcopy

• 递归复制所有层级的对象

• 创建一个完全独立的副本

import copy

new_list = copy.deepcopy(old_list)

快速记忆方法：

1. 想象一个带有抽屉的柜子：

• 赋值 = 给柜子贴上新标签

• 浅拷贝 = 复制柜子但抽屉内容共享

• 深拷贝 = 复制柜子和所有抽屉内容

代码澄清：

"""
Python深浅拷贝
作用：展示Python中的深浅拷贝原理
"""


#######################
# 1. 深浅拷贝详解      #
#######################
def copy_demo():
    import copy

    print("1. 深浅拷贝示例：")
    print("-" * 50)

    # 1.1 原始数据
    # 创建一个包含可变对象的列表
    original = [1, [2, 3], {"name": "Python"}]
    print(f"原始数据: {original}")
    print(f"原始数据内部列表的ID: {id(original[1])}")
    print(f"原始数据内部字典的ID: {id(original[2])}")

    print("\n1.2 赋值引用（完全不复制）：")
    print("-" * 30)
    # 赋值操作只是创建新的引用，指向同一个对象
    reference = original
    reference[0] = 100  # 修改会影响原始数据
    print(f"引用后修改: {reference}")
    print(f"原始数据: {original}")
    print(f"是否是同一个对象: {reference is original}")  # True

    print("\n1.3 浅拷贝（复制第一层）：")
    print("-" * 30)
    # 浅拷贝：只复制第一层对象，内部对象仍然共享引用
    shallow_copy = copy.copy(original)
    # 或使用其他浅拷贝方法
    # shallow_copy = original.copy()  # 列表的copy方法
    # shallow_copy = list(original)   # 使用构造函数
    # shallow_copy = original[:]      # 切片操作

    # 修改第一层，不影响原始数据
    shallow_copy[0] = 200
    print(f"修改第一层后 - 浅拷贝: {shallow_copy}")
    print(f"修改第一层后 - 原始数据: {original}")

    # 修改内部对象，会影响原始数据
    shallow_copy[1].append(4)
    print(f"修改内部对象后 - 浅拷贝: {shallow_copy}")
    print(f"修改内部对象后 - 原始数据: {original}")
    print(f"内部列表是否是同一个对象: {shallow_copy[1] is original[1]}")  # True

    print("\n1.4 深拷贝（完全复制）：")
    print("-" * 30)
    # 深拷贝：递归复制所有层级的对象
    deep_copy = copy.deepcopy(original)

    # 修改任何层级都不影响原始数据
    deep_copy[1].append(5)
    deep_copy[2]["age"] = 20
    print(f"修改后 - 深拷贝: {deep_copy}")
    print(f"修改后 - 原始数据: {original}")
    print(f"内部列表是否是同一个对象: {deep_copy[1] is original[1]}")  # False

    print("\n1.5 快速记忆规则：")
    print("-" * 30)
    print("1) 赋值操作(=)：完全不复制，只是新建引用")
    print("2) 浅拷贝：只复制第一层，内部对象共享")
    print("   - list.copy()")
    print("   - dict.copy()")
    print("   - copy.copy()")
    print("3) 深拷贝：递归复制所有层级")
    print("   - copy.deepcopy()")


# 运行示例
if __name__ == "__main__":
    copy_demo()

打印结果说明，便于理解含义：

1. 深浅拷贝示例：
--------------------------------------------------
原始数据: [1, [2, 3], {'name': 'Python'}]
原始数据内部列表的ID: 4352391168
原始数据内部字典的ID: 4352002880

1.2 赋值引用（完全不复制）：
------------------------------
引用后修改: [100, [2, 3], {'name': 'Python'}]
原始数据: [100, [2, 3], {'name': 'Python'}]
是否是同一个对象: True

1.3 浅拷贝（复制第一层）：
------------------------------
修改第一层后 - 浅拷贝: [200, [2, 3], {'name': 'Python'}]
修改第一层后 - 原始数据: [100, [2, 3], {'name': 'Python'}]
修改内部对象后 - 浅拷贝: [200, [2, 3, 4], {'name': 'Python'}]
修改内部对象后 - 原始数据: [100, [2, 3, 4], {'name': 'Python'}]
内部列表是否是同一个对象: True

1.4 深拷贝（完全复制）：
------------------------------
修改后 - 深拷贝: [100, [2, 3, 4, 5], {'name': 'Python', 'age': 20}]
修改后 - 原始数据: [100, [2, 3, 4], {'name': 'Python'}]
内部列表是否是同一个对象: False

1.5 快速记忆规则：
------------------------------
1) 赋值操作(=)：完全不复制，只是新建引用
2) 浅拷贝：只复制第一层，内部对象共享
   - list.copy()
   - dict.copy()
   - copy.copy()
3) 深拷贝：递归复制所有层级
   - copy.deepcopy()