QA测试开发工程师面试题满分问答3: python的深拷贝和浅拷贝问题

在 Python 中，深拷贝（deep copy）和浅拷贝（shallow copy）是用于创建对象副本的两种不同方式。

• 浅拷贝是创建一个新的对象，该对象与原始对象的内容相同（包括内部嵌套对象的引用），但是它们指向相同的内存地址。换句话说，浅拷贝创建了一个对象的表面副本，而不是递归复制所有嵌套对象。当原始对象包含可变对象（如列表、字典）时，对副本进行修改可能会影响原始对象。
• 深拷贝是创建一个全新的对象，该对象与原始对象内容相同，包括所有嵌套对象。深拷贝递归地复制所有嵌套对象，而不仅仅是创建一个表面副本。因此，对深拷贝对象的修改不会影响原始对象。

下面是深拷贝和浅拷贝的用途：

1. 浅拷贝适用于需要创建一个对象的快速副本，但不需要对副本进行深层次的修改。它可以节省内存和复制时间，特别是当对象包含大量数据或嵌套对象时。

2. 深拷贝适用于需要创建一个完全独立的对象，以便对副本进行修改而不会影响原始对象。它用于确保对象及其所有嵌套对象在修改时的独立性。

在 Python 中，可以使用 copy 模块来执行深拷贝和浅拷贝操作。以下是示例代码：

import copy

# 浅拷贝示例
original_list = [1, 2, [3, 4]]
shallow_copy = copy.copy(original_list)

# 修改浅拷贝对象的嵌套列表
shallow_copy[2][0] = 5

print(original_list)  # 输出: [1, 2, [5, 4]]
print(shallow_copy)  # 输出: [1, 2, [5, 4]]

# 深拷贝示例
deep_copy = copy.deepcopy(original_list)

# 修改深拷贝对象的嵌套列表
deep_copy[2][1] = 6

print(original_list)  # 输出: [1, 2, [5, 4]]
print(deep_copy)  # 输出: [1, 2, [5, 6]]

在上述示例中，我们首先对一个包含嵌套列表的原始列表进行浅拷贝和深拷贝操作。然后，修改拷贝后的对象的嵌套列表的值。可以看到，浅拷贝对象的嵌套列表修改也影响了原始列表，而深拷贝对象的修改不会影响原始列表。

可能遇到的问题

在进行深拷贝和浅拷贝时，可能会遇到以下问题：

1. 嵌套对象的共享引用：浅拷贝只复制了对象的引用，而不是创建嵌套对象的副本。这意味着如果对浅拷贝对象中的嵌套对象进行修改，原始对象也会受到影响。这可能导致意外的副作用。

2. 无限递归：如果存在循环引用或互相引用的对象，进行深拷贝时可能会导致无限递归。这会导致程序进入无限循环并最终引发 "RecursionError" 异常。

3. 可变对象的修改：无论是深拷贝还是浅拷贝，如果复制的对象包含可变对象（如列表或字典），对副本进行修改可能会影响原始对象。这是因为副本和原始对象引用同一个可变对象。

4. 性能和内存消耗：深拷贝涉及递归地复制所有嵌套对象，这可能对性能和内存消耗产生一定影响，特别是在处理大型对象或嵌套层次较深的对象时。

一个重要问题：嵌套列表内的引用是相同的

当进行浅拷贝时，新创建的列表中的元素是原始列表中元素的引用，而不是元素的副本。这意味着如果在浅拷贝列表中的嵌套列表上进行修改，原始列表中相应的嵌套列表也会受到影响。

通过一个示例来说明这个问题：

import copy

original_list = [1, [2, 3], 4]
shallow_copy = copy.copy(original_list)

# 修改浅拷贝列表中的嵌套列表
shallow_copy[1].append(5)

print(original_list)  # 输出: [1, [2, 3, 5], 4]
print(shallow_copy)  # 输出: [1, [2, 3, 5], 4]

在上述示例中，我们对一个包含嵌套列表的原始列表进行浅拷贝。然后，我们修改浅拷贝列表中的嵌套列表，结果原始列表中的嵌套列表也被修改了。

这是因为浅拷贝只复制了嵌套列表的引用，而不是创建嵌套列表的副本。因此，对浅拷贝列表中的嵌套列表进行修改实际上是对原始列表中相应的嵌套列表进行修改。

要解决这个问题，你可以使用深拷贝来创建所有嵌套列表的副本，而不是共享引用。这样，对深拷贝列表中的嵌套列表进行修改不会影响原始列表。

import copy

original_list = [1, [2, 3], 4]
deep_copy = copy.deepcopy(original_list)

# 修改深拷贝列表中的嵌套列表
deep_copy[1].append(5)

print(original_list)  # 输出: [1, [2, 3], 4]
print(deep_copy)  # 输出: [1, [2, 3, 5], 4]

在上述示例中，我们使用深拷贝创建了嵌套列表的副本。对深拷贝列表中的嵌套列表进行修改不会影响原始列表。

因此，当涉及到嵌套列表时，特别是在进行拷贝操作时，请考虑使用深拷贝来确保所有嵌套列表的副本都被创建，以避免意外行为

当涉及到嵌套字典时，浅拷贝也会导致类似的问题。通过一个例子来说明：

import copy

original_dict = {'a': 1, 'b': {'x': 2, 'y': 3}}
shallow_copy = copy.copy(original_dict)

# 修改浅拷贝字典中的嵌套字典
shallow_copy['b']['x'] = 4

print(original_dict)  # 输出: {'a': 1, 'b': {'x': 4, 'y': 3}}
print(shallow_copy)  # 输出: {'a': 1, 'b': {'x': 4, 'y': 3}}

在上述示例中，我们对一个包含嵌套字典的原始字典进行浅拷贝。然后，我们修改浅拷贝字典中的嵌套字典的值，结果原始字典中相应的嵌套字典也被修改了。

这是因为浅拷贝只复制了嵌套字典的引用，而不是创建嵌套字典的副本。因此，对浅拷贝字典中的嵌套字典进行修改实际上是对原始字典中相应的嵌套字典进行修改。

同样地，为了解决这个问题，你可以使用深拷贝来创建所有嵌套字典的副本，而不是共享引用。这样，对深拷贝字典中的嵌套字典进行修改不会影响原始字典。

import copy

original_dict = {'a': 1, 'b': {'x': 2, 'y': 3}}
deep_copy = copy.deepcopy(original_dict)

# 修改深拷贝字典中的嵌套字典
deep_copy['b']['x'] = 4

print(original_dict)  # 输出: {'a': 1, 'b': {'x': 2, 'y': 3}}
print(deep_copy)  # 输出: {'a': 1, 'b': {'x': 4, 'y': 3}}

在上述示例中，我们使用深拷贝创建了嵌套字典的副本。对深拷贝字典中的嵌套字典进行修改不会影响原始字典。

因此，无论是嵌套列表还是嵌套字典，在进行拷贝操作时，请考虑使用深拷贝来确保所有嵌套对象的副本都被创建，以避免意外修改原始对象的问题

    三段头部互联网大厂测开经历，辅导过25+同学入职大厂，【简历优化】、【就业指导】、【模拟/辅导面试】一对一指导