如何在Python中创建对象的副本？

Question

我想创建一个对象的副本.我希望新对象拥有旧对象的所有属性(字段的值).但我想拥有独立的对象.因此,如果我更改新对象的字段值,则旧对象不应受此影响.

Answer 1

要获得对象的完全独立副本,可以使用该copy.deepcopy()功能.

有关浅层和深层复制的更多详细信息,请参阅此问题的其他答案以及相关问题的答案中的精彩解释.

Answer 2

如何在Python中创建对象的副本？

因此,如果我更改新对象的字段值,则旧对象不应受此影响.

你的意思是一个可变对象.

在Python 3中,列表得到一个copy方法(在2中,你使用切片来制作副本):

>>> a_list = list('abc')
>>> a_copy_of_a_list = a_list.copy()
>>> a_copy_of_a_list is a_list
False
>>> a_copy_of_a_list == a_list
True

浅拷贝

浅拷贝只是最外层容器的副本.

list.copy 是一个浅的副本:

>>> list_of_dict_of_set = [{'foo': set('abc')}]
>>> lodos_copy = list_of_dict_of_set.copy()
>>> lodos_copy[0]['foo'].pop()
'c'
>>> lodos_copy
[{'foo': {'b', 'a'}}]
>>> list_of_dict_of_set
[{'foo': {'b', 'a'}}]

您没有获得内部对象的副本.它们是同一个对象 - 所以当它们发生变异时,变化会出现在两个容器中.

深拷贝

深层副本是每个内部对象的递归副本.

>>> lodos_deep_copy = copy.deepcopy(list_of_dict_of_set)
>>> lodos_deep_copy[0]['foo'].add('c')
>>> lodos_deep_copy
[{'foo': {'c', 'b', 'a'}}]
>>> list_of_dict_of_set
[{'foo': {'b', 'a'}}]

更改不会反映在原始文件中,只会在副本中反映出来.

不可变的物体

通常不需要复制不可变对象.事实上,如果你尝试,Python将只给你原始的对象:

>>> a_tuple = tuple('abc')
>>> tuple_copy_attempt = a_tuple.copy()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'copy'

元组甚至没有复制方法,所以让我们尝试一下切片:

>>> tuple_copy_attempt = a_tuple[:]

但我们看到它是同一个对象:

>>> tuple_copy_attempt is a_tuple
True

对于字符串类似:

>>> s = 'abc'
>>> s0 = s[:]
>>> s == s0
True
>>> s is s0
True

而对于frozensets,即使他们有一个copy方法:

>>> a_frozenset = frozenset('abc')
>>> frozenset_copy_attempt = a_frozenset.copy()
>>> frozenset_copy_attempt is a_frozenset
True

何时复制不可变对象

如果需要复制可变内部对象,则应复制不可变对象.

>>> tuple_of_list = [],
>>> copy_of_tuple_of_list = tuple_of_list[:]
>>> copy_of_tuple_of_list[0].append('a')
>>> copy_of_tuple_of_list
(['a'],)
>>> tuple_of_list
(['a'],)
>>> deepcopy_of_tuple_of_list = copy.deepcopy(tuple_of_list)
>>> deepcopy_of_tuple_of_list[0].append('b')
>>> deepcopy_of_tuple_of_list
(['a', 'b'],)
>>> tuple_of_list
(['a'],)

我们可以看到,当复制的内部对象发生突变,原本就不会发生改变.

自定义对象

自定义对象通常将数据存储在__dict__属性中或__slots__(类似于元组的内存结构中).

要制作可复制对象,请定义__copy__(对于浅拷贝)和/或__deepcopy__(对于深拷贝).

from copy import copy, deepcopy

class Copyable:
    __slots__ = 'a', '__dict__'
    def __init__(self, a, b):
        self.a, self.b = a, b
    def __copy__(self):
        return type(self)(self.a, self.b)
    def __deepcopy__(self, memo): # memo is a dict of id's to copies
        id_self = id(self)        # memoization avoids unnecesary recursion
        _copy = memo.get(id_self)
        if _copy is None:
            _copy = type(self)(
                deepcopy(self.a, memo), 
                deepcopy(self.b, memo))
            memo[id_self] = _copy 
        return _copy

请注意,deepcopy将id(original)(或标识号)的备忘录字典保留为副本.要使用递归数据结构享受良好的行为,请确保您尚未制作副本,如果有,请返回该副本.

所以让我们做一个对象:

>>> c1 = Copyable(1, [2])

并copy制作一份浅色副本:

>>> c2 = copy(c1)
>>> c1 is c2
False
>>> c2.b.append(3)
>>> c1.b
[2, 3]

而deepcopy现在做了深刻的副本:

>>> c3 = deepcopy(c1)
>>> c3.b.append(4)
>>> c1.b
[2, 3]

Answer 3

浅拷贝 copy.copy()

#!/usr/bin/env python3

import copy

class C():
    def __init__(self):
        self.x = [1]
        self.y = [2]

# It copies.
c = C()
d = copy.copy(c)
d.x = [3]
assert c.x == [1]
assert d.x == [3]

# It's shallow.
c = C()
d = copy.copy(c)
d.x[0] = 3
assert c.x == [3]
assert d.x == [3]

深拷贝 copy.deepcopy()

#!/usr/bin/env python3
import copy
class C():
    def __init__(self):
        self.x = [1]
        self.y = [2]
c = C()
d = copy.deepcopy(c)
d.x[0] = 3
assert c.x == [1]
assert d.x == [3]

文档:https://docs.python.org/3/library/copy.html

在Python 3.6.5上测试.