在 Python 中，深拷貝（deep copy）和淺拷貝（shallow copy）是用于創(chuàng)建對象副本的兩種不同方式。

• 淺拷貝是創(chuàng)建一個新的對象，該對象與原始對象的內(nèi)容相同（包括內(nèi)部嵌套對象的引用），但是它們指向相同的內(nèi)存地址。換句話說，淺拷貝創(chuàng)建了一個對象的表面副本，而不是遞歸復(fù)制所有嵌套對象。當(dāng)原始對象包含可變對象（如列表、字典）時，對副本進(jìn)行修改可能會影響原始對象。
• 深拷貝是創(chuàng)建一個全新的對象，該對象與原始對象內(nèi)容相同，包括所有嵌套對象。深拷貝遞歸地復(fù)制所有嵌套對象，而不僅僅是創(chuàng)建一個表面副本。因此，對深拷貝對象的修改不會影響原始對象。

下面是深拷貝和淺拷貝的用途：

1. 淺拷貝適用于需要創(chuàng)建一個對象的快速副本，但不需要對副本進(jìn)行深層次的修改。它可以節(jié)省內(nèi)存和復(fù)制時間，特別是當(dāng)對象包含大量數(shù)據(jù)或嵌套對象時。

2. 深拷貝適用于需要創(chuàng)建一個完全獨立的對象，以便對副本進(jìn)行修改而不會影響原始對象。它用于確保對象及其所有嵌套對象在修改時的獨立性。

在 Python 中，可以使用?copy?模塊來執(zhí)行深拷貝和淺拷貝操作。以下是示例代碼：

import copy# 淺拷貝示例
original_list = [1, 2, [3, 4]]
shallow_copy = copy.copy(original_list)# 修改淺拷貝對象的嵌套列表
shallow_copy[2][0] = 5print(original_list)  # 輸出: [1, 2, [5, 4]]
print(shallow_copy)  # 輸出: [1, 2, [5, 4]]# 深拷貝示例
deep_copy = copy.deepcopy(original_list)# 修改深拷貝對象的嵌套列表
deep_copy[2][1] = 6print(original_list)  # 輸出: [1, 2, [5, 4]]
print(deep_copy)  # 輸出: [1, 2, [5, 6]]

在上述示例中，我們首先對一個包含嵌套列表的原始列表進(jìn)行淺拷貝和深拷貝操作。然后，修改拷貝后的對象的嵌套列表的值。可以看到，淺拷貝對象的嵌套列表修改也影響了原始列表，而深拷貝對象的修改不會影響原始列表。

可能遇到的問題

在進(jìn)行深拷貝和淺拷貝時，可能會遇到以下問題：

1. 嵌套對象的共享引用：淺拷貝只復(fù)制了對象的引用，而不是創(chuàng)建嵌套對象的副本。這意味著如果對淺拷貝對象中的嵌套對象進(jìn)行修改，原始對象也會受到影響。這可能導(dǎo)致意外的副作用。

2. 無限遞歸：如果存在循環(huán)引用或互相引用的對象，進(jìn)行深拷貝時可能會導(dǎo)致無限遞歸。這會導(dǎo)致程序進(jìn)入無限循環(huán)并最終引發(fā) "RecursionError" 異常。

3. 可變對象的修改：無論是深拷貝還是淺拷貝，如果復(fù)制的對象包含可變對象（如列表或字典），對副本進(jìn)行修改可能會影響原始對象。這是因為副本和原始對象引用同一個可變對象。

4. 性能和內(nèi)存消耗：深拷貝涉及遞歸地復(fù)制所有嵌套對象，這可能對性能和內(nèi)存消耗產(chǎn)生一定影響，特別是在處理大型對象或嵌套層次較深的對象時。

一個重要問題：嵌套列表內(nèi)的引用是相同的

當(dāng)進(jìn)行淺拷貝時，新創(chuàng)建的列表中的元素是原始列表中元素的引用，而不是元素的副本。這意味著如果在淺拷貝列表中的嵌套列表上進(jìn)行修改，原始列表中相應(yīng)的嵌套列表也會受到影響。

通過一個示例來說明這個問題：

import copyoriginal_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]

在上述示例中，我們對一個包含嵌套列表的原始列表進(jìn)行淺拷貝。然后，我們修改淺拷貝列表中的嵌套列表，結(jié)果原始列表中的嵌套列表也被修改了。

這是因為淺拷貝只復(fù)制了嵌套列表的引用，而不是創(chuàng)建嵌套列表的副本。因此，對淺拷貝列表中的嵌套列表進(jìn)行修改實際上是對原始列表中相應(yīng)的嵌套列表進(jìn)行修改。

要解決這個問題，你可以使用深拷貝來創(chuàng)建所有嵌套列表的副本，而不是共享引用。這樣，對深拷貝列表中的嵌套列表進(jìn)行修改不會影響原始列表。

import copyoriginal_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]

在上述示例中，我們使用深拷貝創(chuàng)建了嵌套列表的副本。對深拷貝列表中的嵌套列表進(jìn)行修改不會影響原始列表。

因此，當(dāng)涉及到嵌套列表時，特別是在進(jìn)行拷貝操作時，請考慮使用深拷貝來確保所有嵌套列表的副本都被創(chuàng)建，以避免意外行為

當(dāng)涉及到嵌套字典時，淺拷貝也會導(dǎo)致類似的問題。通過一個例子來說明：

import copyoriginal_dict = {'a': 1, 'b': {'x': 2, 'y': 3}}
shallow_copy = copy.copy(original_dict)# 修改淺拷貝字典中的嵌套字典
shallow_copy['b']['x'] = 4print(original_dict)  # 輸出: {'a': 1, 'b': {'x': 4, 'y': 3}}
print(shallow_copy)  # 輸出: {'a': 1, 'b': {'x': 4, 'y': 3}}

在上述示例中，我們對一個包含嵌套字典的原始字典進(jìn)行淺拷貝。然后，我們修改淺拷貝字典中的嵌套字典的值，結(jié)果原始字典中相應(yīng)的嵌套字典也被修改了。

這是因為淺拷貝只復(fù)制了嵌套字典的引用，而不是創(chuàng)建嵌套字典的副本。因此，對淺拷貝字典中的嵌套字典進(jìn)行修改實際上是對原始字典中相應(yīng)的嵌套字典進(jìn)行修改。

同樣地，為了解決這個問題，你可以使用深拷貝來創(chuàng)建所有嵌套字典的副本，而不是共享引用。這樣，對深拷貝字典中的嵌套字典進(jìn)行修改不會影響原始字典。

import copyoriginal_dict = {'a': 1, 'b': {'x': 2, 'y': 3}}
deep_copy = copy.deepcopy(original_dict)# 修改深拷貝字典中的嵌套字典
deep_copy['b']['x'] = 4print(original_dict)  # 輸出: {'a': 1, 'b': {'x': 2, 'y': 3}}
print(deep_copy)  # 輸出: {'a': 1, 'b': {'x': 4, 'y': 3}}

在上述示例中，我們使用深拷貝創(chuàng)建了嵌套字典的副本。對深拷貝字典中的嵌套字典進(jìn)行修改不會影響原始字典。

因此，無論是嵌套列表還是嵌套字典，在進(jìn)行拷貝操作時，請考慮使用深拷貝來確保所有嵌套對象的副本都被創(chuàng)建，以避免意外修改原始對象的問題

????三段頭部互聯(lián)網(wǎng)大廠測開經(jīng)歷，輔導(dǎo)過25+同學(xué)入職大廠，【簡歷優(yōu)化】、【就業(yè)指導(dǎo)】、【模擬/輔導(dǎo)面試】一對一指導(dǎo)