在总结 python 对象和引用的时候，想到其实 对于python的深拷贝和浅拷贝也可以很好对其的进行理解。
在python中，对象的赋值的其实就是对象的引用。也就是说，当创建一个对象，然后赋给另外一个变量之后，实际上只是拷贝了这个对象的引用。
我们先用 利用切片操作和工厂方法list方法 来阐述一下浅拷贝。
举个栗子：
Tom = ['Tom', ['age', 10]]
Jack = Tom[:] ……切片操作
June = list(Tom)
接下来查看一下 上述三个变量的引用：
>>> id(Tom)
140466700697824
>>> id(Jack)
140466700700488
>>> id(June)
140466700770192
可以发现，三个变量分别指向了不同的对象。我们再来看一下这三个对象的内容：
>>> Tom
['Tom', ['age', 10]]
>>> Jack
['Tom', ['age', 10]]
>>> June
['Tom', ['age', 10]]
显然这三个对象的内容会是一样的，因为通过上面的 切片操作 以及 工厂函数list 对Tom引用的对象进行了拷贝。接下来再进行进一步验证：
我们对 Jack 和 June 引用的对象进行修改：
>>> Jack[0] = 'Jack'
>>> Jack
['Jack', ['age', 10]]
>>> June[0] = 'June'
>>> June
['June', ['age', 10]]
现在我们打算对Jack的年龄进行修改：
>>> Jack[1][1] = 20
>>> Jack
['Jack', ['age', 20]]
可以看到Jack年龄变为了20； 让我们接下来看一下Tom， June的年龄：
>>> print Tom, Jack, June
['Tom', ['age', 20]] ['Jack', ['age', 20]] ['June', ['age', 20]]
奇怪的事情发生了，我们仅仅是修改了 Jack的年龄， 但是Tom 和 June 的年龄跟着改变了， 这是为什么呢？
这个就涉及到了python中浅拷贝的奥秘：
我们先来看一下上面 Tom， Jack， June中内部元素的 内存地址：
>>> for x in Tom:
... print id(x)
...
140704715293600 --> 'Tom'
140704715147816 --> ['age', 20]
>>> for x in Jack:
... print id(x)
...
140704715286256 --> 'Jack'
140704715147816 --> ['age', 20]
>>> for x in June:
... print id(x)
...
140704715286352 -->'June'
140704715147816 -->['age', 20]
仔细观察可以看到，Tom, Jack, June 三个变量的 岁数元素['age', 20] 指向同一个 对象； 那为什么他们的 名字元素 分别指向不同的对象。这是因为，在python中的分为 可变数据对象(列表，字典) 和 不可变数据对象(整型，字符串，浮点型，元祖)。 正是因为这个原因，他们的 名字元素 为字符串，为不可变数据对象，因此开始为 Jack 和 June 重新命名的时候，实际上内存中已经创建了 Jack 和 June对象。而 岁数元素 是 可变数据对象，所以并不会在内存中创建新的对象，Tom，Jack，June的岁数元素都引用同一个对象，导致修改其中一个会让另外俩个的年龄跟着变化。
这个就是python的浅拷贝，其仅仅是拷贝了 一个整体的对象(应该说一个对象最外面的那一层)，而对于对象里面包含的元素不会进行拷贝。
接下来，我们 利用copy中的deepcopy方法 来阐述一下 深拷贝：
还是用上面那个栗子：
为了让 Tom， Jack， June之间互不影响，我们用deepcopy方法对Tom进行拷贝生成 Jack 和 June：
>>> Tom = ['Tom', ['age', 10]]
>>> import copy
>>> Jack = copy.deepcopy(Tom)
>>> June = copy.deepcopy(Tom)
>>> Jack
['Tom', ['age', 10]]
>>> June
['Tom', ['age', 10]]
>>> Tom
['Tom', ['age', 10]]
让我们看一下Tom， Jack， June分别指向的内存地址：
>>> print id(Tom), id(June), id(Jack)
140707738759392 140707738799280 140707738797192
三个内存地址不同，然后我们接着改变Jack 和 June的名字，并查看修改后它们的内部元素所指向的内存地址：
>>> Jack[0] = 'Jack'
>>> June[0] = 'June'
>>> Tom
['Tom', ['age', 10]]
>>> Jack
['Jack', ['age', 10]]
>>> June
['June', ['age', 10]]
>>> for x in Tom:
... print id(x)
...
140707738882976 --> 'Tom'
140707738737192 --> ['age', 10]
>>> for x in Jack:
... print id(x)
...
140707738875584 --> 'Jack'
140707738910016 --> ['age', 10]
>>> for x in June:
... print id(x)
...
140707738876640 -->'June'
140707738910160 --> ['age', 10]
可以清楚的看到，他们的内部元素也指向了不同的对象，说明通过deepcopy方法，对元素进行了彻底的拷贝(包括内部元素)。
最后总结一下思路：
思路一：利用切片操作和工厂方法list方法拷贝就叫浅拷贝，只是拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。
思路二：利用copy中的deepcopy方法进行拷贝就叫做深拷贝，外围和内部元素都进行了拷贝对象本身，而不是引用。
但是对于数字，字符串和其他原子类型对象等，没有被拷贝的说法，即便是用深拷贝，查看id的话也是一样的，如果对其重新赋值，也只是新创建一个对象，替换掉旧的而已。