【Python】python深拷贝和浅拷贝（一）

【Python】python深拷贝和浅拷贝（一）

定义

• 直接赋值：其实就是对象的引用。
• 浅拷贝：拷贝父对象，不会拷贝对象的内部的子对象。
• 深拷贝： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。

浅拷贝：构造一个新的对象，尽可能的将原始对象中的所有找到的对象引用加入到新构造的对象中；

深拷贝：构造一个新的对象，然后递归的在原始对象中将找到的对象的副本插入其中。

• 有可能由于循环引用，可能会导致递归循环；
• 深层次有可能会复制过多的对象；

示例

直接赋值

arr = [1, 2, 3, 4]
arr1 = arr
id(arr), id(arr1)
---------------------
(2226394970240, 2226394970240)

结论：直接赋值只是将对对象的引用直接给了新的变量，没有在堆中构建一个新的对象。

浅拷贝

使用copy.copy()进行浅拷贝，浅复制可以理解为只对最高层对象进行一个复制，对其它层的对象只是引用。

list1 = [[1, 2, 3], [4, 5, 6]]
list2 = copy(list1)
print(id(list1), id(list2))
print(id(list1[0]), id(list2[0]))
print(id(list1[1]), id(list2[1]))

运行结果如下，可以发现list1和list2的内存地址并不相同，但是他们内部元素的地址是相同的，也证明了浅拷贝只对最高层对象进行复制，不会对子对象进行复制。

画图来看，copy方法只是构建了一个新的容器，其内部对堆中对象的引用被复制了，但是堆中的对象没有任何操作。

list1 = [[1, 2, 3], [4, 5, 6]]
list1.append("append")
print(list1, list2)

结果如下，证明最高层对象是真正在堆中创建了一个新的对象。

画图来看，list1和list2已经不是一个对象了。

上面的示例中，我们已经证明了对浅拷贝对象本身的操作是不会相互影响的。现在再看另一个示例

arr = [{1, 2, 3}, "aba", 4, {'a': 1, 'b': 2}]
arr1 = arr[:]

for i, j in zip(arr, arr1):
    print(id(i) == id(j))

从上面的示例可以看到，采用浅拷贝复制对象后，对象内部的所有子对象本质上都是同一个，那么对它们的操作必定会相互影响。

arr1[0].add(4)
arr1[3]['c'] = 3
arr, arr1

深拷贝

深拷贝可以理解为多层嵌套浅拷贝，需要调用deepcopy进行复制，示例如下：

list1 = [[1, 2, 3], [4, 5, 6], 7, "a"]
list2 = deepcopy(list1)
for i, j in zip(list1, list2):
    print(id(i), id(j))

可以看到，复制之后[1, 2, 3], [4, 5, 6]的地址已经不在相同，代表这两个对象都已经在堆中重新创建了一份。画图来看：

'a'以及7的引用是相同的，原因在于这些基础数字、字母在python启动的时候会进行缓存，在内存中有且只有一份。

源码分析

copy方法

1. 获取对象的类，这一点可以理解为调用__class__魔术方法；
2. 在已有的【_copy_dispatch】中获取现有的copier；
3. 如果在【_copy_dispatch】中没有现有的copier，那么先判断他是否是元类（MetaClass）创建的对象，即类（Class），如果是则调用_copy_immutable方法，处理方式和不可变对象一致；
4. 如果上述copier都是None，则检查对象的__copy__方法，如果存在该方法则调用该方法；
5. 使用序列化的方式进行拷贝…

def copy(x):
    """Shallow copy operation on arbitrary Python objects.

    See the module's __doc__ string for more info.
    """
	
    # 获取要复制对象的类型
    cls = type(x)
	
    # 获取对象的copier，如果copier不为空则使用它进行复制，本质上来说copier是一个Function对象。
    copier = _copy_dispatch.get(cls)
    if copier:
        return copier(x)

    if issubclass(cls, type):
        # treat it as a regular class:
        return _copy_immutable(x)
	
    # 如果对象的类实现了__copy__方法是调用该方法进行复制
    copier = getattr(cls, "__copy__", None)
    if copier is not None:
        return copier(x)
	
    # 使用序列化的方式进行复制，同样是先查看是否有现有的
    reductor = dispatch_table.get(cls)
    if reductor is not None:
        rv = reductor(x)
    else:
        reductor = getattr(x, "__reduce_ex__", None)
        if reductor is not None:
            rv = reductor(4)
        else:
            reductor = getattr(x, "__reduce__", None)
            if reductor:
                rv = reductor()
            else:
                raise Error("un(shallow)copyable object of type %s" % cls)

    if isinstance(rv, str):
        return x
    return _reconstruct(x, None, *rv)

# 定义了那些类型使用deepcopy_atomic作为copier
d[type(None)] = _deepcopy_atomic
d[type(Ellipsis)] = _deepcopy_atomic
d[type(NotImplemented)] = _deepcopy_atomic
d[int] = _deepcopy_atomic
d[float] = _deepcopy_atomic
d[bool] = _deepcopy_atomic
d[complex] = _deepcopy_atomic
d[bytes] = _deepcopy_atomic
d[str] = _deepcopy_atomic
d[types.CodeType] = _deepcopy_atomic
d[type] = _deepcopy_atomic
d[types.BuiltinFunctionType] = _deepcopy_atomic
d[types.FunctionType] = _deepcopy_atomic
d[weakref.ref] = _deepcopy_atomic
d[property] = _deepcopy_atomic

# 针对容器类型，在builtsin.py中定义了他们复制方式
d[list] = list.copy
d[dict] = dict.copy
d[set] = set.copy
d[bytearray] = bytearray.copy

# deepcopy_atomic会直接返回原始对象，这就是为什么int、str这种类型调用copy方法会返回原始对象
def _deepcopy_atomic(x, memo):
    return x

deepcopy

# 循环递归进行深拷贝，用dispatch_table保存类型:复制方法，判断每一个对象的类型并找到它的深拷贝方法。
# 利用memo放置循环
def deepcopy(x, memo=None, _nil=[]):
    """Deep copy operation on arbitrary Python objects.

    See the module's __doc__ string for more info.
    """
	
    # memo用来记录复制过的对象，避免循环引用无限复制
    if memo is None:
        memo = {}
	
    # 获取复制对象的id，检查memo中是否有相同的对象，如果有直接返回
    d = id(x)
    y = memo.get(d, _nil)
    if y is not _nil:
        return y
	
    # 整个复制流程和copy一致，不同点在于使用的复制方法不同，
    cls = type(x)

    copier = _deepcopy_dispatch.get(cls)
    if copier is not None:
        y = copier(x, memo)
    else:
        if issubclass(cls, type):
            y = _deepcopy_atomic(x, memo)
        else:
            copier = getattr(x, "__deepcopy__", None)
            if copier is not None:
                y = copier(memo)
            else:
                reductor = dispatch_table.get(cls)
                if reductor:
                    rv = reductor(x)
                else:
                    reductor = getattr(x, "__reduce_ex__", None)
                    if reductor is not None:
                        rv = reductor(4)
                    else:
                        reductor = getattr(x, "__reduce__", None)
                        if reductor:
                            rv = reductor()
                        else:
                            raise Error(
                                "un(deep)copyable object of type %s" % cls)
                if isinstance(rv, str):
                    y = x
                else:
                    y = _reconstruct(x, memo, *rv)

    # If is its own copy, don't memoize.
    if y is not x:
        memo[d] = y
        _keep_alive(x, memo) # Make sure x lives at least as long as d
    return y

# 元祖深拷贝
def _deepcopy_tuple(x, memo, deepcopy=deepcopy):
    y = [deepcopy(a, memo) for a in x]
    # We're not going to put the tuple in the memo, but it's still important we
    # check for it, in case the tuple contains recursive mutable structures.
    try:
        return memo[id(x)]
    except KeyError:
        pass
    for k, j in zip(x, y):
        if k is not j:
            y = tuple(y)
            break
    else:
        y = x
    return y
d[tuple] = _deepcopy_tuple

# 字典深拷贝方法
def _deepcopy_dict(x, memo, deepcopy=deepcopy):
    y = {}
    memo[id(x)] = y
    for key, value in x.items():
        y[deepcopy(key, memo)] = deepcopy(value, memo)
    return y
d[dict] = _deepcopy_dict
if PyStringMap is not None:
    d[PyStringMap] = _deepcopy_dict
    
# 列表深拷贝
def _deepcopy_list(x, memo, deepcopy=deepcopy):
    y = []
    memo[id(x)] = y
    append = y.append
    for a in x:
        append(deepcopy(a, memo))
    return y
d[list] = _deepcopy_list



if PyStringMap is not None:
    d[PyStringMap] = _deepcopy_dict

    
# 列表深拷贝

def _deepcopy_list(x, memo, deepcopy=deepcopy):
    y = []
    memo[id(x)] = y
    append = y.append
    for a in x:
        append(deepcopy(a, memo))
    return y
d[list] = _deepcopy_list

这是我们的公众号【朝阳三只大明白】，满满全是干货，三个信通硕士，一个方向互联网后端开发，一个方向互联网大数据开发，一个立志读博士，努力ing的科研人!分享近期学习知识以及个人总结，一起努力，一起加油!求关注！！