Python 的所有变量其实都是指向内存中的对象的一个指针，这确实和之前学过的强类型语言（Java）是有不同的。在Java中基本数据类型数据直接存储在栈(stack)中，引用数据类型数据存储的是该对象在栈中引用，真实的数据存放在 堆内存 里，引用数据类型在栈中存储了指针，该指针指向堆中该实体的起始地址。当解释器寻找引用值时，会首先检索其在栈中的地址，取得地址后从堆中获得实体。

而在Python中因为变量是指针，所以所有的变量无类型限制，可以指向任意对象。指针的内存空间大小是与类型无关的，其内存空间只是保存了所指向数据的内存地址。

对象还分两类：一类是可修改的，一类是不可修改的。 可修改(mutable)的类型叫做值类型，不可修改(immutable)类型叫做引用类型。

不可变(immutable)对象类型

int，float，decimal，complex，bool，str，tuple，range，frozenset，bytes

可变(mutable)对象类型

list，dict，set，bytearray，user-defined classes (unless specifically made immutable)

为了探索对象在内存的存储，我们可以求助于Python的内置函数id()。它用于返回对象的身份(唯一标识符，标识符是一个整数）其实，这里所谓的身份，就是该对象的内存地址。

a = 1

print(id(a))

print(hex(id(a)))

在我的计算机上，它们返回的是:

11246696 '0xab9c68'

分别为内存地址的十进制和十六进制表示。

1. 浅拷贝和深拷贝的概念

以下分别是百度百科对浅拷贝和深拷贝的定义：

浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。即默认 拷贝构造函数 只是对对象进行浅拷贝复制(逐个成员依次拷贝)，即只复制对象空间而不复制资源。

深拷贝 会拷贝所有的属性，并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。深拷贝相比于浅拷贝速度较慢并且花销较大。

简单说就是：

浅拷贝只复制某个对象的引用，而不复制对象本身，新旧对象还是共享同一块内存。

深拷贝会创造一个一模一样的对象，新对象和原对象不共享内存，修改新对象不会改变原对对象。

在python中

浅拷贝(copy())：拷贝父对象，不会拷贝对象内部的子对象。

深拷贝(deepcopy())：是copy模块中的方法，完全拷贝了子对象和父对象

2. is和==的区别

python是一种面向对象的语言，python中对象包含三种基本要素：id(返回的是对象的地址)、type(返回的是对象的数据类型)及value(对象的值)。

is和==都可以对两个对象进行比较，而且它们的返回值都是布尔类型。但是它们比较的内容是不同的，不然两个函数的作用就重复了。首先我们来看下例子，从实际操作中来看下二者的区别。

从上面的例子可以得出，is和==比较的对象的内容时不同的，即：is比较的是两个对象的地址值，也就是说两个对象是否为同一个实例对象；而==比较的是对象的值是否相等，其调用了对象的__eq__()方法。

那么怎么才能让两个对象的地址值相等呢，如果想让一个对象ls2 is ls1返回True应该怎么操作呢，我们可以把ls1赋值给ls2，这样ls1和ls2指向的就是同一个内存地址，ls1 == ls2和ls1 is ls2返回的都是True。如下图所示：

3. 赋值操作

在上面提到了赋值操作， 在python中对象赋值实际上是对象的引用。当创建一个对象，然后把它赋值给另一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。

ls1 = ls赋值引用，ls1和ls都指向同一个对象。内存图如下所示：

综上，赋值操作只是 浅拷贝 传递对象的引用而已，原始列表改变，被赋值的变量也会做相同的改变，所以属于浅拷贝。

前面讲到python中分为可变类型和不可变类型，下面分别按照这2种类型介绍浅拷贝和深拷贝。

4. copy模块里面的copy()方法

可变类型和不可变类型在浅拷贝中的区别

# coding=utf-8
import copy
不可变类型Number String Tuple
num1 = 17
num2 = copy.copy(num1)
print("num1:" + str(id(num1)))
print("num2:" + str(id(num1)))
# num1和num2的地址都相同
str1 = "hello"
str2 = copy.copy(str1)
print("str1:" + str(id(str1)))
print("str2:" + str(id(str2)))
# str1和str2的地址都相同
tup1 = (18, "tom")
tup2 = copy.copy(tup1)
print("tup1:" + str(id(tup1)))
print("tup2:" + str(id(tup2)))
# tup1和tup2的地址都相同
可变类型List、Dictionary、Set
list1 = [11,12]
list2 = copy.copy(list1)
print("list1:" + str(id(list1)))
print("list2:" + str(id(list2)))
# list1和list2的地址不相同
dic1 = {"key": "hello", "num": 18}
dic2 = copy.copy(dic1)
print("dic1:" + str(id(dic1)))
print("dic2:" + str(id(dic2)))
# dic1和dic2的地址不相同
set1 = {"AA","BB"}
set2 = copy.copy(set1)
print("set1:" + str(id(set1)))
print("set2:" + str(id(set2)))
# set1和set2的地址不相同
输出结果：
num1:58549080
num2:58549080
str1:60653712
str2:60653712
tup1:60127112
tup2:60127112
list1:60101000
list2:60190344
dic1:60203624
dic2:60205528
set1:60064936
set2:60064712
从以上输出结果可以看到：
 
对于不可变类型 Number String Tuple，浅复制仅仅是地址指向，不会开辟新空间拷贝值
对于可变类型 List、Dictionary、Set，浅复制会开辟新的空间地址，进行浅拷贝
 
那如果对对象作出修改操作呢？
 
1）最外层的数据类型是不可变的，内层数据是可变的
 
import copy
最外层的数据类型是不可变的，内层数据是可变的
a=[34, 56]
b=[89, 37]
c=(a, b)
d=copy.copy(c)
print("c: %s" % str(c))
print("d: %s" % str(d))
print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))
print("id(c[0]): %s" % id(c[0]))
print("id(c[1]): %s" % id(c[1]))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))
a.append(90)
print("c: %s" % str(c))
print("d: %s" % str(d))
输出结果：
c: ([34, 56], [89, 37])
d: ([34, 56], [89, 37])
id(a): 56627592
id(b): 56639880
id(c): 56640648
id(d): 56640648
id(c[0]): 56627592
id(c[1]): 56639880
id(d[0]): 56627592
id(d[1]): 56639880
c: ([34, 56, 90], [89, 37])
d: ([34, 56, 90], [89, 37])
 
从以上输出结果可以看到，c=(a, b)的最外层是元组不可变类型，d在进行浅拷贝的时候，是直接引用c的地址，而不是再开辟新的地址空间存放。c=(a, b)的内层是列表可变类型，d在进行浅拷贝的时候，内层元素是引用的a和b的地址，也没有开辟新的地址空间存放。当a发生变化后，d也随之发生了变更。
 
2）最外层的数据类型是不可变的，内层数据也是不可变的
 
import copy
最外层的数据类型是不可变的，内层数据也是不可变的
a=(34, 56)
b=(89, 37)
c=(a, b)
d=copy.copy(c)
print("c: %s" % str(c))
print("d: %s" % str(d))
print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))
print("id(c[0]): %s" % id(c[0]))
print("id(c[1]): %s" % id(c[1]))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))
输出结果：
c: ((34, 56), (89, 37))
d: ((34, 56), (89, 37))
id(a): 59722120
id(b): 59722184
id(c): 59720840
id(d): 59720840
id(c[0]): 59722120
id(c[1]): 59722184
id(d[0]): 59722120
id(d[1]): 59722184
 
从以上输出结果可以看到，c=(a, b)的最外层是元组不可变类型，d在进行浅拷贝的时候，是直接引用c的地址，而不是再开辟新的地址空间存放。c=(a, b)的内层是不可变类型，d在进行浅拷贝的时候，内层元素是引用的a和b的地址，也没有开辟新的地址空间存放。
 
3）最外层的数据类型是可变的，内层数据也是可变的
 
import copy
最外层的数据类型是可变的，内层数据也是可变的
a=[34, 56]
b=[89, 37]
c=[a, b]
d=copy.copy(c)
print("c: %s" % c)
print("d: %s" % d)
print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))
a.append(90)
print("c: %s" % c)
print("d: %s" % d)
输出结果：
c: [[34, 56], [89, 37]]
d: [[34, 56], [89, 37]]
id(a): 59249032
id(b): 59261320
id(c): 59263624
id(d): 59338568
id(d[0]): 59249032
id(d[1]): 59261320
c: [[34, 56, 90], [89, 37]]
d: [[34, 56, 90], [89, 37]]
 
从以上输出结果可以看到，c=(a, b)的最外层是列表可变类型，d在进行浅拷贝的时候，是开辟了新的地址空间存放。c=(a, b)的内层是列表可变类型，d在进行浅拷贝的时候，内层元素是引用的a和b的地址，而没有开辟新的地址空间存放。当a发生变化后，d也随之发生了变更。
 
4）最外层的数据类型是可变的，内层数据是不可变的
 
import copy
浅拷贝是对一个对象父级（外层）的拷贝，并不会拷贝子级（内部）。
最外层的数据类型是可变的，内层数据是不可变的
a=(34, 56)
b=(89, 37)
c=[a, b]
d=copy.copy(c)
print("c: %s" % c)
print("d: %s" % d)
print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))
输出结果：
c: [(34, 56), (89, 37)]
d: [(34, 56), (89, 37)]
id(a): 52381896
id(b): 52381960
id(c): 52367752
id(d): 52448968
id(d[0]): 52381896
id(d[1]): 52381960
 
从以上输出结果可以看到，c=(a, b)的最外层是列表可变类型，d在进行浅拷贝的时候，是开辟了新的地址空间存放。c=(a, b)的内层是不可变类型，d在进行浅拷贝的时候，内层元素是引用的a和b的地址，而没有开辟新的地址空间存放。
 
综上，可以得出结论：
 
浅拷贝是对一个对象父级（外层）的拷贝，并不会拷贝子级（内部）。使用浅拷贝的时候，分为两种情况。
 第一种，如果最外层的数据类型是可变的，比如说列表，字典等，浅拷贝会开启新的地址空间去存放。
 第二种，如果最外层的数据类型是不可变的，比如元组，字符串等，浅拷贝对象的时候，还是引用对象的地址空间。
  
 
5. copy模块里面的deepcopy()方法
 
1）最外层的数据类型是不可变的，内层数据是可变的
 
import copy
最外层的数据类型是不可变的，内层数据是可变的
a=[34, 56]
b=[89, 37]
c=(a, b)
d=copy.deepcopy(c)
print("c: %s" % str(c))
print("d: %s" % str(d))
print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))
print("id(c[0]): %s" % id(c[0]))
print("id(c[1]): %s" % id(c[1]))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))
a.append(90)
print("c: %s" % str(c))
print("d: %s" % str(d))
输出结果：
c: ([34, 56], [89, 37])
d: ([34, 56], [89, 37])
id(a): 52367752
id(b): 52380040
id(c): 52380808
id(d): 52380872
id(c[0]): 52367752
id(c[1]): 52380040
id(d[0]): 52382472
id(d[1]): 52457160
c: ([34, 56, 90], [89, 37])
d: ([34, 56], [89, 37])
 
从以上输出结果可以看到，c=(a, b)的最外层是元组不可变类型，d在进行深拷贝的时候，是开辟了新的地址空间存放。c=(a, b)的内层是列表可变类型，d在进行深拷贝的时候，内层元素也开辟了新的地址空间存放。当a发生变化后，d并没有发生变更。
 
2）最外层的数据类型是不可变的，内层数据也是不可变的
 
import copy
最外层的数据类型是不可变的，内层数据也是不可变的
a=(34, 56)
b=(89, 37)
c=(a, b)
d=copy.deepcopy(c)
print("c: %s" % str(c))
print("d: %s" % str(d))
print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))
print("id(c[0]): %s" % id(c[0]))
print("id(c[1]): %s" % id(c[1]))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))
输出结果：
c: ((34, 56), (89, 37))
d: ((34, 56), (89, 37))
id(a): 48187848
id(b): 48187912
id(c): 48186504
id(d): 48186504
id(c[0]): 48187848
id(c[1]): 48187912
id(d[0]): 48187848
id(d[1]): 48187912
 
从以上输出结果可以看到，c=(a, b)的最外层是元组不可变类型，d在进行深拷贝的时候，是直接引用c的地址，而不是再开辟新的地址空间存放。c=(a, b)的内层是不可变类型，d在进行深拷贝的时候，内层元素是引用的a和b的地址，也没有开辟新的地址空间存放。
 
3）最外层的数据类型是可变的，内层数据也是可变的
 
import copy
最外层的数据类型是可变的，内层数据也是可变的
a=[34, 56]
b=[89, 37]
c=[a, b]
d=copy.deepcopy(c)
print("c: %s" % c)
print("d: %s" % d)
print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))
a.append(90)
print("c: %s" % c)
print("d: %s" % d)
输出结果：
c: [[34, 56], [89, 37]]
d: [[34, 56], [89, 37]]
id(a): 59380104
id(b): 59392392
id(c): 59394696
id(d): 59394824
id(d[0]): 59469512
id(d[1]): 59469768
c: [[34, 56, 90], [89, 37]]
d: [[34, 56], [89, 37]]
 
从以上输出结果可以看到，c=(a, b)的最外层是列表可变类型，d在进行深拷贝的时候，是开辟了新的地址空间存放。c=(a, b)的内层是列表可变类型，d在进行深拷贝的时候，内层元素也开辟了新的地址空间存放。当a发生变化后，d并没有发生变更。
 
4）最外层的数据类型是可变的，内层数据是不可变的
 
import copy
浅拷贝是对一个对象父级（外层）的拷贝，并不会拷贝子级（内部）。
最外层的数据类型是可变的，内层数据是不可变的
a=(34, 56)
b=(89, 37)
c=[a, b]
d=copy.deepcopy(c)
print("c: %s" % c)
print("d: %s" % d)
print("id(a): %s" % id(a))
print("id(b): %s" % id(b))
print("id(c): %s" % id(c))
print("id(d): %s" % id(d))
print("id(d[0]): %s" % id(d[0]))
print("id(d[1]): %s" % id(d[1]))
输出结果：
c: [(34, 56), (89, 37)]
d: [(34, 56), (89, 37)]
id(a): 45041928
id(b): 45041992
id(c): 45027720
id(d): 45040008
id(d[0]): 45041928
id(d[1]): 45041992
 
从以上输出结果可以看到，c=(a, b)的最外层是列表可变类型，d在进行深拷贝的时候，是开辟了新的地址空间存放。c=(a, b)的内层是不可变类型，d在进行深拷贝的时候，内层元素是引用的a和b的地址，而没有开辟新的地址空间存放。
 
综上，可以得出结论：
 
深拷贝对一个对象是所有层次的拷贝（递归），内部和外部都会被拷贝过来。
 深拷贝也分两种情况：
 第一种，最外层数据类型可变。外层的会新开辟地址空间存放。如果里面是可变数据类型，内部会新开辟地址空间存放。如果内部数据类型不可变，内部则是对地址的引用。
 第二种，外层数据类型不可变，如果内部数据是可变数据类型，外部和内部都会新开辟地址空间存放。如果内部数据类型不可变，外部和内部都是对地址的引用。
 
6.字典自带的copy方法
 
dict_1 = {"key1":[1,2,3,4],"key2":"val2"}
dict_2 = dict_1.copy()
dict_1["key1"].append(5)
print("id(dict_1)",id(dict_1),id(dict_1["key1"]),dict_1)
print("id(dict_2)",id(dict_2),id(dict_1["key1"]),dict_2)
输出结果：
('id(dict_1)', 43262840L, 48538120L, {'key2': 'val2', 'key1': [1, 2, 3, 4, 5]})
('id(dict_2)', 48598552L, 48538120L, {'key2': 'val2', 'key1': [1, 2, 3, 4, 5]})
 
可以看出，父对象被拷贝到了一个新内存地址，但是对于子对象只是引用了它的内存地址，并没有拷贝子对象里面可迭代的内容。如果子对象里面的内容修改后，被赋值的变量也会做相同的改变，所以字典中的copy方法属于浅拷贝。
 
7.切片表达式拷贝
 
num1 = [1, 2, 3, [4, 5]]
num2 = num1[:]
num1[0] = 0
num1.append(5)
num1[3].append(6)
print(num1, id(num1))
print(num2, id(num2))
print(num1[3], id(num1[3]))
print(num2[3], id(num2[3]))
输出结果：
([0, 2, 3, [4, 5, 6], 5], 57012616L)
([1, 2, 3, [4, 5, 6]], 57012744L)
([4, 5, 6], 57000328L)
([4, 5, 6], 57000328L)
 
由此可见，切片操作并没有复制可变类型的元素而是复制了可变类型的地址，相当于浅拷贝。
 
首先深拷贝和浅拷贝都是对象的拷贝，都会生成一个看起来相同的对象，他们本质的区别是拷贝出来的对象的地址是否和原对象一样
 (1)深拷贝：拷贝了一份与原对象不同地址的对象，修改对象中的任何值，都不会改变深拷贝的对象的值。
 (2)浅拷贝：对原对象值的拷贝，地址仍然指向原对象的地址，原对象的值发生变化，拷贝对象的值也会随着改变。
 (3)深拷贝和浅拷贝需要注意的地方是：可变元素的拷贝
 在浅拷贝时，拷贝出来的新对象的地址和原对象是不一样的，但是新对象里面的可变元素（如列表）的地址和原对象里的地址是相同的。也就是说浅拷贝它拷贝的是浅层次的数据结构（不可变元素），对象里的可变元素作为深层次的数据结构并没有被拷贝到新地址里面去，而是和原对象里的指向同一个地址。
 
下面解释可变类型和不可变类型的嵌套使用：
 
（1）可变类型:
 浅拷贝和深拷贝只要最外层是可变类型都会生成新的对象
 
[] 或者{}, 浅拷贝和深拷贝都会生成新的对象
[[],[]]列表的嵌套，可变类型嵌套了可变类型，浅拷贝：只拷贝最外层，会生成新的对象，内层是引用。深拷贝：外层和内层都会进行拷贝，都是全新的对象，都有独立的存储空间
[(),()] 外层可变，内层不可变，浅拷贝：只拷贝最外层，会生成新的对象，内层是引用。深拷贝：外层和内层都会进行拷贝，外层会生成新对象，但是由于内层是不可变类型，所以内层依然是引用
[(),[]] 外层可变，内层有一个是可变，浅拷贝：只拷贝最外层，会生成新的对象，内层是引用。深拷贝：外层和内层都会进行拷贝，外层会生成新对象，内层可变对象会生成新对象，内层不可变对象是引用
 
（2）不可变类型:
 最外层是不可变类型，浅拷贝就一定是引用
 
Number、字符串或者(), 浅拷贝和深拷贝都是引用
([],[]), copy浅拷贝：只会拷贝最外层，内层只是引用，但是最外层是不可变，拷贝之后毫无意义，仅仅是引用关系。deepcopy：从外层到内层都会拷贝，内层是可变，为了达到和原来的数据完全隔离，会生成全新的对象
((),()) 完全不可变，拷贝了之后如果生成新的数据也无法修改，所以不管深拷贝还是浅拷贝都是引用
((),[]) 外层不可变，但是内层有一个是可变，copy依然是引用，deepcopy,会生成新的对象，内层的不可变类型是引用，可变类型会生成新的对象。
 
参考文章：
 
python之浅拷贝和深拷贝的区别_埃菲尔没有塔尖的博客-CSDN博客_python 深拷贝和浅拷贝的区别
 
Python之中切片是浅拷贝吗？Python怎么实现浅拷贝 - 优草派
 
python赋值、深拷贝和浅拷贝的区别详解_测试小白00的博客-CSDN博客_python赋值和浅拷贝
 
python中的is和==区别_Tonywu2018的博客-CSDN博客_python is和==的区别
 
python3浅拷贝与深拷贝的区别和理解 - 简书
变量-引用-对象(可变对象，不可变对象)-切片-拷贝(浅拷贝，深拷贝)
【变量-对象-引用】
在Python中一切都是对象，比如说:3, 3.14, ‘Hello’, [1,2,3,4],{‘a’:1}……
甚至连type其本身都是对象，type对象
Python中变量与C/C++/Java中不同，它是指对象的引用，Python是动态类型，程序运行时候，会根据对象的类型
来确认变量到底是什么类型。
单独赋值： 比如说：
复制代码 代码如下:
>>> a = 3
在运行a=3后，变量a变成了对象3的一个引用。在内部，变量事实上是到对
				
一、前奏：熟悉Python内存管理
在Python中，变量在第一次赋值时自动声明，在创建---也就是赋值的时候，解释器会根据语法和右侧的操作数来决定新对象的类型。
引用计数器：一个内部跟踪变量
引用计数：每一个对象各有多少个引用
当对象被创建并(将其引用)赋值给变量时，该对象的引用计数就被设置为 1
>>> x = 3.14
语句 x=3.14，创建一个浮点型对象并将其引用赋值




    

				
在python中，对象赋值实际上是对象的引用。当创建一个对象，然后把它赋给另一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用
一般有三种方法，
alist=[1,2,3,["a","b"]]
（1）直接赋值,传递对象的引用而已,原始列表改变，被赋值的b也会做相同的改变
>>> b=list
>>> print b
[1, 2, 3, [...
				
首先深拷贝和浅拷贝都是对象的拷贝，都会生成一个看起来相同的对象，他们本质的区别是拷贝出来的对象的地址是否和原对象一样，也就是地址的复制还是值的复制的区别。
什么是可变对象，什么是不可变对象：
可变对象是指，一个对象在不改变其所指向的地址的前提下，可以修改其所指向的地址中的值；
不可变对象是指，一个对象所指向的地址上值是不能修改的，如果你修改了这个对象的值，那么它指向的地址就改...
				
深拷贝（deep copy）和浅拷贝（shallow copy）是Python中关于对象复制的两个概念。
浅拷贝是指创建一个新的对象，其内容是原始对象的引用。也就是说，新对象与原始对象共享内存地址，对其中一个对象的修改会影响到另一个对象。在Python中，可以使用`copy`模块的`copy()`函数或者对象的`copy()`方法进行浅拷贝。
深拷贝则是创建一个新的对象，完全复制原始对象及其所有嵌套对象的内容。也就是说，新对象与原始对象完全独立，互不影响。在Python中，可以使用`copy`模块的`deepcopy()`函数或者对象的`deepcopy()`方法进行深拷贝。
下面是一个简单的示例代码来说明深拷贝和浅拷贝的区别：
```python
import copy
# 原始对象
original_list = [1, 2, [3, 4]]
print("原始对象:", original_list)
# 浅拷贝
shallow_copy_list = copy.copy(original_list)
print("浅拷贝对象:", shallow_copy_list)
# 修改浅拷贝对象
shallow_copy_list[2][0] = 5
print("修改浅拷贝对象后，原始对象:", original_list)
print("修改浅拷贝对象后，浅拷贝对象:", shallow_copy_list)
# 深拷贝
deep_copy_list = copy.deepcopy(original_list)
print("深拷贝对象:", deep_copy_list)
# 修改深拷贝对象
deep_copy_list[2][1] = 6
print("修改深拷贝对象后，原始对象:", original_list)
print("修改深拷贝对象后，深拷贝对象:", deep_copy_list)
输出结果为：
原始对象: [1, 2, [3, 4]]
浅拷贝对象: [1, 2, [3, 4]]
修改浅拷贝对象后，原始对象: [1, 2, [5, 4]]
修改浅拷贝对象后，浅拷贝对象: [1, 2, [5, 4]]
深拷贝对象: [1, 2, [3, 4]]
修改深拷贝对象后，原始对象: [1, 2, [5, 4]]
修改深拷贝对象后，深拷贝对象: [1, 2, [3, 6]]
可以看到，对浅拷贝对象的修改会影响到原始对象，而对深拷贝对象的修改不会影响原始对象。
                Mysql 解决1251- Client does not support authentication protocol requested by server...的问题
                    汉书挂角: 
                    不是哥们，怎么变成错误1045了
                flask之url_for()函数解析
                    goocheez: 
                    请问，我的应用位于 /myapp 下，而不是 /，我应该如何让 url_for() 处理好这个问题？也就是说，如何让 url_for() 自动加上一个前缀？谢谢
我查了很多资料，最后找到的办法是直接重构该函数，然后使用自己重构过的 url_for，不好的地方是，每个模块都要引用一次自定义的 url_for，显得不够优雅。