1.普通赋值-代码讲解
```python
"""
深拷贝和浅拷贝介绍:
概述:
大白话解释就是 深拷贝拷贝的多, 浅拷贝拷贝的少.
细节(记忆):
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_普通赋值()
```
2.浅拷贝-代码讲解
```python
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_浅拷贝不可变类型()
```
3.深拷贝-代码讲解
```python
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_深拷贝不可变类型()
```