深浅拷贝详解

关于深浅拷贝的 4 句话:

    1. 所谓的深浅拷贝, 指的是: 拷贝的多与少.  深拷贝拷贝的多, 浅拷贝拷贝的少.
    2. 深浅拷贝都可以操作可变 和 不可变类型, 但是深浅拷贝一般不会操作不可变类型, 且你遇到的面试题几乎都是: 深浅拷贝操作可变类型.
    3. 回顾可变和不可变类型, 划分依据: 在不改变地址值的情况下, 是否可以修改内容, 可以 => 可变类型, 不可以 => 不可变类型.
        可变类型:   列表, 字典, 集合
        不可变类型: 字符串, 整数, 浮点型, 元组, 布尔...
    4. 所谓的深浅拷贝, 指的就是 copy 模块的不同函数.
        浅拷贝: copy.copy()
        深拷贝: copy.deepcopy()

普通赋值-代码讲解

"""
深拷贝和浅拷贝介绍:
    概述:
        大白话解释就是 深拷贝拷贝的多, 浅拷贝拷贝的少.
    细节(记忆):
        1. 深浅拷贝区别就是: 拷贝的层级的多与少.
        2. 深浅拷贝都能操作可变类型 和 不可变类型, 但是深浅拷贝一般操作的都是 可变类型, 几乎不会出操作不可变类型的.
        3. 回顾, 我们之前学过 可变类型 和 不可变类型的划分依据: 在不改变地址值的情况下, 元素值是否可以发生改变, 可以: 可变类型, 不可以: 不可变类型.
            可变类型:   列表, 字典, 集合
            不可变类型:  整型, 浮点型, 字符串, 布尔型, 元组
        4. 深浅拷贝指的是 copy模块下的不同的函数.
            浅拷贝: copy.copy()
            深拷贝: copy.deepcopy()
"""

# 需求: 演示可变和不可变类型.
# a = 10
# print(id(a))    # 140711071459392
# a = 20          # 内容变了.
# print(id(a))    # 140711071459712, 内容变了, 地址值也变了 = 不可变类型.
# print('-' * 31)
#
# list1 = [11, 22, 33]
# print(id(list1))    # 1675417267008
# list1[1] = 200
# print(id(list1))    # 1675417267008
# print(list1)        # [11, 200, 33], 内容变了, 地址值没变 = 可变类型.

# python的赋值操作属于引用赋值(eg:b是a的别名, 形参是实参的别名)
def dm01_普通赋值():
    # 1 python中的赋值操作, 属于引用赋值 (把a的地址赋值给b)
    # 2 b是a的别名, b和a都指向相同的内存空间
    a = 10
    b = a
    print('id(a)-->', id(a))    # 1
    print('id(b)-->', id(b))    # 1
    print('id(10)-->', id(10))  # 1

    # 3 也是引用赋值 c和d指向相同的内存空间
    a = [1, 2, 3]
    b = [11, 22, 33]
    c = [a, b]
    d = c
    print('id(c)-->', id(c))    # 2
    print('id(d)-->', id(d))    # 2

    # 4 值的方式赋值 a 指向一块内存空间、b 也指向一块内存空间
    # b = a python中不支持, 这样做传参效率高

dm01_普通赋值()

浅拷贝-代码讲解

import copy


# 需求1: 浅拷贝可变类型: 只拷贝第1层数据, 深层次数据不拷贝
def dm02_浅拷贝可变类型():
    a = [1, 2, 3]
    b = [11, 22, 33]
    c = [6, 7, a, b]

    # 测试1 id(c)和id(d)
    d = copy.copy(c)
    print('id(c)-->', id(c))    # 1
    print('id(d)-->', id(d))    # 2
    print("id(c)和id(d)值不一样, 说明浅拷贝第1层(最外面一层的数据)")

    # 测试2
    print(id(c[2])) # 3
    print(id(a))    # 3
    print("id(c[2])和id(a)值一样, 说明浅拷贝第2层的数据")

    # 修改a[2] = 22
    a[2] = 22
    print('c->', c)  # [6, 7, [1, 2, 22], [11, 22, 33]]
    print('d->', d)  # [6, 7, [1, 2, 22], [11, 22, 33]]

# dm02_浅拷贝可变类型()



# 浅拷贝不可变类型: 不会给拷贝的对象c开辟新的内存空间,
# 而只是拷贝了这个对象的引用
def dm03_浅拷贝不可变类型():

    # 不可变类型 a b c
    a = (1, 2, 3)
    b = (11, 22, 33)
    c = (6, 7, a, b)

    d = copy.copy(c)
    print('id(c)-->', id(c))    # 1
    print('id(d)-->', id(d))    # 1
    print("id(c)和id(d)值一样, 说明c和d指向相同的内存空间")
    # 不可变类型本身值都是不能被修改的,没有再浪费内存空,
    # 所以程序员要copy不可变类型,
    # python解释器直接返回值地址(别名/引用)

dm03_浅拷贝不可变类型()

深拷贝-代码讲解

import copy


# 需求1: 深拷贝可变类型: 只要是可变类型, 每一层都会拷贝.
def dm02_深拷贝可变类型():
    a = [1, 2, 3]
    b = [11, 22, 33]
    c = [6, 7, a, b]

    # 测试1 id(c)和id(d)
    d = copy.deepcopy(c)
    print('id(c)-->', id(c))    # 1
    print('id(d)-->', id(d))    # 2

    # 测试2
    print(id(c[2])) # 3
    print(id(a))    # 3

    # 修改a[2] = 22
    a[2] = 22
    print('c->', c)  # [6, 7, [1, 2, 22], [11, 22, 33]]
    print('d->', d)  # [6, 7, [1, 2, 3], [11, 22, 33]]

# dm02_深拷贝可变类型()



# 深拷贝不可变类型: 不会给拷贝的对象c开辟新的内存空间, 而只是拷贝了这个对象的引用
def dm03_深拷贝不可变类型():

    # 不可变类型 a b c
    a = (1, 2, 3)
    b = (11, 22, 33)
    c = (6, 7, a, b)

    d = copy.deepcopy(c)
    print('id(c)-->', id(c))    # 1
    print('id(d)-->', id(d))    # 1
    print("id(c)和id(d)值一样, 说明c和d指向相同的内存空间")
    # 不可变类型本身值都是不能被修改的,没有再浪费内存空,
    # 所以程序员要copy不可变类型,
    # python解释器直接返回值地址(别名/引用)

dm03_深拷贝不可变类型()