使用new_list = my_list ，您实际上没有两个列表。赋值仅复制对列表的引用，而不是实际列表，因此new_list和my_list在赋值后引用相同的列表。
要实际复制列表，您有各种可能性：
你可以使用内置的list.copy()方法（从 python 3.3 开始提供）：
new_list = old_list.copy()你可以切片：
new_list = old_list[:]Alex Martelli对此的看法（至少在 2007 年 ）是这样的， 它是一种奇怪的语法，并且永远使用它是没有意义的 。 ;）（在他看来，下一个更具可读性）。
您可以使用内置的list()函数：
new_list = list(old_list)您可以使用通用copy.copy() ：
import copy
new_list = copy.copy(old_list)这比list()慢一点，因为它必须首先找出old_list的数据类型。
如果列表包含对象并且您也想要复制它们，请使用通用copy.deepcopy() ：
import copy
new_list = copy.deepcopy(old_list)显然是最慢和最需要内存的方法，但有时是不可避免的。
例：
import copy
class Foo(object):
def __init__(self, val):
self.val = val
def __repr__(self):
return str(self.val)
foo = Foo(1)
a = ['foo', foo]
b = a.copy()
c = a[:]
d = list(a)
e = copy.copy(a)
f = copy.deepcopy(a)
# edit orignal list and instance
a.append('baz')
foo.val = 5
print('original: %r\n list.copy(): %r\n slice: %r\n list(): %r\n copy: %r\n deepcopy: %r'
% (a, b, c, d, e, f))结果：
original: ['foo', 5, 'baz']
list.copy(): ['foo', 5]
slice: ['foo', 5]
list(): ['foo', 5]
copy: ['foo', 5]
deepcopy: ['foo', 1]菲利克斯已经提供了一个很好的答案，但我想我会对各种方法进行速度比较：
copy.deepcopy(old_list) Copy()方法Copy()方法不复制类（只有 dicts / lists / tuples） for item in old_list: new_list.append(item) [i for i in old_list] （ 列表理解 ） copy.copy(old_list) list(old_list) new_list = []; new_list.extend(old_list) old_list[:] （ 列表切片 ） 所以最快的是列表切片。但请注意， copy.copy() ， list[:]和list(list)与copy.deepcopy()和 python 版本不同，不会复制列表中的任何列表，字典和类实例，因此如果原件发生更改，他们也会在复制的列表中进行更改，反之亦然。
（这是脚本，如果有人有兴趣或想提出任何问题:)
from copy import deepcopy
class old_class:
def __init__(self):
self.blah = 'blah'
class new_class(object):
def __init__(self):
self.blah = 'blah'
dignore = {str: None, unicode: None, int: None, type(None): None}
def Copy(obj, use_deepcopy=True):
t = type(obj)
if t in (list, tuple):
if t == tuple:
# Convert to a list if a tuple to
# allow assigning to when copying
is_tuple = True
obj = list(obj)
else:
# Otherwise just do a quick slice copy
obj = obj[:]
is_tuple = False
# Copy each item recursively
for x in xrange(len(obj)):
if type(obj[x]) in dignore:
continue
obj[x] = Copy(obj[x], use_deepcopy)
if is_tuple:
# Convert back into a tuple again
obj = tuple(obj)
elif t == dict:
# Use the fast shallow dict copy() method and copy any
# values which aren't immutable (like lists, dicts etc)
obj = obj.copy()
for k in obj:
if type(obj[k]) in dignore:
continue
obj[k] = Copy(obj[k], use_deepcopy)
elif t in dignore:
# Numeric or string/unicode?
# It's immutable, so ignore it!
pass
elif use_deepcopy:
obj = deepcopy(obj)
return obj
if __name__ == '__main__':
import copy
from time import time
num_times = 100000
L = [None, 'blah', 1, 543.4532,
['foo'], ('bar',), {'blah': 'blah'},
old_class(), new_class()]
t = time()
for i in xrange(num_times):
Copy(L)
print 'Custom Copy:', time()-t
t = time()
for i in xrange(num_times):
Copy(L, use_deepcopy=False)
print 'Custom Copy Only Copying Lists/Tuples/Dicts (no classes):', time()-t
t = time()
for i in xrange(num_times):
copy.copy(L)
print 'copy.copy:', time()-t
t = time()
for i in xrange(num_times):
copy.deepcopy(L)
print 'copy.deepcopy:', time()-t
t = time()
for i in xrange(num_times):
L[:]
print 'list slicing [:]:', time()-t
t = time()
for i in xrange(num_times):
list(L)
print 'list(L):', time()-t
t = time()
for i in xrange(num_times):
[i for i in L]
print 'list expression(L):', time()-t
t = time()
for i in xrange(num_times):
a = []
a.extend(L)
print 'list extend:', time()-t
t = time()
for i in xrange(num_times):
a = []
for y in L:
a.append(y)
print 'list append:', time()-t
t = time()
for i in xrange(num_times):
a = []
a.extend(i for i in L)
print 'generator expression extend:', time()-t 编辑 ：在基准测试中添加了新式，旧式类和 dicts，并使 python 版本更快，并添加了更多方法，包括列表表达式和extend() 。
我被告知 Python 3.3+ 添加了list.copy()方法，它应该像切片一样快：
newlist = old_list.copy()