在平時(shí)工作中，經(jīng)常涉及到數(shù)據(jù)的傳遞，在數(shù)據(jù)傳遞使用過程中，可能會(huì)發(fā)生數(shù)據(jù)被修改的問題。為了防止數(shù)據(jù)被修改，就需要在傳遞一個(gè)副本，即使副本被修改，也不會(huì)影響原數(shù)據(jù)的使用。為了生成這個(gè)副本，就產(chǎn)生了拷貝。今天就說一下Python中的深拷貝與淺拷貝的問題。

概念普及：對象、可變類型、引用

數(shù)據(jù)拷貝會(huì)涉及到Python中對象、可變類型、引用這3個(gè)概念，先來看看這幾個(gè)概念，只有明白了他們才能更好的理解深拷貝與淺拷貝到底是怎么一回事。

Python對象

在Python中，對對象有一種很通俗的說法，萬物皆對象。說的就是構(gòu)造的任何數(shù)據(jù)類型都是一個(gè)對象，無論是數(shù)字，字符串，還是函數(shù)，甚至是模塊，Python都對當(dāng)做對象處理。

所有Python對象都擁有三個(gè)屬性：身份、類型、值。

看一個(gè)簡單的例子：

In [1]: name = "laowang" # name對象 
In [2]: id(name) # id:身份的唯一標(biāo)識(shí) 
Out[2]: 1698668550104 
In [3]: type(name) # type:對象的類型，決定了該對象可以保存什么類型的值 
Out[3]: str 
In [4]: name # 對象的值，表示的數(shù)據(jù) 
Out[4]: 'laowang' 

可變與不可變對象

在Python中，按更新對象的方式，可以將對象分為2大類：可變對象與不可變對象。

• 可變對象： 列表、字典、集合
• 所謂可變是指可變對象的值可變，身份是不變的。
• 不可變對象：數(shù)字、字符串、元組
• 不可變對象就是對象的身份和值都不可變。新創(chuàng)建的對象被關(guān)聯(lián)到原來的變量名，舊對象被丟棄，垃圾回收器會(huì)在適當(dāng)?shù)臅r(shí)機(jī)回收這些對象。

In [7]: var1 = "python" 
In [8]: id(var1) 
Out[8]: 1700782038408 
#由于var1是不可變的，重新創(chuàng)建了java對象，隨之id改變，舊對象python會(huì)在某個(gè)時(shí)刻被回收 
In [9]: var1 = "java" 
In [10]: id(var1)  
Out[10]: 1700767578296 

引用

在 Python 程序中，每個(gè)對象都會(huì)在內(nèi)存中申請開辟一塊空間來保存該對象，該對象在內(nèi)存中所在位置的地址被稱為引用。在開發(fā)程序時(shí)，所定義的變量名實(shí)際就對象的地址引用。

引用實(shí)際就是內(nèi)存中的一個(gè)數(shù)字地址編號(hào)，在使用對象時(shí)，只要知道這個(gè)對象的地址，就可以操作這個(gè)對象，但是因?yàn)檫@個(gè)數(shù)字地址不方便在開發(fā)時(shí)使用和記憶，所以使用變量名的形式來代替對象的數(shù)字地址。 在 Python 中，變量就是地址的一種表示形式，并不開辟開辟存儲(chǔ)空間。

就像 IP 地址，在訪問網(wǎng)站時(shí)，實(shí)際都是通過 IP 地址來確定主機(jī)，而 IP 地址不方便記憶，所以使用域名來代替 IP 地址，在使用域名訪問網(wǎng)站時(shí)，域名被解析成 IP 地址來使用。

通過一個(gè)例子來說明變量和變量指向的引用就是一個(gè)東西。

In [11]: age = 18 
In [12]: id(age) 
Out[12]: 1730306752 
In [13]: id(18) 
Out[13]: 1730306752 

逐步深入：引用賦值

上邊已經(jīng)明白，引用就是對象在內(nèi)存中的數(shù)字地址編號(hào)，變量就是方便對引用的表示而出現(xiàn)的，變量指向的就是此引用。賦值的本質(zhì)就是讓多個(gè)變量同時(shí)引用同一個(gè)對象的地址。 那么在對數(shù)據(jù)修改時(shí)會(huì)發(fā)生什么問題呢?

• 不可變對象的引用賦值。
• 對不可變對象賦值，實(shí)際就是在內(nèi)存中開辟一片空間指向新的對象，原不可變對象不會(huì)被修改。

原理圖如下：

下面通過案例來理解一下：

a與b在內(nèi)存中都是指向1的引用，所以a、b的引用是相同的。

In [1]: a = 1 
In [2]: b = a 
In [3]: id(a) 
Out[3]: 1730306496 
In [4]: id(b) 
Out[4]: 1730306496 

現(xiàn)在再給a重新賦值，看看會(huì)發(fā)生什么變化?

從下面不難看出：當(dāng)給a 賦新的對象時(shí)，將指向現(xiàn)在的引用，不在指向舊的對象引用。

In [1]: a = 1 
In [2]: b = a 
In [5]: a = 2 
In [6]: id(a) 
Out[6]: 1730306816 
In [7]: id(b) 
Out[7]: 1730306496 

• 可變對象的引用賦值。
• 可變對象保存的并不是真正的對象數(shù)據(jù)，而是對象的引用。當(dāng)對可變對象進(jìn)行賦值時(shí)，只是將可變對象中保存的引用指向了新的對象。

原理圖如下：

仍然通過一個(gè)實(shí)例來體會(huì)一下，可變對象引用賦值的過程。

當(dāng)改變l1時(shí)，整個(gè)列表的引用會(huì)指新的對象，但是l1與l2都是指向保存的同一個(gè)列表的引用，所以引用地址不會(huì)變。

In [3]: l1 = [1, 2, 3] 
In [4]: l2 = l1 
In [5]: id(l1) 
Out[5]: 1916633584008 
In [6]: id(l2) 
Out[6]: 1916633584008 
In [7]: l1[0] = 11 
In [8]: id(l1) 
Out[8]: 1916633584008 
In [9]: id(l2) 
Out[9]: 1916633584008 

主旨詳解：淺拷貝、深拷貝

經(jīng)過前2部分的解讀，大家對對象的引用賦值應(yīng)該有了一個(gè)清晰的認(rèn)識(shí)了。

下面大家思考一個(gè)這樣的問題：Python中如何解決原始數(shù)據(jù)在函數(shù)傳遞之后不受影響了?

這個(gè)問題Python已經(jīng)幫我們解決了，使用對象的拷貝或者深拷貝就可以愉快的解決了。

下面具體來看看Python中的淺拷貝與深拷貝是如何實(shí)現(xiàn)的。

• 淺拷貝：

為了解決函數(shù)傳遞后被修改的問題，就需要拷貝一份副本，將副本傳遞給函數(shù)使用，就算是副本被修改，也不會(huì)影響原始數(shù)據(jù) 。

不可變對象的拷貝

不可變對象只在修改的時(shí)候才會(huì)在內(nèi)存中開辟新的空間， 而拷貝實(shí)際上是讓多個(gè)對象同時(shí)指向一個(gè)引用，和對象的賦值沒區(qū)別。

同樣的，通過一個(gè)實(shí)例來感受一下：不難看出，a與b指向相同的引用，不可變對象的拷貝就是對象賦值。

In [11]: import copy 
In [12]: a = 10 
In [13]: b = copy.copy(a) 
In [14]: id(a) 
Out[14]: 1730306496 
In [15]: id(b) 
Out[15]: 1730306496 

可變對象的拷貝

對于不可變對象的拷貝，對象的引用并沒有發(fā)生變化，那么可變對象的拷貝會(huì)不會(huì)和不可變對象一樣了?我們接著往下看。

通過下面這個(gè)實(shí)例可以看出：可變對象的拷貝，會(huì)在內(nèi)存中開辟一個(gè)新的空間來保存拷貝的數(shù)據(jù)。當(dāng)再改變之前的對象時(shí)，對拷貝之后的對象沒有任何影響。

In [24]: import copy 
In [25]: l1 = [1, 2, 3] 
In [26]: l2 = copy.copy(l1) 
In [27]: id(l1) 
Out[27]: 1916631742088 
In [28]: id(l2) 
Out[28]: 1916636282952 
In [29]: l1[0] = 11 
In [30]: id(l1) 
Out[30]: 1916631742088 
In [31]: id(l2) 
Out[31]: 1916636282952 

原理圖如下：

現(xiàn)在再回到剛才那個(gè)問題，是不是淺拷貝就可以解決原始數(shù)據(jù)在函數(shù)傳遞之后不變的問題了?下面看一個(gè)稍微復(fù)雜一點(diǎn)的數(shù)據(jù)結(jié)構(gòu)。

通過下面這個(gè)實(shí)例可以發(fā)現(xiàn)：復(fù)雜對象在拷貝時(shí)，并沒有解決數(shù)據(jù)在傳遞之后，數(shù)據(jù)改變的問題。 出現(xiàn)這種原因，是copy() 函數(shù)在拷貝對象時(shí)，只是將指定對象中的所有引用拷貝了一份，如果這些引用當(dāng)中包含了一個(gè)可變對象的話，那么數(shù)據(jù)還是會(huì)被改變。 這種拷貝方式，稱為淺拷貝。

In [35]: a = [1, 2] 
In [36]: l1 = [3, 4, a] 
In [37]: l2 = copy.copy(l1) 
In [38]: id(l1) 
Out[38]: 1916631704520 
In [39]: id(l2) 
Out[39]: 1916631713736 
In [40]: a[0] = 11 
In [41]: id(l1) 
Out[41]: 1916631704520 
In [42]: id(l2) 
Out[42]: 1916631713736 
In [43]: l1 
Out[43]: [3, 4, [11, 2]] 
In [44]: l2 
Out[44]: [3, 4, [11, 2]] 

原理圖如下：

對于上邊這種狀況，Python還提供了另一種拷貝方式(深拷貝)來解決。

• 深拷貝

區(qū)別于淺拷貝只拷貝頂層引用，深拷貝會(huì)逐層進(jìn)行拷貝，直到拷貝的所有引用都是不可變引用為止。

接下來我們看看，要是將上邊的拷貝實(shí)例用使用深拷貝的話，原始數(shù)據(jù)改變的問題還會(huì)不會(huì)存在了?

下面的實(shí)例清楚的告訴我們：之前的問題就可以***解決了。

import copy 
l1 = [3, 4, a] 
In [47]: l2 = copy.deepcopy(li) 
In [48]: id(l1) 
Out[48]: 1916632194312 
In [49]: id(l2) 
Out[49]: 1916634281416 
In [50]: a[0] = 11 
In [51]: id(l1) 
Out[51]: 1916632194312 
In [52]: id(l2) 
Out[52]: 1916634281416 
In [54]: l1 
Out[54]: [3, 4, [11, 2]] 
In [55]: l2 
Out[55]: [1, 2, 3] 

原理圖如下：

查漏補(bǔ)缺

為什么Python默認(rèn)的拷貝方式是淺拷貝?

• 時(shí)間角度：淺拷貝花費(fèi)時(shí)間更少。
• 空間角度：淺拷貝花費(fèi)內(nèi)存更少。
• 效率角度：淺拷貝只拷貝頂層數(shù)據(jù)，一般情況下比深拷貝效率高。

本文知識(shí)點(diǎn)總結(jié)：

• 不可變對象在賦值時(shí)會(huì)開辟新空間。
• 可變對象在賦值時(shí)，修改一個(gè)的值，另一個(gè)也會(huì)發(fā)生改變。
• 深、淺拷貝對不可變對象拷貝時(shí)，不開辟新空間，相當(dāng)于賦值操作。
• 淺拷貝在拷貝時(shí)，只拷貝***層中的引用，如果元素是可變對象，并且被修改，那么拷貝的對象也會(huì)發(fā)生變化。
• 深拷貝在拷貝時(shí)，會(huì)逐層進(jìn)行拷貝，直到所有的引用都是不可變對象為止。
• Python 中有多種方式實(shí)現(xiàn)淺拷貝，copy模塊的copy 函數(shù) ，對象的 copy 函數(shù) ，工廠方法，切片等。
• 大多數(shù)情況下，編寫程序時(shí)，都是使用淺拷貝，除非有特定的需求。
• 淺拷貝的優(yōu)點(diǎn)：拷貝速度快，占用空間少，拷貝效率高。