Python 從入門到進階之路(七)

豐寸發表於2019-06-18

之前的文章我們簡單介紹了一下 Python 中異常處理,本篇文章我們來看一下 Python 中 is 和 == 的區別及深拷貝和淺拷貝。

我們先來看一下在 Python 中的雙等號 == 。

== 是比較兩個物件的內容是否相等,即兩個物件的“值”是否相等,不管兩者在記憶體中的引用地址是否一樣。

is 比較的是兩個例項物件是不是完全相同,它們是不是同一個物件,佔用的記憶體地址是否相同。即is比較兩個條件:1.內容相同。2.記憶體中地址相同

 1 a = 10000
 2 b = 10000
 3 print(a == b)  # True
 4 print(a is b)  # True
 5 print(id(a))  # 4461408208
 6 print(id(b))  # 4461408208
 7 
 8 a = "hello world"
 9 b = "hello world"
10 print(a == b)  # True
11 print(a is b)  # True
12 print(id(a))  # 4461408208
13 print(id(b))  # 4461408208
14 
15 a = [11,22,33]
16 b = [11,22,33]
17 print(a == b)  # True
18 print(a is b)  # False
19 print(id(a))  # 4409720712
20 print(id(b))  # 4409720776

在上面的程式碼中,我們分別定義了 a 和 b 兩個變數,通過輸出結果可以發現當變數為字串或數字時, is 和 == 的輸出結果是一樣的,當為列表時 is 和 == 結果不一樣,通過列印兩個變數的 id 值可以看出兩個 id 值不一樣,這是由於當我們建立列表 a 和 b 時,是分別開闢了兩塊記憶體來分別儲存這兩個變數,從表象上來看結果是一樣的,但兩個變數所指向的記憶體地址不一樣,我們將上面的程式碼改為如下:

1 a = [11,22,33]
2 b = a
3 print(a == b)  # True
4 print(a is b)  # True
5 print(id(a))  # 4535062408
6 print(id(b))  # 4535062408

在上面的程式碼中,我們並沒有直接給變數 b 賦值,而是讓 b=a,這樣的話 b 和 a 就指向了同一塊記憶體,所以 a is b 就為 True 了。

上面的程式碼我是在 PyCharm 編輯器中實現的,但是在終端命令列實現的話結果卻是不一樣的,如下:

 1 >>> a = 10000
 2 >>> b = 10000
 3 >>> a == b
 4 True
 5 >>> a is b
 6 False
 7 >>> id(a)
 8 4360555120
 9 >>> id(b)
10 4360555216

當我們將 a 和 b 的值變小時,如下:

 1 >>> a = 100
 2 >>> b = 100
 3 >>> a == b
 4 True
 5 >>> a is b
 6 True
 7 >>> id(a)
 8 4357367984
 9 >>> id(b)
10 4357367984

造成上面的原因是因為python對小整數在記憶體中直接建立了一份,不會回收,所有建立的小整數變數直接從物件池中引用他即可。但是注意Python僅僅對比較小的整數物件進行快取(範圍為範圍[-5, 256])快取起來,而並非是所有整數物件。也就說只有在這個[-5,256]範圍內建立的變數值使用is比較時候才會成立。

在 PyCharm 中,當值超過 256 時 is 和 == 的輸出結果仍是一樣,這是因為直譯器也做了一部分優化,對於數字和字串這類變數都進行了快取。

我們再來看一下在終端命令列中當變數為字串時:

 1 >>> a = "hello world"
 2 >>> b = "hello world"
 3 >>> a == b
 4 True
 5 >>> a is b
 6 False
 7 >>> id(a)
 8 4359747248
 9 >>> id(b)
10 4361247408
 1 >>> a = "hello"
 2 >>> b = "hello"
 3 >>> a == b
 4 True
 5 >>> a is b
 6 True
 7 >>> id(a)
 8 4361199040
 9 >>> id(b)
10 4361199040

通過輸出結果可以看出,在命令列中當變數為簡單字串時輸出結果一致,否則輸出結果不一致,這是由於 Python 對簡單字串物件也進行了快取,這樣做的意義是可以優化程式碼的執行速度,減少記憶體消耗。

 

在上面的程式碼中,我們讓 a=b 其實是一種淺拷貝的過程,他們指向的是同一塊記憶體,當我們改變其中一個變數時,另一個也會變,如下:

1 a = [11,22,33]
2 b = a
3 a[0] = 123
4 print(a)  # [123, 22, 33]
5 print(b)  # [123, 22, 33]

在 Python 中還有深拷貝,它是重新開闢一塊區域用來儲存變數的,如下:

 1 import copy
 2 
 3 a = [11, 22, 33]
 4 b = a
 5 c = [11, 22, 33]
 6 d = copy.deepcopy(a)
 7 print(a == b, a is b)  # True True
 8 print(a == c, a is c)  # True False
 9 print(a == d, a is d)  # True False
10 
11 a[0] = 123
12 print(a)  # [123, 22, 33]
13 print(b)  # [123, 22, 33]
14 print(c)  # [11, 22, 33]
15 print(d)  # [11, 22, 33]

在上面的程式碼中我們引入了一個 copy 的模組,引入模組這個之前的文章沒有提到,後續會單獨說一下。

在 copy 模組中有一個 deepcopy() 的方法,從上面的程式碼中可以看出 deepcopy() 的方法就相當於 c=[11,22,33] 這樣重新開闢一塊區域來儲存變數,當 a 變數改變時,淺拷貝的內容 b 會隨之改變,但是深拷貝的內容 d 並不是指向 a 的記憶體地址,所以不會改變。

 

在 copy 的模組中還有一個 copy() 方法,它在某些方面看起來和 deepcopy() 方法是一樣的,其實不一樣,如下:

import copy

a = [11, 22, 33]
b = copy.copy(a)
c = copy.deepcopy(a)
a[0] = 123
print(a)  # [123, 22, 33]
print(b)  # [11, 22, 33]
print(c)  # [11, 22, 33]

從上面的輸出結果看,當 a 變數修改之後,b 變數和 c 變數一樣沒有改變,那 copy() 和 deepcopy() 到底有什麼區別呢,我們再看下面的程式碼:

1 import copy
2 
3 a = [11, 22, [123,456]]
4 b = copy.copy(a)
5 c = copy.deepcopy(a)
6 a[2][0] = 789
7 print(a)  # [11, 22, [789, 456]]
8 print(b)  # [11, 22, [789, 456]]
9 print(c)  # [11, 22, [123, 456]]

從上面的輸出結果可以看出,b 變數隨 a 變數的變化而變化了,而 c 變數沒有。

很顯然這時 copy() 函式拷貝的值隨著原物件的值修改了,而 deepcopy() 的值沒有隨著原物件的值修改。主要是因為 deepcopy()  會將複雜物件的每一層複製一個單獨的個體出來對於 copy() 函式要慎用,慎用。

 

相關文章