啟動任何Python解釋器時，都有70多個內置函數可用。 每個Python學習者都不應不熟悉一些普通的學習者。 例如，我們可以使用len()來獲取對象的長度，例如列表或字典中的項目數。 再舉一個例子，我們可以使用print()打印出感興趣的對象，以進行學習和調試。

[[327474]]

此外，幾乎所有Python程序員都應該在教程中看到內置的id()函數的使用，以用于指導特定的Python概念。 但是，據我所知，這些信息是分散的。 在本文中，我想對使用id()函數理解六個關鍵Python概念進行系統的回顧。

1. 一切都是Python中的對象

作為一種流行的面向對象的編程語言，Python在其實現中隨處使用對象。 例如，諸如整數，浮點數，字符串，列表和字典之類的內置數據類型都是對象。 而且，函數，類甚至模塊也被用作對象。

根據定義，id()函數接受一個對象并返回該對象的標識，即以整數表示的內存地址。 因此，我們可以使用此函數來證明Python中的所有對象都是真實的。

>>> import sys 
>>> class Foo: 
...     pass 
...  
>>> def foo(): 
...     pass 
...  
>>> a_tuple = ('Error', 404) 
>>> a_dict = {'error_code': 404} 
>>> a_list = [1, 2, 3] 
>>> a_set = set([2, 3, 5]) 
>>> objects = [2, 2.2, 'hello', a_tuple, a_dict, a_list, a_set, Foo, foo, sys] 
>>>  
>>> for item in objects: 
...     print(f'{type(item)} with id: {id(item)}') 
...  
<class 'int'> with id: 4479354032 
<class 'float'> with id: 4481286448 
<class 'str'> with id: 4483233904 
<class 'tuple'> with id: 4483061152 
<class 'dict'> with id: 4483236000 
<class 'list'> with id: 4483236720 
<class 'set'> with id: 4483128688 
<class 'type'> with id: 140235151304256 
<class 'function'> with id: 4483031840 
<class 'module'> with id: 4480703856 

在上面的代碼片段中，您可以看到對象列表中的每個項目都可以在id()函數中使用，該函數顯示每個對象的內存地址。

我認為很有趣的以下操作是，作為函數本身，id()函數也應具有其內存地址。

>>> print(f'{type(id)} with id: {id(id)}') 
<class 'builtin_function_or_method'> with id: 4480774224 

2. 變量分配和別名

在Python中創建變量時，通常使用以下語法：

var_name = the_object 

此過程基本上將在內存中創建的對象綁定到特定的變量名稱。 如果為變量分配另一個變量，例如var_name1 = var_name，會發生什么?

考慮以下示例。 在下面的代碼片段中，我們首先創建了一個名為hello的變量，并為其分配了字符串值。 接下來，我們通過分配之前的變量hello創建了另一個名為world的變量。 當我們打印出他們的內存地址時，我們發現hello和world都具有相同的內存地址，這表明它們是內存中的同一對象。

>>> hello = 'Hello World!' 
>>> print(f'{hello} from: {id(hello)}') 
Hello World! from: 4341735856 
>>> world = hello 
>>> print(f'{world} from: {id(world)}') 
Hello World! from: 4341735856 
>>> 
>>> bored = {'a': 0, 'b': 1} 
>>> print(f'{bored} from: {id(bored)}') 
{'a': 0, 'b': 1} from: 4341577200 
>>> more_bored = bored 
>>> print(f'{more_bored} from: {id(more_bored)}') 
{'a': 0, 'b': 1} from: 4341577200 
>>> more_bored['c'] = 2 
>>> bored 
{'a': 0, 'b': 1, 'c': 2} 
>>> more_bored 
{'a': 0, 'b': 1, 'c': 2} 

在這種情況下，變量世界通常稱為變量hello的別名，通過分配現有變量來創建新變量的過程可以稱為別名。 在其他編程語言中，別名非常類似于與內存中基礎對象有關的指針或引用。

在上面的代碼中，我們還可以看到，當我們為字典創建別名并修改別名的數據時，該修改也將應用于原始變量，因為在后臺，我們修改了內存中的同一字典對象。

3. 比較運算符：== vs. is

在各種情況下，我們需要比較兩個對象作為決策點，以便在滿足或不滿足特定條件時應用不同的功能。 就相等比較而言，我們可以使用兩個比較運算符：==和is。 一些新的Python學習者可能會錯誤地認為它們是相同的，但是有細微差別。

考慮以下示例。 我們創建了兩個相同項目的列表。 當我們使用==運算符比較兩個列表時，比較結果為True。 當我們使用is運算符比較兩個列表時，比較結果為False。 他們為什么產生不同的結果? 這是因為==運算符會比較值，而is運算符會比較標識(即內存地址)。

正如您所期望的，這些變量引用了內存中的同一對象，它們不僅具有相同的值，而且具有相同的標識。 這導致==和is運算符的評估結果相同，如下面涉及str0和str1的示例所示：

>>> list0 = [1, 2, 3, 4] 
>>> list1 = [1, 2, 3, 4] 
>>> print(f'list0 == list1: {list0 == list1}') 
list0 == list1: True 
>>> print(f'list0 is list1: {list0 is list1}') 
list0 is list1: False 
>>> print(f'list0 id: {id(list0)}') 
list0 id: 4341753408 
>>> print(f'list1 id: {id(list1)}') 
list1 id: 4341884240 
>>> 
>>> str0 = 'Hello' 
>>> str1 = str0 
>>> print(f'str0 == str1: {str0 == str1}') 
str0 == str1: True 
>>> print(f'str0 is str1: {str0 is str1}') 
str0 is str1: True 
>>> print(f'str0 id: {id(str0)}') 
str0 id: 4341981808 
>>> print(f'str1 id: {id(str1)}') 
str1 id: 4341981808 

4. 整數緩存

我們在編程中經常使用的一組數據是整數。 在Python中，解釋器通常會緩存介于-5到256之間的小整數。這意味著在啟動Python解釋器時，這些整數將被創建并可供以后在內存中使用。 以下代碼片段顯示了此功能：

>>> number_range = range(-10, 265) 
>>> id_counters = {x: 0 for x in number_range} 
>>> id_records = {x: 0 for x in number_range} 
>>>  
>>> for _ in range(1000): 
...     for number in number_range: 
...         idid_number = id(number) 
...         if id_records[number] != id_number: 
...             id_records[number] = id_number 
...             id_counters[number] += 1 
...  
>>> [x for x in id_counters.keys() if id_counters[x] > 1] 
[-10, -9, -8, -7, -6, 257, 258, 259, 260, 261, 262, 263, 264] 

在上面的代碼中，我創建了兩個字典，其中id_counters跟蹤每個整數的唯一標識的計數，而id_records跟蹤整數的最新標識。 對于介于-10到265之間的整數，如果新整數的標識與現有整數不同，則相應的計數器將遞增1。 我重復了這個過程1000次。

代碼的最后一行使用列表推導技術向您顯示具有多個同一性的整數。 顯然，經過1000次后，從-5到256的整數對于每個整數僅具有一個標識，如上一段所述。 要了解有關Python列表理解的更多信息，您可以參考我以前關于此的文章：

5. 淺層和深層副本

有時，我們需要制作現有對象的副本，以便我們可以更改一個副本而不更改另一個副本。 內置的復制模塊為此提供了兩種方法：copy()和deepcopy()，它們分別進行淺拷貝和深拷貝。 如果您不知道它們是什么，讓我們利用id()函數來了解這兩個概念。

>>> import copy 
>>> original = [[0, 1], 2, 3] 
>>> print(f'{original} id: {id(original)}, embeded list id: {id(original[0])}') 
[[0, 1], 2, 3] id: 4342107584, embeded list id: 4342106784 
>>> copycopy0 = copy.copy(original) 
>>> print(f'{copy0} id: {id(copy0)}, embeded list id: {id(copy0[0])}') 
[[0, 1], 2, 3] id: 4341939968, embeded list id: 4342106784 
>>> copycopy1 = copy.deepcopy(original) 
>>> print(f'{copy1} id: {id(copy1)}, embeded list id: {id(copy1[0])}') 
[[0, 1], 2, 3] id: 4341948160, embeded list id: 4342107664 

我們首先創建了一個名為original的列表變量，它由一個嵌套列表和兩個整數組成。 然后，我們分別使用copy()和deepcopy()方法制作了兩個副本(copy0和copy1)。 如我們所料，原始的copy0和copy1具有相同的值(即[[0，1]，2，3])。 但是，它們具有不同的身份，因為與別名不同，copy()和deepcopy()方法均會在內存中創建新對象，從而使新副本具有不同的身份。

淺層副本和深層副本之間最本質的區別是，深層復制將為原始復合對象遞歸創建副本，而淺層復制將在適用的情況下保留對現有對象的引用。 在上面顯示的示例中，變量original實際上是一個復合對象(即一個列表嵌套在另一個列表中)。

在這種情況下，使用copy()方法，變量copy0的第一個元素與原始的第一個元素具有相同的標識(即，相同的對象)。 相比之下，deepcopy()方法在內存中復制嵌套列表，以使copy1中的第一個元素具有與原始元素不同的標識。

但是在深度復制中"遞歸"是什么意思? 這意味著如果存在多層嵌套(例如，嵌套在列表中的列表，又嵌套在另一個列表中)，則deepcopy()方法將為每一層創建新對象。 請參見以下示例以了解此功能：

>>> mul_nested = [[[0, 1], 2], 3] 
>>> print(f'{mul_nested} id: {id(mul_nested)}, inner id: {id(mul_nested[0])}, innermost id: {id(mul_nested[0][0])}') 
[[[0, 1], 2], 3] id: 4342107824, inner id: 4342106944, innermost id: 4342107424 
>>> mul_nested_dc = copy.deepcopy(mul_nested) 
>>> print(f'{mul_nested_dc} id: {id(mul_nested_dc)}, inner id: {id(mul_nested_dc[0])}, innermost id: {id(mul_nested_dc[0][0])}') 
[[[0, 1], 2], 3] id: 4342107264, inner id: 4342107984, innermost id: 4342107904 

6. 數據可變性

Python編程中的一個高級主題與數據可變性有關。 一般來說，不可變數據是指其值在創建后便無法更改的對象，例如整數，字符串和元組。 相比之下，可變數據是指其值在創建后可以更改的那些對象，例如列表，字典和集合。

需要注意的一件事是，通過"更改值"，我們的意思是是否可以更改內存中的基礎對象。 在我的上一篇文章中可以找到關于數據可變性的詳盡討論：

不可變與可變

為了本文討論id()函數的目的，讓我們考慮以下示例。 對于不可變數據類型(代碼片段中的整數變量千)，當我們嘗試更改其值時，會在內存中創建一個新的整數，這由千變量的新標識所反映。 換句話說，原始的基礎整數對象無法更改。 嘗試更改整數只會在內存中創建一個新對象。

>>> thousand = 1000 
>>> print(f'{thousand} id: {id(thousand)}') 
1000 id: 4342004944 
>>> thousand += 1 
>>> print(f'{thousand} id: {id(thousand)}') 
1001 id: 4342004912 
>>> numbers = [4, 3, 2] 
>>> print(f'{numbers} id: {id(numbers)}') 
[4, 3, 2] id: 4342124624 
>>> numbers += [1] 
>>> print(f'{numbers} id: {id(numbers)}') 
[4, 3, 2, 1] id: 4342124624 

如果這讓您感到困惑，讓我們看看可變數據類型發生了什么—在我們的例子中是列表變量編號。 如上面的代碼所示，當我們嘗試更改數字的值時，變量號得到了更新，并且更新后的列表仍具有相同的標識，從而確認了列表類型的對象的可變性。

總結

在本文中，我們利用內置的id()函數來了解Python中的六個關鍵概念。 以下是這些概念的快速回顧：

• Python中的所有內容都是一個對象。
• 我們通過賦值創建變量，別名指向內存中的相同對象。
• 比較運算符==比較值，而比較運算符正在比較標識。
• Python解釋器在啟動時會創建從-5到256的整數對象。
• 淺副本和深副本均具有與其原始對象相同的值，但是淺副本僅復制原始對象的嵌套對象的引用。
• 可變對象的值可以在內存中更改，而不可變對象不支持值更改。