• 直接赋值：其实就是对象的引用（别名）。新老变量同时指向同一片内存，对新变量所做的任何修改都会连带修改老变量

• 浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。对象的内部的子对象还是直接赋值，所以如果修改父对象，不会对原变量的父对象造成影响，但是修改如果内部的子对象，则会连带修改原对象的子对象，因为共用一个引用。

• 深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。父对象和内部子对象都拷贝到新空间，对新变量所做的任何修改，不会对原变量 a 造成任何影响

直接赋值案例

直接赋值，新老变量同时指向同一片内存，对新变量所做的任何修改都会连带修改老变量

# 直接赋值，新老变量同时指向同一片内存，对新变量所做的任何修改都会连带修改老变量
a = {1: [1, 2, 3]}
b = a
# 修改父对象，给父对象添加元素，同时影响 a 和 b
b[2] = [4, 5, 6]
print("a=%s\tb=%s" % (a, b)) # a={1: [1, 2, 3], 2: [4, 5, 6]}  b={1: [1, 2, 3], 2: [4, 5, 6]}

# 修改内部子对象，给子对象添加元素，同时影响 a 和 b
b[1].append(7)
print("a=%s\tb=%s" % (a, b)) # a={1: [1, 2, 3, 7], 2: [4, 5, 6]}       b={1: [1, 2, 3, 7], 2: [4, 5, 6]}

浅拷贝案例

浅拷贝，拷贝父对象到新空间，对象的内部的子对象还是直接赋值，所以如果修改父对象，不会对原变量的父对象造成影响，但是修改如果内部的子对象，则会连带修改原对象的子对象，因为共用一个引用。

import copy
a = {1: [1, 2, 3]}
b = copy.copy(a)  # 等同于 b = a.copy()
# 修改父对象，给父对象添加元素，只影响 b，不影响 a
b[2] = [4, 5, 6]
print("a=%s\tb=%s" % (a, b)) # a={1: [1, 2, 3]}        b={1: [1, 2, 3], 2: [4, 5, 6]}

# 修改对象内部子对象，给子对象添加元素，同时影响 a 和 b
b[1].append(7)
print("a=%s\tb=%s" % (a, b)) # a={1: [1, 2, 3, 7]}     b={1: [1, 2, 3, 7], 2: [4, 5, 6]}

深拷贝案例

深拷贝，父对象和内部子对象都拷贝到新空间，对新变量所做的任何修改，不会对原变量 a 造成任何影响

# 深拷贝，父对象和内部子对象都拷贝到新空间，对新变量所做的任何修改，不会对原变量 a 造成任何影响
import copy
a = {1: [1, 2, 3]}
b = copy.deepcopy(a)
# 修改父对象，给父对象添加元素，只影响 b，不影响 a
b[2] = [4, 5, 6]
print("a=%s\tb=%s" % (a, b)) # a={1: [1, 2, 3]}        b={1: [1, 2, 3], 2: [4, 5, 6]}

# 修改对象内部子对象，给子对象添加元素，只影响 b，不影响 a
b[1].append(7)
print("a=%s\tb=%s" % (a, b)) # a={1: [1, 2, 3]}        b={1: [1, 2, 3, 7], 2: [4, 5, 6]}

参考：Python 直接赋值、浅拷贝和深度拷贝解析