Python 程序員如何防止數據被修改？

作者 | PayneLi

責編| 郭芮

在平時工作中，經常涉及到數據的傳遞。在數據傳遞使用過程中，可能會發生數據被修改的問題。為了防止數據被修改，就需要再傳遞一個副本，即使副本被修改，也不會影響原數據的使用。為了生成這個副本，就產生了拷貝——今天就說一下Python中的深拷貝與淺拷貝的問題。

概念解讀

數據拷貝會涉及到Python中對象、可變類型、引用這3個概念，先來看看這幾個概念，只有明白了它們才能更好地理解拷貝到底是怎麼一回事。

Python對象

在Python中，對對象有一種很通俗的說法，萬物皆對象。說的就是構造的任何數據類型都是一個對象，無論是數字、字元串、還是函數，甚至是模塊、Python都對當做對象處理。

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

看一個簡單的例子：

In [1]: name ="laowang"# name對象

In [2]: id(name)# id:身份的唯一標識

Out[2]: 1698668550104

In [3]:type(name)# type:對象的類型，決定了該對象可以保存什麼類型的值

Out[3]: str

In [4]: name# 對象的值，表示的數據

Out[4]:"laowang"

可變與不可變對象

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

可變對象： 列表、字典、集合。所謂可變是指可變對象的值可變，身份是不變的。

不可變對象：數字、字元串、元組。不可變對象就是對象的身份和值都不可變。新創建的對象被關聯到原來的變數名，舊對象被丟棄，垃圾回收器會在適當的時機回收這些對象。

In [7]: var1 ="python"

In [8]:id(var1)

Out[8]:1700782038408

#由於var1是不可變的，重新創建了java對象，隨之id改變，舊對象python會在某個時刻被回收

In [9]: var1 ="java"

In [10]:id(var1)

Out[10]:1700767578296

引用

在Python程序中，每個對象都會在內存中申請開闢一塊空間來保存該對象，該對象在內存中所在位置的地址被稱為引用。在開發程序時，所定義的變數名實際就對象的地址引用。

引用實際就是內存中的一個數字地址編號，在使用對象時，只要知道這個對象的地址，就可以操作這個對象，但是因為這個數字地址不方便在開發時使用和記憶，所以使用變數名的形式來代替對象的數字地址。在Python中，變數就是地址的一種表示形式，並不開闢開闢存儲空間。

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

通過一個例子來說明變數和變數指向的引用就是一個東西：

逐步深入：引用賦值

上邊已經明白，引用就是對象在內存中的數字地址編號，變數就是方便對引用的表示而出現的，變數指向的就是此引用。賦值的本質就是讓多個變數同時引用同一個對象的地址。

那麼在對數據修改時會發生什麼問題呢？

不可變對象的引用賦值

對不可變對象賦值，實際就是在內存中開闢一片空間指向新的對象，原不可變對象不會被修改。原理圖如下：

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

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

現在再給a重新賦值，看看會發生什麼變化？從下面不難看出：當給a賦新的對象時，將指向現在的引用，不在指向舊的對象引用。

可變對象的引用賦值

可變對象保存的並不是真正的對象數據，而是對象的引用。當對可變對象進行賦值時，只是將可變對象中保存的引用指向了新的對象。原理圖如下：

仍然通過一個實例來體會一下，可變對象引用賦值的過程：當改變l1時，整個列表的引用會指新的對象，但是l1與l2都是指向保存的同一個列表的引用，所以引用地址不會變。

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

經過前2部分的解讀，大家對對象的引用賦值應該有了一個清晰的認識了。那麼Python中如何解決原始數據在函數傳遞之後不受影響？這個問題Python已經幫我們解決了，使用對象的拷貝或者深拷貝就可以愉快解決了。

下面具體來看看Python中的淺拷貝與深拷貝是如何實現的。

淺拷貝

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

不可變對象的拷貝

不可變對象只在修改的時候才會在內存中開闢新的空間，而拷貝實際上是讓多個對象同時指向一個引用，和對象的賦值沒區別。

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

In [11]:importcopy

In [12]: a =10

In [13]: b =copy.copy(a)

In [14]: id(a)

Out[14]:1730306496

In [15]: id(b)

Out[15]:1730306496

可變對象的拷貝

對於不可變對象的拷貝，對象的引用並沒有發生變化，那麼可變對象的拷貝會不會和不可變對象一樣了？我們接著往下看。

通過下面的實例能看出：可變對象的拷貝會在內存中開闢一個新的空間來保存拷貝的數據。當再改變之前的對象時，對拷貝之後的對象沒有任何影響。

In [24]: importcopy

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[] =11

In [30]:id(l1)

Out[30]:1916631742088

In [31]:id(l2)

Out[31]:1916636282952

原理圖如下：

現在再回到剛才那個問題，是不是淺拷貝就可以解決原始數據在函數傳遞之後不變的問題了？下面看一個稍微複雜一點的數據結構。

通過下面這個實例可以發現：複雜對象在拷貝時，並沒有解決數據在傳遞之後，數據改變的問題。出現這種原因，是copy() 函數在拷貝對象時只是將指定對象中的所有引用拷貝了一份，如果這些引用當中包含了一個可變對象的話，那麼數據還是會被改變。這種拷貝方式，稱為淺拷貝。

原理圖如下：

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

深拷貝

區別於淺拷貝只拷貝頂層引用，深拷貝會逐層進行拷貝，直到拷貝的所有引用都是不可變引用為止。

接下來我們看看，要是將上邊的拷貝實例用使用深拷貝的話，原始數據改變的問題還會不會存在了？

下面的實例清楚地告訴我們：之前的問題就可以完美解決了。

importcopy

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[] =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, 4]

原理圖如下：

查漏補缺

為什麼Python默認的拷貝方式是淺拷貝？

時間角度：淺拷貝花費時間更少；

空間角度：淺拷貝花費內存更少；

效率角度：淺拷貝只拷貝頂層數據，一般情況下比深拷貝效率高。

本文知識點總結：

不可變對象在賦值時會開闢新空間；

可變對象在賦值時，修改一個的值，另一個也會發生改變；

深、淺拷貝對不可變對象拷貝時，不開闢新空間，相當於賦值操作；

淺拷貝在拷貝時，只拷貝第一層中的引用，如果元素是可變對象，並且被修改，那麼拷貝的對象也會發生變化；

深拷貝在拷貝時會逐層進行拷貝，直到所有的引用都是不可變對象為止；

Python中有多種方式實現淺拷貝，copy模塊的copy函數、對象的copy函數、工廠方法、切片等；

大多數情況下，編寫程序時都是使用淺拷貝，除非有特定的需求；

淺拷貝的優點：拷貝速度快，佔用空間少，拷貝效率高。

作者：PayneLi，就職於深圳一家科技公司AI部門，負責Python後台開發、爬蟲和數據挖掘相關工作。運營個人公眾號 Python全家桶 ，歡迎關注，一起學習交流。

聲明：本文為作者投稿，版權歸其個人所有。

熱 文推 薦

喜歡這篇文章嗎？立刻分享出去讓更多人知道吧！