new_list=my_list实际上并没有创建第二个列表。赋值只是将引用复制到列表，而不是实际的列表，因此new_list和my_list在赋值后都引用相同的列表。

要实际复制列表，您有几个选项：

您可以使用内置的list.copy（）方法（从Python 3.3开始提供）：new_list=old_list.copy（）您可以对其进行切片：new_list=旧列表[：]亚历克斯·马特利（Alex Martelli）（至少在2007年）对此的看法是，这是一种奇怪的语法，永远使用它都没有意义（在他看来，下一篇更具可读性）。您可以使用内置的list（）构造函数：new_list=列表（old_list）您可以使用泛型copy.copy（）：导入副本new_list=复制副本（old_list）这比list（）慢一点，因为它必须首先找到old_list的数据类型。如果您还需要复制列表中的元素，请使用genericcopy.deepcopy（）：导入副本new_list=复制.depcopy（old_list）显然是最慢、最需要内存的方法，但有时不可避免。这是递归操作；它将处理任意级别的嵌套列表（或其他容器）。

例子：

import copy

class Foo(object):
    def __init__(self, val):
         self.val = val

    def __repr__(self):
        return f'Foo({self.val!r})'

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(f'original: {a}\nlist.copy(): {b}\nslice: {c}\nlist(): {d}\ncopy: {e}\ndeepcopy: {f}')

结果：

original: ['foo', Foo(5), 'baz']
list.copy(): ['foo', Foo(5)]
slice: ['foo', Foo(5)]
list(): ['foo', Foo(5)]
copy: ['foo', Foo(5)]
deepcopy: ['foo', Foo(1)]

请注意，在某些情况下，如果您定义了自己的自定义类，并且希望保留这些属性，则应使用copy.copy（）或copy.deepcopy（），而不是其他选项，例如在Python 3中：

import copy

class MyList(list):
    pass

lst = MyList([1,2,3])

lst.name = 'custom list'

d = {
'original': lst,
'slicecopy' : lst[:],
'lstcopy' : lst.copy(),
'copycopy': copy.copy(lst),
'deepcopy': copy.deepcopy(lst)
}


for k,v in d.items():
    print('lst: {}'.format(k), end=', ')
    try:
        name = v.name
    except AttributeError:
        name = 'NA'
    print('name: {}'.format(name))

输出：

lst: original, name: custom list
lst: slicecopy, name: NA
lst: lstcopy, name: NA
lst: copycopy, name: custom list
lst: deepcopy, name: custom list

这是因为，行new_list=my_list为变量my_list分配了一个新的引用，即new_list这类似于下面给出的C代码，

int my_list[] = [1,2,3,4];
int *new_list;
new_list = my_list;

您应该使用复制模块创建新列表

import copy
new_list = copy.deepcopy(my_list)

deepcopy选项是唯一适用于我的方法：

from copy import deepcopy

a = [   [ list(range(1, 3)) for i in range(3) ]   ]
b = deepcopy(a)
b[0][1]=[3]
print('Deep:')
print(a)
print(b)
print('-----------------------------')
a = [   [ list(range(1, 3)) for i in range(3) ]   ]
b = a*1
b[0][1]=[3]
print('*1:')
print(a)
print(b)
print('-----------------------------')
a = [   [ list(range(1, 3)) for i in range(3) ] ]
b = a[:]
b[0][1]=[3]
print('Vector copy:')
print(a)
print(b)
print('-----------------------------')
a = [   [ list(range(1, 3)) for i in range(3) ]  ]
b = list(a)
b[0][1]=[3]
print('List copy:')
print(a)
print(b)
print('-----------------------------')
a = [   [ list(range(1, 3)) for i in range(3) ]  ]
b = a.copy()
b[0][1]=[3]
print('.copy():')
print(a)
print(b)
print('-----------------------------')
a = [   [ list(range(1, 3)) for i in range(3) ]  ]
b = a
b[0][1]=[3]
print('Shallow:')
print(a)
print(b)
print('-----------------------------')

导致输出：

Deep:
[[[1, 2], [1, 2], [1, 2]]]
[[[1, 2], [3], [1, 2]]]
-----------------------------
*1:
[[[1, 2], [3], [1, 2]]]
[[[1, 2], [3], [1, 2]]]
-----------------------------
Vector copy:
[[[1, 2], [3], [1, 2]]]
[[[1, 2], [3], [1, 2]]]
-----------------------------
List copy:
[[[1, 2], [3], [1, 2]]]
[[[1, 2], [3], [1, 2]]]
-----------------------------
.copy():
[[[1, 2], [3], [1, 2]]]
[[[1, 2], [3], [1, 2]]]
-----------------------------
Shallow:
[[[1, 2], [3], [1, 2]]]
[[[1, 2], [3], [1, 2]]]
-----------------------------

在已经给出的答案中，缺少了一个独立于python版本的非常简单的方法，您可以在大多数时间使用（至少我这样做）：

new_list = my_list * 1       # Solution 1 when you are not using nested lists

但是，如果my_list包含其他容器（例如，嵌套列表），则必须按照复制库中上述答案中的其他建议使用deepcopy。例如：

import copy
new_list = copy.deepcopy(my_list)   # Solution 2 when you are using nested lists

。奖励：如果您不想复制元素，请使用（AKA浅层复制）：

new_list = my_list[:]

让我们了解解决方案#1和解决方案#2之间的区别

>>> a = range(5)
>>> b = a*1
>>> a,b
([0, 1, 2, 3, 4], [0, 1, 2, 3, 4])
>>> a[2] = 55
>>> a,b
([0, 1, 55, 3, 4], [0, 1, 2, 3, 4])

正如您所看到的，当我们不使用嵌套列表时，解决方案#1工作得很好。让我们检查一下当我们将解决方案#1应用于嵌套列表时会发生什么。

>>> from copy import deepcopy
>>> a = [range(i,i+4) for i in range(3)]
>>> a
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]
>>> b = a*1
>>> c = deepcopy(a)
>>> for i in (a, b, c): print i
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]
>>> a[2].append('99')
>>> for i in (a, b, c): print i
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5, 99]]
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5, 99]]   # Solution #1 didn't work in nested list
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]       # Solution #2 - DeepCopy worked in nested list

在Python中，请记住：

    list1 = ['apples','bananas','pineapples']
    list2 = list1

List2没有存储实际的列表，而是对list1的引用。因此，当您对list1执行任何操作时，list2也会发生变化。使用copy模块（非默认，在pip上下载）制作列表的原始副本（对于简单列表，copy.copy（）；对于嵌套列表，copy。deepcopy（））。这将生成一个不会随第一个列表而更改的副本。