一、什么是對象的引用

在 Python 中，對象的引用是指變量指向內存中某個對象的地址或標識符。當你創建一個新的對象(比如一個整數、字符串、列表等)，Python 會分配一塊內存來存儲這個對象，并且給這個對象分配一個唯一的標識符(也就是對象的地址)。當你將這個對象賦值給一個變量時，實際上這個變量就存儲了對該對象的引用，而不是對象本身。這意味著變量并不直接包含對象的值，而是指向存儲這個值的內存地址。

舉例：

In [19]: x = [1, 2, 3] # 創建一個列表對象，并將其引用賦給變量x
In [20]: y = x # y和x現在指向同一個列表對象
In [21]: # 修改x所指向的列表對象
In [22]: x.append(4)
In [23]: print(y) # 輸出[1, 2, 3, 4]，因為y引用的是和x相同的列表對象
[1, 2, 3, 4]

在這個例子中，[1, 2, 3] 是一個列表對象，在內存中有自己的地址。x 這個變量包含了對這個列表對象的引用，而不是列表對象本身。如果你創建一個新的變量 y = x，那么 y 實際上也會指向同一個列表對象，即它們共享相同的引用。圖示：

因此，對于可變對象(如列表、字典等)， 如果多個變量引用了同一個對象，當你通過一個變量修改這個對象時，其他引用了相同對象的變量也會反映出這個修改。這是因為它們引用的是同一個對象，而不是對象的副本。對于不可變對象(如整數、字符串等)， 由于對象本身是不可變的，任何修改都會導致新對象的創建，而不會影響原始對象，因為對不可變對象的修改實際上是創建了一個新對象并將變量重新指向新對象的地址。舉例：

In [33]: x = 300
In [34]: y = x
In [35]: y = 400
In [36]: print(x, y)
300 400

圖示：

補充：在 Python 中，== 和 is 是用于比較對象的運算符，但它們的作用不同：

① == 操作符用于比較兩個對象的值是否相等。
② is 操作符用于檢查兩個對象是否是同一個對象，也就是比較它們的身份標識(即內存地址/引用)是否相同。示例如下：

In [39]: a = [1, 2, 3]
In [40]: b = [1, 2, 3]
In [41]: # 比較值是否相等
In [42]: print(a == b) # 輸出True，因為列表a和列表b中的元素都相同
True
In [43]: # 檢查是否是同一個對象
In [44]: print(a is b) # 輸出False，因為a和b是不同的對象，即在內存地址/引用不一樣
False

注意： 在 Python 中，有一個特定的機制用于緩存一定范圍內的小整數對象，這個范圍通常是 -5~256 (這個范圍可能會因 Python 版本和具體實現而略有不同)。 這意味著在這個范圍內的整數對象在 Python 程序中的生命周期中會被緩存并重用，而不是每次都創建新的對象。這個緩存機制是為了提高性能和節省內存。因為這些小整數在許多情況下是常用的，Python 會在啟動時預先創建這些對象并將其緩存起來，當你需要使用這些整數時，Python 會直接返回緩存中的對象而不是創建新的對象。這種緩存機制使得在相同范圍內的整數對象比較時，使用 is 操作符可能返回 True，因為它們指向相同的對象：

In [45]: x = 10
In [46]: y = 10
In [47]: print(x is y) # 輸出True，因為x和y是同一個對象，由于小整數的緩存機制(有些也稱為常量池)
True
In [48]: a = 300
In [49]: b = 300
In [50]: print(a is b) # 輸出False，因為超出了小整數的緩存范圍，a和b是不同的對象
False

二、深拷貝和淺拷貝

在 Python 中，深拷貝和淺拷貝是用于創建對象副本的概念。在理解這兩者之間的區別之前，讓我們先來看看它們的定義和用法。

2.1 淺拷貝(Shallow Copy)

淺拷貝創建一個新對象，但是只復制了對象的引用。這意味著原始對象及其副本引用了相同的子對象。當你對原始對象或副本對象做出改變時，子對象的改變會反映在兩者之間。

在 Python 中，可以使用 copy 模塊中的 copy() 方法來進行淺拷貝：

In [65]: import copy
In [66]: original_list = [1, 2, [3, 4]]
In [67]: new_list = original_list  # 賦值是最簡單的淺拷貝
In [68]: id(original_list) # 用來顯示original_list指向的數據的內存地址
Out[68]: 1837971633856
In [69]: id(new_list) # 用來顯示new_list指向的數據的內存地址
Out[69]: 1837971633856In [70]: shallow_copied_list = copy.copy(original_list)
In [71]: # 修改shallow_copied_list副本中的元素
In [72]: shallow_copied_list[0] = 5
In [73]: # 修改子對象(原始對象和副本對象共享的對象)
In [74]: shallow_copied_list[2][0] = 6
In [77]: print(original_list, new_list)
[1, 2, [6, 4]] [1, 2, [6, 4]]
In [78]: print(shallow_copied_list)
[5, 2, [6, 4]]

圖示：

字典示例：

In [131]: import copy
In [132]: d = dict(name='AmoXiang',age=19,hobby_list=['dance', 'sing'])
In [133]: co = copy.copy(d)
In [134]: d
Out[134]: {'name': 'AmoXiang', 'age': 19, 'hobby_list': ['dance', 'sing']}
In [135]: co
Out[135]: {'name': 'AmoXiang', 'age': 19, 'hobby_list': ['dance', 'sing']}
In [136]: id(d),id(co)
Out[136]: (1838005229056, 1838001691136)
In [137]: d['name'] = 'Amo'
In [138]: d
Out[138]: {'name': 'Amo', 'age': 19, 'hobby_list': ['dance', 'sing']}
In [139]: co
Out[139]: {'name': 'AmoXiang', 'age': 19, 'hobby_list': ['dance', 'sing']}
In [140]: co['hobby_list'].append('swim')
In [141]: co
Out[141]: {'name': 'AmoXiang', 'age': 19, 'hobby_list': ['dance', 'sing', 'swim']}
In [142]: d
Out[142]: {'name': 'Amo', 'age': 19, 'hobby_list': ['dance', 'sing', 'swim']}
In [143]: id(d['name']),id(co['name'])
Out[143]: (1837976233200, 1837949658800)
In [144]: id(d['age']),id(co['age'])
Out[144]: (1837896002416, 1837896002416)
In [145]: id(d['hobby_list']),id(co['hobby_list'])
Out[145]: (1837979180480, 1837979180480)
In [146]: co['age'] = 20
In [147]: co
Out[147]: {'name': 'AmoXiang', 'age': 20, 'hobby_list': ['dance', 'sing', 'swim']}
In [148]: d
Out[148]: {'name': 'Amo', 'age': 19, 'hobby_list': ['dance', 'sing', 'swim']}

淺拷貝對不可變類型和可變類型的 copy 不同：
① copy.copy 對于可變類型，會進行淺拷貝
② copy.copy 對于不可變類型，不會拷貝，僅僅是指向

In [159]: import copy
In [160]: a = [1,2,3]
In [161]: b = copy.copy(a)
In [162]: id(a),id(b)
Out[162]: (1838001649984, 1837979060672)
In [163]: a.append(4)
In [164]: a
Out[164]: [1, 2, 3, 4]
In [165]: b
Out[165]: [1, 2, 3]
In [166]: a = (1,2,3)
In [167]: b = copy.copy(a)
In [168]: id(a),id(b)
Out[168]: (1838005603584, 1838005603584)

2.2 深拷貝(Deep Copy)

深拷貝創建一個全新的對象，同時遞歸地復制了所有子對象。這意味著原始對象及其副本不共享任何子對象。無論你對原始對象還是副本對象做出任何改變，都不會影響對方。同樣使用 copy 模塊中的 deepcopy() 方法進行深拷貝：

In [90]: import copy
In [91]: original_list = [1, 2, [3, 4]]
In [92]: deep_copied_list = copy.deepcopy(original_list)
In [93]: id(original_list)
Out[93]: 1838005694912
In [94]: id(deep_copied_list)
Out[94]: 1838005773312
In [95]: # 修改副本的元素
In [96]: deep_copied_list[0] = 5
In [97]: # 修改子對象(原始對象和副本對象共享的對象)
In [98]: deep_copied_list[2][0] = 6
In [99]: print(original_list)  # 輸出:[1, 2, [3, 4]]
[1, 2, [3, 4]]
In [100]: print(deep_copied_list)  # 輸出：[5, 2, [6, 4]]
[5, 2, [6, 4]]
In [101]: print(id(original_list[2]))
1838004780096
In [102]: print(id(deep_copied_list[2]))
1838001793984

圖示：

2.3 copy.copy和copy.deepcopy的區別

copy.copy 圖示：

copy.deepcopy 有興趣的可以自己畫一下，這里我就不再進行贅述(圖太難畫了，偷下懶)。