在Python中，请记住：

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

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

菲利克斯已经给出了一个很好的答案，但我想我应该对各种方法进行速度比较：

10.59秒（105.9µs/itn）-copy.depcopy（旧列表）10.16秒（101.6µs/itn）-纯Python Copy（）方法使用deepcopy复制类1.488秒（14.88µs/itn）-纯Python Copy（）方法不复制类（仅dicts/lists/tuples）0.325秒（3.25µs/itn）-对于old_list:new_list.append（项目）中的项目0.217秒（2.17µs/itn）-[i代表old_list]（列表理解）0.186秒（1.86µs/itn）-复制副本（old_list）0.075秒（0.75µs/itn）-列表（旧列表）0.053秒（0.53µs/itn）-新列表=[]；新列表扩展（旧列表）0.039秒（0.39µs/itn）-old_list[：]（列表切片）

所以最快的是列表切片。但请注意，与copy.deepcopy（）和python版本不同，copy.copy（）、list[：]和list（list）不会复制列表中的任何列表、字典和类实例，因此如果原始列表发生变化，它们也会在复制的列表中发生变化，反之亦然。

（如果有人感兴趣或想提出任何问题，以下是脚本：）

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

请注意，在某些情况下，如果您定义了自己的自定义类，并且希望保留这些属性，则应使用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

在已经给出的答案中，缺少了一个独立于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

所有其他贡献者都给出了很好的答案，当你有一个单一维度（水平化）列表时，这些方法是有效的，但是在目前提到的方法中，只有copy.deepcopy（）可以克隆/复制列表，而当你使用多维嵌套列表（列表列表）时，它不会指向嵌套列表对象。虽然菲利克斯·克林在他的回答中提到了这一点，但这个问题还有一点问题，可能还有一个使用内置程序的解决方案，这可能会证明是深度复制的更快替代方案。

虽然new_list=old_list[：]，copy.copy（old_list）'和Py3k old_list.copy（）适用于单层列表，但它们恢复为指向嵌套在old_list和new_list中的列表对象，对其中一个列表对象的更改将在另一个列表中永久化。

编辑：新信息曝光

正如Aaron Hall和PM 2Ring所指出的那样，使用eval（）不仅是一个坏主意，而且比copy.deepcopy（）慢得多。这意味着，对于多维列表，唯一的选项是copy.deepcopy（）。尽管如此，当您尝试在中等大小的多维数组上使用它时，它确实不是一个选项，因为性能会下降。我尝试使用42x42阵列来计时，这是前所未闻的，甚至对于生物信息学应用程序来说也是如此之大，我放弃了等待响应，只是开始在这篇文章中输入我的编辑。似乎唯一真正的选择就是初始化多个列表并独立处理它们。如果有人对如何处理多维列表复制有任何其他建议，将不胜感激。

正如其他人所说的那样，在多维列表中使用copy模块和copy.devcopy存在严重的性能问题。

使用对象[：]

>>> a = [1,2]
>>> b = a[:]
>>> a += [3]
>>> a
[1, 2, 3]
>>> b
[1, 2]
>>>