可能重复：
对象和基本类型的分配
a = [1,2,3]
b = a
print b is a
此代码打印 True。为什么？"is" 仅在两个变量指向同一个对象时才返回 True，在这种情况下，它们是具有相同值的不同对象。"==" 将返回 True，但 "is" 不应该。
然而，由于
b.reverse()
print a,b
prints [3, 2, 1] [3, 2, 1]，似乎就解释器而言，它们是同一个对象，对b的操作将自动在a上执行。再说一遍，为什么？我以前从未见过这样的事情发生。
a = [81, 82, 83]
b = a
print(a is b) #prints True
这就是这里实际发生的事情：
对于类似的东西：
a = [81,82,83]
b = [81,82,83]
print(a is b) # False
print(a == b) #True, as == only checks value equality
In [24]: import sys
In [25]: a=[1,2,3]
In [26]: sys.getrefcount(a) #number of references to [1,2,3] are 2
Out[26]: 2
In [27]: b=a #now b also points to [1,2,3]
In [28]: sys.getrefcount(a) # reference to [1,2,3] got increased by 1,
# as b now also points to [1,2,3]
Out[28]: 3
In [29]: id(a)
Out[29]: 158656524 #both have the same id(), that's why "b is a" is True
In [30]: id(b)
Out[30]: 158656524
何时使用该copy模块：
In [1]: a=[1,2,3]
In [2]: b=a
In [3]: id(a),id(b)
Out[3]: (143186380, 143186380) #both point to the same object
In [4]: b=a[:] #now use slicing, it is equivalent to b=copy.copy(a)
# or b= list(a)
In [5]: id(a),id(b)
Out[5]: (143186380, 143185260) #as expected both now point to different objects
# so now changing one will not affect other
In [6]: a=[[1,2],[3,4]] #list of lists
In [7]: b=a[:] #use slicing
In [8]: id(a),id(b) #now both point to different object as expected
# But what about the internal lists?
Out[8]: (143184492, 143186380)
In [11]: [(id(x),id(y)) for (x,y) in zip(a,b)] #so internal list are still same objects
#so doing a[0][3]=5, will changes b[0] too
Out[11]: [(143185036, 143185036), (143167244, 143167244)]
In [12]: from copy import deepcopy #to fix that use deepcopy
In [13]: b=deepcopy(a)
In [14]: [(id(x),id(y)) for (x,y) in zip(a,b)] #now internal lists are different too
Out[14]: [(143185036, 143167052), (143167244, 143166924)]
更多细节：
In [32]: def func():
....: a=[1,2,3]
....: b=a
....:
....:
In [34]: import dis
In [35]: dis.dis(func)
2 0 LOAD_CONST 1 (1)
3 LOAD_CONST 2 (2)
6 LOAD_CONST 3 (3)
9 BUILD_LIST 3
12 STORE_FAST 0 (a) #now 'a' poits to [1,2,3]
3 15 LOAD_FAST 0 (a) #load the object referenced by a
18 STORE_FAST 1 (b) #store the object returned by a to b
21 LOAD_CONST 0 (None)
24 RETURN_VALUE
In [36]: def func1():
....: a=[1,2,3]
....: b=[1,2,3]
....:
....:
In [37]: dis.dis(func1) #here both a and b are loaded separately
2 0 LOAD_CONST 1 (1)
3 LOAD_CONST 2 (2)
6 LOAD_CONST 3 (3)
9 BUILD_LIST 3
12 STORE_FAST 0 (a)
3 15 LOAD_CONST 1 (1)
18 LOAD_CONST 2 (2)
21 LOAD_CONST 3 (3)
24 BUILD_LIST 3
27 STORE_FAST 1 (b)
30 LOAD_CONST 0 (None)
33 RETURN_VALUE
当您这样做时，a = [1, 2, 3]您将名称绑定a到列表对象。当您这样做时b = a，您将名称绑定b到任何a内容 - 在本例中为列表对象。因此，它们是相同的...一个对象可以有多个名称。值得一读Python 数据模型。
如果您想制作 listobj 的副本，那么您可以考虑b = a[:]使用 slice 来创建浅拷贝，或者copy.copy用于浅拷贝（应该适用于任意对象），或者copy.deepcopy奇怪的是 - 深拷贝。
您还会注意到 CPython 中有一些令人惊讶的东西，它缓存了短字符串/小整数......
>>> a = 4534534
>>> b = a
>>> a is b
True
>>> b = 4534534
>>> a is b
False
>>> a = 1
>>> b = a
>>> a is b
True
>>> b = 1
>>> a is b
True
它们实际上引用的是同一个对象。
试试这个：
a = [1,2,3]
b = a
print b is a
b[0] = 0
print b is a
您将看到 a 和 b 都已更改并且彼此仍然相同。
我不确定列表是否同样有效，但可以从关于浅拷贝和深拷贝的 numpy.array() 教程中查看：http ://www.scipy.org/Tentative_NumPy_Tutorial#head-1529ae93dd5d431ffe3a1001a4ab1a394e70a5f2
a = b只需创建对同一对象的新引用。要获得真正的副本，您可能会发现列表对象具有类似于链接中的深层复制示例的内容b = a.copy()。然后你可以说有 2 个对具有相同值的两个单独对象的引用。
此外，我认为大多数 OO 语言都是这样工作的，因为它=只是创建一个新的引用而不是一个新的对象。
此代码打印 True。为什么？
因为b is a.
"is" 仅在两个变量指向同一个对象时才返回 True
如果他们命名相同的对象。“指向”是一种粗俗的术语，暗示了一种低得多的编程模型。
在这种情况下，它们是具有相同值的不同对象。
不，他们不是。
在 Python 中，b = a意味着“b将不再是它当前名称的名称，如果有的话，并成为a当前名称的名称”。同一个对象。不是副本。
事情不会在 Python 中被隐式复制。
打印 [3, 2, 1] [3, 2, 1]，似乎就解释器而言，它们是同一个对象
因为他们是。
b 上的操作会自动在 a 上执行。
因为它们是同一个对象。
再说一遍，为什么？
再次，因为他们是。
...就好像你想到了每一个明显的测试来确认行为，但是一旦每一个测试都与你的核心假设相矛盾，就拒绝拒绝你的核心假设，即使文献中没有任何东西支持你的核心假设（因为事实上它是错误的） .
我以前从未见过这样的事情发生。
那么你一定从来没有在 Python 中测试过这样的东西，因为它在 Python 中一直都是这样工作的。在编程语言中甚至没有那么奇怪。Java 对所有非原始类型的东西都做同样的事情，而 C# 对类（引用类型）做同样的事情，同时对结构（值类型）做你显然期望的事情。它被称为“引用语义”，这绝不是一个新想法。
a = [1,2,3]
b = a
print b is a
您正在比较相同的引用list。如果您执行以下操作：
a = [1,2,3]
b = [1,2,3]
print b is a
你应该得到一个错误。