python淺拷貝

① python的復制，深拷貝和淺拷貝的區別

簡單點說
1. . 淺拷貝 只拷貝父對象，不會拷貝對象的內部的子對象。
2. .deep 深拷貝 拷貝對象及其子對象
用一個簡單的例子說明如下：
>>>import
>>>a = [1, 2, 3, 4, ['a', 'b', 'c']]
>>> b = a
>>> c = .(a)
>>> d = .deep(a)
很容易理解：a是一個列表，表內元素a[4]也是一個列表（也就是一個內部子對象）；b是對a列表的又一個引用，所以a、b是完全相同的，可以通過id(a)==id(b)證明。
第4行是淺拷貝，第五行是深拷貝，通過id(c)和id(d)可以發現他們不相同，且與id(a)都不相同：
>>> id(a)
19276104
>>> id(b)
19276104
>>> id(c)
19113304
>>> id(d)
19286976
至於如何看深/淺拷貝的區別，可以通過下面的操作來展現：
>>> a.append(5) #操作1
>>> a[4].append('hello') #操作2
這時再查看結果：
>>> a
[1, 2, 0, 4, ['a', 'b', 'c', 'hello'], 5]
>>> b
[1, 2, 0, 4, ['a', 'b', 'c', 'hello'], 5]
>>> c
[1, 2, 3, 4, ['a', 'b', 'c', 'hello']]
>>> d
[1, 2, 3, 4, ['a', 'b', 'c']]
可以發現a、b受了操作1、2的影響，c只受操作2影響，d不受影響。a、b結果相同很好理解。由於c是a的淺拷貝，只拷貝了父對象，因此a的子對象（ ['a', 'b', 'c', 'hello']）改變時會影響到c；d是深拷貝，完全不受a的影響

② python的復制，深拷貝和淺拷貝的區別

在Python中存在深拷貝與淺拷貝的區別，相信有些Python初學者可能就有些疑惑，是指什麼意思呢？
1. 賦值其實只是傳遞對象引用，引用對象id是一樣的。
2. 淺拷貝是指拷貝的只是原始對象元素的引用，換句話說，淺拷貝產生的對象本身是新的，但是它的內容不是新的，只是對原對象的一個引用。
3. 深拷貝是指完全拷貝原始對象，而且產生的對象是新的，並且不受其他引用對象的操作影響。

③ Python中的賦值，淺拷貝和深拷貝的區別

賦值(=)，就是創建了對象的一個新的引用，修改其中任意一個變數都會影響到另一個。
淺拷貝：創建一個新的對象，但它包含的是對原始對象中包含項的引用(如果用引用的方式修改其中一個對象，另外一個也會修改改變){1,完全切片方法;2，工廠函數，如list();3，模塊的()函數}
深拷貝：創建一個新的對象，並且遞歸的復制它所包含的對象(修改其中一個，另外一個不會改變){模塊的deep.deep()函數}

④ python深拷貝和淺拷貝的區別

深度拷貝，就是把拷貝對象里所有的東西全部另存一份到新的內存空間，拷貝完後，兩者毫無聯系，從此是路人。跟我們的常識理解是一回事。
淺拷貝，就是把拷貝對象的地址給了需要拷貝的對象，看上去兩個是不同的對象，其實本質都是一回事，也有另外一種淺拷貝，看上去，確實復制了一份新的，但這個新的對象，是個可變對象，它指向的對象內容，仍然沒有復制過來，仍然指向了同一個東西。

⑤ Python3 & 淺拷貝與深拷貝

在Python中對象的賦值（=）其實就是對象的引用。即：當創建一個對象，把它賦值給另一個變數時，python並沒有拷貝這個對象，只是拷貝了這個對象的引用而已。

Python中對象的拷貝分為：淺拷貝()和深拷貝(deep)。
淺拷貝：拷貝了最外圍的對象本身，內部的元素都只是拷貝了一個引用而已。也就是，將原對象在內存中引用地址拷貝過來，然後讓新的對象指向這個地址。可以使用「=」或列表自帶的()函數(如list.()），或使用模塊的()函數。

深拷貝：外圍和內部元素都進行了拷貝對象本身，而不是引用。即把對象復制一遍，並且該對象中引用的其他對象也同時復制，完全得到一個新的一模一樣的對象，對新對象里的值進行修改不會影響原有對象，新對象和原對象完全分離開。深拷貝只能使用模塊中deep()函數，使用前要導入：from import deep。

Python中對象分為不可變對象 、可變對象。
不可變對象：一旦創建就不可修改的對象，例如：字元串、元組、數字
可變對象：可以修改的對象，例如：列表、字典。
其中Python中的切片可以應用於：列表、元組、字元串，但不能應用於字典。
而深淺拷貝，可應用於序列（列表、元組、字元串），也可應用於字典。
其中不可變對象，不管是深拷貝還是淺拷貝，地址值在拷貝後的值都是一樣的。

以下以元組（不可變類型）為例

從上述示例可以看出：
不可變對象類型，沒有被拷貝的說法，即便是用深拷貝，查看id的話也是一樣的，如果對其重新賦值，也只是新創建一個對象，替換掉舊的而已。
所以不可變類型，不管是深拷貝還是淺拷貝，地址值和拷貝後的值都是一樣的。

以下以列表（可變類型）為例
第一種方法：使用=號淺拷貝

輸出結果：

第二種方法：使用淺拷貝

輸出結果：

第三種方法：使用deep深拷貝

輸出結果：

從上述示例可以看出：
=淺拷貝：值相等，地址相等
淺拷貝：值相等，地址不相等
deep深拷貝：值相等，地址不相等

總結：
1，深淺拷貝都是對源對象的復制，佔用不同的內存空間。
2，不可變類型的對象，對於深淺拷貝毫無影響，最終的地址值和值都是相等的。
3，可變類型的對象，使用=淺拷貝時， 值相等，地址相等，對新對象里的值進行修改同時會影響原有對象;使用淺拷貝時值相等，地址不相等;使用deep深拷貝時值相等，地址不相等。可以看出針對可變類型淺拷貝和deep深拷貝，對新對象里的值進行修改不會影響原有對象。

⑥ Python的賦值與復制

對於Python的初學者，在對象的使用過程中，由於對變數的賦值和對象的復制中的概念模糊，導致程序出錯。

例如，下面的代碼：

輸出結果為：

a = [6,2,3,4,5],
b = [6,2,3,4,5],
c = [1,2,3,4,5]
a等於b？True
a等於c？True
a是b？True
a是c? False

可以看到，a，b, c所指向的對象的值都相同（a==b為True). a和b都是代表同一個對象(a is b為True)。當我們通過變數b對該列表進行修改時，由於a也指向該列表，所以當列印a,b時，我們得到相同的值。 而a和c則是代表不同的對象(a is c為False),所以修改b所指向得列表不會改變c梭子鄉的列表的值.

在Python中，所有的變數都代表了對象，即便是簡單的數字類型（int, float, bool），也是以對象的形式存在的。我們看下面的代碼：

輸出結果是：

a==b為True
a is b為True

可見，a, b都是指向同一個對象。接下來，進行下面的操作，

輸出結果是：

a = 1, b = 2
a is b為False

與前面的列表不同，當我們對b做修改時，實際上是給b賦予了一個新生成的對象，對數值類型來說，所有的數值運算都會創建一個數值對象，並將這個對象指定給變數。因此，a與b指向了不同的對象，數值也不同。

再回過頭來看列表對象，

我們知道，b是與a指向同一對象的變數,使用b對該對象進行修改，與使用a對該對象進行修改，效果是完全一樣的。如果我們需要需要一個與a完全相同又與a相互獨立的列表，那麼就需要復制這個對象，也就是新建一個內容和源對象相同的對象。

對於列表來說，最簡單的復制方法是通過下標索引的方式創建新的列表：

對於各種數據類型通用的對象拷貝復制，我們可以使用python內建的模塊。

對於復雜對象（如嵌套列表）的復制，則需要注意區分淺拷貝和深拷貝。我們來看下面的代碼：

得到的結果是：
a[0] is b[0]為 True
a[0] is c[0]為 False
a = [[-1, 2, 3], [4, 5, 6]]
b = [[-1, 2, 3], [7, 8, 9]]
c = [[1, 2, 3], [4, 5, 6]]
a[1] is b[1]為False

從上面的代碼我們可以看到，函數為淺拷貝，只拷貝了對象的外層，而對象內部所包含的對象仍然指向原有的對象。而deep則為深拷貝，對象內部的對象也進行了復制。

以上我們對變數的賦值和對象的復製做了更加深入的分析。在具體的使用中，我們需要根據具體來決定使用賦值、淺拷貝、深拷貝。

⑦ python 為什麼有深拷貝淺拷貝

在寫Python過程中，經常會遇到對象的拷貝，如果不理解淺拷貝和深拷貝的概念，你的代碼就可能出現一些問題。所以，在這里按個人的理解談談它們之間的區別。

一、賦值（assignment）
在《Python FAQ1》一文中，對賦值已經講的很清楚了，關鍵要理解變數與對象的關系。

12345
>>> a = [1, 2, 3]>>> b = a>>> print(id(a), id(b), sep='\n')

在Python中，用一個變數給另一個變數賦值，其實就是給當前內存中的對象增加一個「標簽」而已。
如上例，通過使用內置函數 id() ，可以看出 a 和 b 指向內存中同一個對象。a is b會返回 True 。

二、淺拷貝（shallow ）
注意：淺拷貝和深拷貝的不同僅僅是對組合對象來說，所謂的組合對象就是包含了其它對象的對象，如列表，類實例。而對於數字、字元串以及其它「原子」類型，沒有拷貝一說，產生的都是原對象的引用。
所謂「淺拷貝」，是指創建一個新的對象，其內容是原對象中元素的引用。（拷貝組合對象，不拷貝子對象）
常見的淺拷貝有：切片操作、工廠函數、對象的()方法、模塊中的函數。

12345678910
>>> a = [1, 2, 3]>>> b = list(a)>>> print(id(a), id(b)) # a和b身份不同140601785066200 140601784764968>>> for x, y in zip(a, b): # 但它們包含的子對象身份相同... print(id(x), id(y))... 140601911441984 140601911442048

從上面可以明顯的看出來，a 淺拷貝得到 b，a 和 b 指向內存中不同的 list 對象，但它們的元素卻指向相同的 int 對象。這就是淺拷貝！

三、深拷貝（deep ）
所謂「深拷貝」，是指創建一個新的對象，然後遞歸的拷貝原對象所包含的子對象。深拷貝出來的對象與原對象沒有任何關聯。
深拷貝只有一種方式：模塊中的deep函數。
1234567891011
>>> import >>> a = [1, 2, 3]>>> b = .deep(a)>>> print(id(a), id(b))140601785065840 140601785066200>>> for x, y in zip(a, b):... print(id(x), id(y))... 140601911441984 140601911442048

看了上面的例子，有人可能會疑惑：
為什麼使用了深拷貝，a和b中元素的id還是一樣呢？
答：這是因為對於不可變對象，當需要一個新的對象時，python可能會返回已經存在的某個類型和值都一致的對象的引用。而且這種機制並不會影響 a 和 b 的相互獨立性，因為當兩個元素指向同一個不可變對象時，對其中一個賦值不會影響另外一個。
我們可以用一個包含可變對象的列表來確切地展示「淺拷貝」與「深拷貝」的區別：


>>> import >>> a = [[1, 2],[5, 6], [8, 9]]>>> b = .(a) # 淺拷貝得到b>>> c = .deep(a) # 深拷貝得到c>>> print(id(a), id(b)) # a 和 b 不同139832578518984 139832578335520>>> for x, y in zip(a, b): # a 和 b 的子對象相同... print(id(x), id(y))... 139832578622816 139832578623104>>> print(id(a), id(c)) # a 和 c 不同139832578518984 139832578622456>>> for x, y in zip(a, c): # a 和 c 的子對象也不同... print(id(x), id(y))... 139832578622816 139832578623392

從這個例子中可以清晰地看出淺拷貝與深拷貝地區別。

總結：
1、賦值：簡單地拷貝對象的引用，兩個對象的id相同。
2、淺拷貝：創建一個新的組合對象，這個新對象與原對象共享內存中的子對象。
3、深拷貝：創建一個新的組合對象，同時遞歸地拷貝所有子對象，新的組合對象與原對象沒有任何關聯。雖然實際上會共享不可變的子對象，但不影響它們的相互獨立性。
淺拷貝和深拷貝的不同僅僅是對組合對象來說，所謂的組合對象就是包含了其它對象的對象，如列表，類實例。而對於數字、字元串以及其它「原子」類型，沒有拷貝一說，產生的都是原對象的引用。

⑧ Python對象的拷貝

Python賦值操作或函數參數傳遞，傳遞的永遠是對象引用（即內存地址），而不是對象內容。在Python中一切皆對象，對象又分為可變(mutable)和不可變(immutable)兩種類型。對象拷貝是指在內存中創建新的對象，產生新的內存地址。當頂層對象和它的子元素對象全都是immutable不可變對象時，不存在被拷貝，因為沒有產生新對象。淺拷貝(Shallow Copy)，拷貝頂層對象，但不會拷貝內部的子元素對象。深拷貝(Deep Copy)，遞歸拷貝頂層對象，以及它內部的子元素對象。

Python中一切皆對象，對象就像一個塑料盒子， 裡面裝的是數據。對象有不同類型，例如布爾型和整型，類型決定了可以對它進行的操作。現實生活中的"陶器"會暗含一些信息（例如它可能很重且易碎，注意不要掉到地上）。

對象的類型還決定了它裝著的數據是允許被修改的變數（可變的mutable）還是不可被修改的常量（不可變的immutable）。你可以把不可變對象想像成一個透明但封閉的盒子：你可以看到裡面裝的數據，但是無法改變它。類似地，可變對象就像一個開著口的盒子，你不僅可以看到裡面的數據，還可以拿出來修改它，但你無法改變這個盒子本身，即你無法改變對象的類型。

對象拷貝是指在內存中創建新的對象，產生新的內存地址。

淺拷貝(Shallow Copy)，拷貝頂層對象，但不會拷貝內部的子元素對象。
2.1.1. 頂層是mutable，子元素全是immutable
當頂層對象是mutable可變對象，但是它的子元素對象全都是immutable不可變對象時，如[1, 'world', 2]

① 創建列表對象並賦值給變數a

② 導入模塊，使用.()函數淺拷貝a，並賦值給變數b

③ 修改變數a的子元素a[0] = 3，由於整數是不可變對象，所以並不是修改1變為3，而是更改a[0]指向對象3

當頂層對象是 mutable可變對象 ，但子元素也存在 mutable可變對象 時，如 [1, 2, ['hello','world']]

① 淺拷貝 .() 只拷貝了頂層對象，沒有拷貝子元素對象['hello','world']，即a[2]和b[2]指向同一個列表對象

② 修改a[2][1] = 'china'，則b[2][1] = 'china'

當頂層對象是immutable不可變對象，同時它的子元素對象也全都是immutable不可變對象時，如(1, 2, 3)

變數a與變數b指向的是同一個元組對象，沒有拷貝

當頂層對象是immutable不可變對象時，但子元素存在mutable可變對象時，如(1, 2, ['hello','world'])

變數a與變數b指向的是相同的元組對象，並且a[2]與b[2]指向同一個列表，所以修改a[2][1]會影響b[2][1]

深拷貝(Deep Copy)，遞歸拷貝頂層對象，以及它內部的子元素對象

當頂層對象是mutable可變對象，但是它的子元素對象全都是immutable不可變對象時，如[1, 'world', 2]

變數a與變數b指向不同的列表對象，修改a[0]只是將列表a的第一個元素重新指向新對象，不會影響b[0]

當頂層對象是mutable可變對象，但子元素也存在mutable可變對象時，如[1, 2, ['hello','world']]

深拷貝既拷貝了頂層對象，又遞歸拷貝了子元素對象，所以a[2]與b[2]指向了兩個不同的列表對象(但是列表對象的子元素初始指定的字元串對象一樣)，修改a[2][1] = 'china'後，它重新指向了新的字元串對象（內存地址為140531581905808），不會影響到b[2][1]

當頂層對象是immutable不可變對象，同時它的子元素對象也全都是immutable不可變對象時，如(1, 2, 3)

變數a與變數b指向的是同一個元組對象，不存在拷貝

當頂層對象是immutable不可變對象時，但子元素存在mutable可變對象時，如(1, 2, ['hello','world'])

變數a與變數b指向的是不同的元組對象，同時a[2]與b[2]指向不同的列表對象，所以修改a[2][1]不會影響b[2][1]

使用=是賦值，即將列表對象的引用也賦值給變數b，可以將列表對象想像成一個盒子，變數a相當於這個盒子上的標簽，執行b = a後，相當於再在這個盒子上貼上b標簽，a和b實際上指向的是同一個對象。因此，無論我們是通過a還是通過b來修改列表的內容，其結果都會作用於雙方。

b/c/d都是a的復制，它們都指向了不同的列表對象，但是沒有拷貝子元素，a[2]和b[2]/c[2]/d[2]指向同一個列表， 相當於淺拷貝的效果

使用分片[:]操作，a和b其實是指向同一個元組，而且沒有拷貝子元素，a[2]和b[2]也指向同一個列表，相當於淺拷貝的效果

同列表類似，可以使用字典的()函數或者轉換函數dict()

變數a與變數b/c指向不同的字典，但是沒有拷貝子元素，a['jobs']和b['jobs']/c['jobs']指定同一個列表， 相當於淺拷貝的效果

同列表類似，可以使用集合的()函數或者轉換函數set()

變數a與變數b/c指向不同的集合，而集合的元素必須是hashable，所以修改集合a不會影響到b/c

⑨ python深拷貝和淺拷貝的區別

1. . 淺拷貝 只拷貝父對象，不會拷貝對象的內部的子對象。
2. .deep 深拷貝 拷貝對象及其子對象
一個很好的例子：
import
a = [1, 2, 3, 4, ['a', 'b']] #原始對象

b = a #賦值，傳對象的引用
c = .(a) #對象拷貝，淺拷貝
d = .deep(a) #對象拷貝，深拷貝

a.append(5) #修改對象a
a[4].append('c') #修改對象a中的['a', 'b']數組對象

print 'a = ', a
print 'b = ', b
print 'c = ', c
print 'd = ', d
輸出結果：
a = [1, 2, 3, 4, ['a', 'b', 'c'], 5]
b = [1, 2, 3, 4, ['a', 'b', 'c'], 5]
c = [1, 2, 3, 4, ['a', 'b', 'c']]
d = [1, 2, 3, 4, ['a', 'b']]

⑩ python深拷貝和淺拷貝的區別

1、淺拷貝(shallow )

所謂「淺拷貝」，是指創建一個新的對象，其內容是原對象中元素的引用。(拷貝組合對象，不拷貝子對象)

常見的淺拷貝有：切片操作、工廠函數、對象的()方法、模塊中的函數。

2、深拷貝(deep )

所謂「深拷貝」，是指創建一個新的對象，然後遞歸的拷貝原對象所包含的子對象。深拷貝出來的對象與原對象沒有任何關聯。

深拷貝只有一種方式：模塊中的deep函數。

總結：

淺拷貝，沒有拷貝子對象，所以原始數據改變，子對象會改變

深拷貝，包含對象裡面的自對象的拷貝，所以原始對象的改變不會造成深拷貝里任何子元素的改變