在Python中，使用“=”運算符創建對象的副本。初學者可能會認為這種方式會創建一個新對象，但其實并非如此，僅創建一個共享原始對象引用的新變量。例如，先創建一個名為old_list的列表，再使用“=”運算符將對象引用傳遞給新列表new_list：

1. >>> old_list = [[1, 2, 3], [4, 5, 6], [7, 8, 'a']] 
2. >>> new_list = old_list   # 創建對象的副本 
3. >>> new_list[2][2] = 9   # 修改新列表 
4. >>> print(old_list)   # 打印舊列表，也改變了 
5. [[1, 2, 3], [4, 5, 6], [7, 8, 9]] 
6. >>> id(old_list)   # id()內建函數,用于獲取對象的內存地址 
7. 4425086088 
8. >>> print(new_list)   # 打印新列表 
9. [[1, 2, 3], [4, 5, 6], [7, 8, 9]] 
10. >>> id(new_list) 
11. 4425086088 

由此可見，變量old_list和new_list共享相同的ID，即4425086088;new_list修改了，old_list也隨之改變了。

在Python中，有兩種創建副本的方法：copy模塊中的深拷貝和淺拷貝。

(1)淺拷貝

淺拷貝創建一個新對象，該對象存儲原始對象的引用。因此，淺拷貝不會創建嵌套對象的副本，而僅復制嵌套對象的引用。這意味著復制過程不會遞歸或創建嵌套對象本身的副本。下面是一個淺拷貝的示例：

1. >>> import copy   # 導入copy模塊 
2. >>> old_list = [[1, 1, 1], [2, 2, 2], [3, 3, 3]] 
3. >>> new_list = copy.copy(old_list)   # 淺拷貝 
4. >>> print(old_list) 
5. [[1, 1, 1], [2, 2, 2], [3, 3, 3]] 
6. >>> print(new_list) 
7. [[1, 1, 1], [2, 2, 2], [3, 3, 3]] 

在上述示例中，首先創建了一個嵌套列表old_list，然后使用copy()函數對old_list進行淺拷貝，這意味著它將創建具有相同內容的新的獨立對象。new_list包含對存儲在old_list中的原始嵌套對象的引用。為了確認new_list與old_list不同，嘗試將新列表追加到old_list并進行檢查：

1. >>> old_list.append([4, 4, 4])   # 向old_list中追加一個新列表 
2. >>> print(old_list)   # old_list中添加了新項 
3. [[1, 1, 1], [2, 2, 2], [3, 3, 3], [4, 4, 4]] 
4. >>> print(new_list)   # new_list中沒有添加新項 
5. [[1, 1, 1], [2, 2, 2], [3, 3, 3]] 

由此可知，將新列表(即[4，4，4])追加到old_list中，這個新的子列表未復制到new_list中。

但是，當更改old_list中的任何嵌套對象時，更改將顯示在new_list中：

1. >>> old_list[1][1] = 'AA' 
2. >>> print(old_list)   # old_list進行更改 
3. [[1, 1, 1], [2, 'AA', 2], [3, 3, 3], [4, 4, 4]] 
4. >>> print(new_list)   # new_list也隨之更改 
5. [[1, 1, 1], [2, 'AA', 2], [3, 3, 3]] 

對old_list進行了更改(即old_list [1] [1] ='AA')，old_list和new_list的索引[1] [1]上的值均已更改，這是由于兩個列表共享相同嵌套對象的引用。使用深拷貝可以解決這個“問題”。

(2)深拷貝

深層副本會創建一個新對象，然后遞歸地添加原始對象中存在的嵌套對象的副本。繼續淺拷貝中的示例，這次將使用deepcopy()函數創建深拷貝。深拷貝創建原始對象及其所有嵌套對象的獨立副本：

1. >>> import copy 
2. >>> old_list = [[1, 1, 1], [2, 2, 2], [3, 3, 3]] 
3. >>> new_list = copy.deepcopy(old_list)   # 深拷貝 
4. >>> print(old_list) 
5. [[1, 1, 1], [2, 2, 2], [3, 3, 3]] 
6. >>> print(new_list) 
7. [[1, 1, 1], [2, 2, 2], [3, 3, 3]] 

使用deepcopy()函數創建外觀相似的副本，這和淺拷貝一樣。但是如果對原始對象old_list中的任何嵌套對象進行更改，并不會對副本new_list進行相應更改：

1. >>> old_list[1][0] = 'BB' 
2. >>> print(old_list) 
3. [[1, 1, 1], ['BB', 2, 2], [3, 3, 3]] 
4. >>> print(new_list) 
5. [[1, 1, 1], [2, 2, 2], [3, 3, 3]] 

為old_list分配新值時，只有old_list被更改了，這意味著old_list和new_list都是獨立的。這是由于對old_list進行的是遞歸復制，所有嵌套對象都適用。