2. 程式人生 > >你真得理解 python 的淺拷貝和深拷貝嗎？

你真得理解 python 的淺拷貝和深拷貝嗎？

阿新 • • 發佈：2019-02-14

三月沙 原文連結

為了讓一個物件發生改變時不對原物件產生副作用，此時，需要一份這個物件的拷貝，python 提供了 copy 機制來完成這樣的任務，對應的模組是 copy。

淺拷貝:shadow copy

在 copy 模組中，有 copy 函式可以完成淺拷貝。

1
 
from copy import copy

在 python 中，標識一個物件唯一身份的是：物件的id(記憶體地址)，物件型別，物件值，而淺拷貝就是建立一個具有相同型別，相同值但不同id的新物件。

對可變物件而言，物件的值一樣可能包含有對其他物件的引用，淺拷貝產生的新物件，雖然具有完全不同的id，但是其值若包含可變物件，這些物件和原始物件中的值包含同樣的引用。

1
2
3
4
5
6
7
8
9
10
11
12
 
>>> import copy
>>> l = {'a': [1,2,3], 'b':[4,5,6]}
>>> c = copy.copy(l)
>>> id(l) == id(c)
False
>>> l['a'].append('4')
>>> c['b'].append('7')
>>> l
{'a': [1, 2, 3, '4'], 'b': [4, 5, 6, '7']}
>>> c
{'a': [1, 2, 3, '4'], 'b'
 
: [4, 5, 6, '7']}
>>>

可見淺拷貝產生的新物件中可變物件的值在發生改變時會對原物件的值產生副作用，因為這些值是同一個引用。

淺拷貝僅僅對物件自身建立了一份拷貝，而沒有在進一步處理物件中包含的值。因此使用淺拷貝的典型使用場景是：物件自身發生改變的同時需要保持物件中的值完全相同，比如 list 排序。

1
2
3
4
5
6
7
8
9
10
11
 
>>> def sorted_list(olist, key=None):
...     copied_list = copy.copy(olist)
...     copied_list.sort(key=key)
 

...     return copied_list
... 
>>> a = [3,2,1]
>>> b = sorted_list(a)
>>> a
[3, 2, 1]
>>> b
[1, 2, 3]

深拷貝:deep copy

在 copy 模組中，有 deepcopy 函式可以完成深拷貝。

1
 
from copy import deepcopy

深拷貝不僅僅拷貝了原始物件自身，也對其包含的值進行拷貝，它會遞迴的查詢物件中包含的其他物件的引用，來完成更深層次拷貝。因此，深拷貝產生的副本可以隨意修改而不需要擔心會引起原始值的改變。

1
2
3
4
5
6
7
8
9
10
11
12
 
>>> import copy
>>> l = {'a': [1,2,3], 'b':[4,5,6]}
>>> c = copy.deepcopy(l)
>>> id(l) == id(c)
False
>>> l['a'].append('4')
>>> c['b'].append('7')
>>> l
{'a': [1, 2, 3, '4'], 'b': [4, 5, 6]}
>>> c
{'a': [1, 2, 3], 'b': [4, 5, 6, '7']}
>>>

值得注意的是，深拷貝並非完完全全遞迴查詢所有物件，因為一旦物件引用了自身，完全遞迴可能會導致無限迴圈。一個物件被拷貝了，python 會對該物件做個標記，如果還有其他需要拷貝的物件引用著該物件，它們的拷貝其實指向的是同一份拷貝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
>>> a = [1,2]
>>> b = [a,a]
>>> b
[[1, 2], [1, 2]]
>>> c = deepcopy(b)
>>> id(b[0]) == id(c[0])
False
>>> id(b[0]) == id(b[1])
True
>>> c
[[1, 2], [1, 2]]
>>> c[0].append(3)  #c list 中包含的兩份拷貝指向同一處
>>> c
[[1, 2, 3], [1, 2, 3]]
>>>

自定義拷貝機制

使用 _copy_ 和 __deepcopy__ 可以完成對一個物件拷貝的定製。這裡不展開了，有機會再探討自定義拷貝。

相關推薦

你真得理解 python 的淺拷貝和深拷貝嗎？

三月沙 原文連結 為了讓一個物件發生改變時不對原物件產生副作用，此時，需要一份這個物件的拷貝，python 提供了 copy 機制來完成這樣的任務，對應的模組是 copy。 淺拷貝:shadow copy 在 copy 模組中，有 copy 函式可以完成淺拷貝。 1 from copy import

python中的淺拷貝和深拷貝

div blog deep imp class pri cnblogs 字符串 style 1.淺拷貝 copy.copy() 淺拷貝是拷貝只拷貝最外一層（這裏所說的拷貝是重新生成一個內存地址，也就是只有最外層的地址是重新生成） import copy li=[23,45

【轉】python的淺拷貝和深拷貝

end ont code append pen ron 實例 賦值 深拷貝 直接賦值：其實就是對象的引用（別名）。 淺拷貝(copy)：拷貝父對象，不會拷貝對象的內部的子對象。 深拷貝(deepcopy)： copy 模塊的 deepcopy 方法，完全拷貝了父對象及其

Python 中的淺拷貝和深拷貝

ont () ebe ans 深拷貝 函數 port epc com 1. 列表和字典，直接賦值，都是淺拷貝，即賦值雙方指向同一地址，因為 Python 對可變對象按引用傳遞。 >>> a = [1, 2, 3] >>> b

python 淺拷貝和深拷貝淺析

編碼過程中發現，列表a和b，初始化a，b拷貝a，b中元素值改過之後，a中元素也會跟著修改，一直以為是自己程式碼邏輯出了錯誤，最後發現這裡的坑是python中淺拷貝和深拷貝的機制 在python中，物件的屬性值有：物件id（記憶體地址），物件型別，物件值 id：唯一標識一個物件：if a

Java: 淺拷貝和深拷貝的理解和實現方式

Java中的物件拷貝(Object Copy)指的是將一個物件的所有屬性（成員變數）拷貝到另一個有著相同類型別的物件中去。舉例說明：比如，物件A和物件B都屬於類S，具有屬性a和b。那麼對物件A進行拷貝操作賦值給物件B就是：B.a=A.a;  B.b=A.b; 在程式中拷貝物件是很常見的

對java的淺拷貝和深拷貝的理解

參考網址：http://www.cnblogs.com/chenssy/p/3308489.html 、https://blog.csdn.net/chenssy/article/details/12952063 淺拷貝：使用一個已知例項對新建立例項的成員變數逐個賦值，這個方式被稱為淺

python賦值，淺拷貝和深拷貝

>>> a = 1 >>> b = a >>> a = 2 >>> a 2 >>> b 1 >>> 你將 1 賦給 a 變數，然後拷貝 a 中的值，將它賦給變數 b。當稍 後將

理解javascript中淺拷貝和深拷貝

首先，我們要知道javascript的資料型別。 javascript有兩種資料型別，基礎資料型別和引用資料型別。 基礎資料型別：儲存在棧記憶體中的簡單資料段，有undefined，boolean，number，string，null。 引用資料型別：Array，物件，Function儲

python的複製，淺拷貝和深拷貝的區別

在python中，物件賦值實際上是物件的引用。當建立一個物件，然後把它賦給另一個變數的時候，python並沒有拷貝這個物件，而只是拷貝了這個物件的引用 一般有三種方法， alist=[1,2,3,["a","b"]]   （1）直接賦值,傳遞物件的引用而已,原始列表改變，被

Python3中的淺拷貝和深拷貝入門理解

1，變數：是一個系統表的元素，擁有指向物件的連線空間  2，物件：被分配的一塊記憶體，儲存其所代表的值  3，引用：是自動形成的從變數到物件的指標  淺拷貝：複製了父物件，沒有拷貝子物件 a

python淺拷貝和深拷貝比較

python將內建的幾種資料型別，再次分為可變型別與不可變型別 不可變型別有：string   int  tuple 可變型別有：list    dict  set 現在對這兩種型別分別進行淺拷貝和深拷貝 一、對string進行淺拷貝和深拷貝，結果是一樣的，物件的記憶

Python 中的淺拷貝和深拷貝詳解

Python 中的淺拷貝與深拷貝詳解 轉載請註明出處：https://blog.csdn.net/jpch89/article/details/85028862 文章目錄 Python 中的淺拷貝與深拷貝詳解 1. 淺拷貝

Java 淺拷貝和深拷貝的理解和實現方式

Java中的物件拷貝(Object Copy)指的是將一個物件的所有屬性（成員變數）拷貝到另一個有著相同類型別的物件中去。舉例說明：比如，物件A和物件B都屬於類S，具有屬性a和b。那麼對物件A進行拷貝操作賦值給物件B就是：B.a=A.a;  B.b=A.b; 在程式中拷貝物件是很常見的

【Python】import與from import真的是淺拷貝和深拷貝嗎

最近在準備面試，回頭看python基礎的過程中，遇到一些小問題。 模組的搜尋順序是： 當前程式所在目錄 當前程式根目錄 PYTHONPATH 標準庫目錄 第三方庫目錄site-packages目錄 path 變數本質是一個列表，可以向path中新增模

淺拷貝和深拷貝理解

import copy x = {'username': 'admin', 'machines': ['foo', 'bar', 'baz']} y = copy.deepcopy(x) y['username'] = 'mlh' y['machines'].remove(

Java--淺拷貝和深拷貝的快速理解及實現方式介紹

我們在平時的開發中難免會遇到物件的複製問題。對於一些定義簡單的物件（所有屬性都為基本型別），如果直接賦值操作，相當於兩個物件共用一個地址。修改其中那個物件的屬性值，另一個的屬性值也會一起變化。如果我們想讓它們兩個各自分配空間，就需要用到物件的拷貝。對於物件中只有基本型別屬性的

（一）Python入門-6面向對象編程：11對象的淺拷貝和深拷貝

copy 測試 n) phone alc 拷貝 ini 遞歸 顯示 對象的淺拷貝和深拷貝： 　　變量的賦值操作 　　　　只是形成兩個變量，實際還是指向同一個對象。 　　淺拷貝 　　　　Python拷貝一般都是淺拷貝。拷貝時，對象包含的子對象內容不拷貝。因此，源對象

引用賦值，淺拷貝和深拷貝

lan art csdn 理解 article 淺拷貝和深拷貝 blank .net hang 三種引用： http://blog.csdn.net/XIAXIA__/article/details/41652057 深拷貝和淺拷貝的理解： http://blog.csdn

js 對象的淺拷貝和深拷貝

tex bject script cnblogs ons assign 對象 而已 obj //淺拷貝，拷貝內存塊,拷貝部門代碼不共存 var obj = { a : "a", b : "b", c : { text : "這是一個文本" } }