很多人連Python變量都沒搞懂，說自己會python

變量是編程的基礎概念，Python 的變量也看似很簡單，但是如果理解不當，生搬硬套，可能會遇到一些麻煩。

下面用 10 個代碼示例展示 Python 的 變量 本質。不過還要注意：不管你是想學Python還是想找python高薪工作，記住：項目實戰永遠是核心，如果你沒有Python入門到高級實戰視頻教程，可以關注我，後臺私信我 ‘py’ 自動獲取最新python教程資料！還有老司機解答哦！

1. 只是個名字

當 a 出現在賦值語句的左側時，它僅僅代表一個 名字：

<code>a = 1024
a = 'davycloud'
a = ['點贊', '關注', '收藏']
複製代碼/<code>

賦值完成後，這個名字和右側的對象就 綁定 在一起了。在這個過程中，

• a 是否已經綁定了其它對象完全不用考慮，也就是說，不管前面 a 綁定了什麼，或者什麼也沒有綁定，它都是個名字。
• 只要名字是合法的，它可以綁定到任意的對象，完全不用考慮對象的類型

2. 對象的引用

綁定了對象的名字，也就是我們常說的 變量，當它出現在賦值語句的右側時，它代表了 對象的引用:

<code>a = []
b = a
複製代碼/<code>

當把 a 賦給 b 的時候，a 代表的是列表對象的引用，也就是說：

• 列表對象本體不受影響
• 並不會複製出一個新的列表
• a 和 b 在這之後都是這同一個列表的引用

因為列表是可變對象，所以可以通過 a 和 b 任意一個變量改變對象，兩者同時都會反映出對象的變化：

<code>a.append(1)   # a = [1], b = [1]
b.append(2)   # a = [1, 2], b = [1, 2]
複製代碼/<code>

“

可變對象下面會再次討論

3. 先右 後左

把多個賦值語句連在一起時，處理的順序是從右往左：

<code>a = b = []
複製代碼/<code>

這裡 b 首先是充當名字，綁定到一個列表對象；然後又充當對象的引用，賦給另一個名字 a，也就是說，上面的語句等價於:

<code># 寫法1
b = []
a = b
複製代碼/<code>

它和下面的賦值方式有著截然不同的後果：

<code># 寫法2
b = []
a = []
複製代碼/<code>

在這裡，兩個變量分別綁定了兩個不同的列表，它們之間互相併無關聯。

但是這裡有個有趣的地方，如果我們把 [] 換成一個整數 1 或者字符串，那麼 寫法 1 和 寫法 2 兩種賦值方式在結果上就並無不同。

4. 變化取決於對象

繼續上面的例子，兩個名字綁定到同一個列表，操作其中一個，另一個就受到影響：

<code>b = []
a = b
a.append(1)
複製代碼/<code>

這是因為列表是一個 可變對象。而如果把列表換成數字或者字符串:

<code>b = 'davy'
a = b
a += 'cloud' 

複製代碼/<code>

對 a 的自增操作並不會影響到 b。先給出自增操作的等價形式：

<code>a = a + 'cloud'
複製代碼/<code>

可見，這仍然是一次賦值而已。利用前面的結論：

• 右邊的 a 代表對象的引用，即 'davy'，它和 'cloud' 加起來生成一個新的對象
• 左邊的 a 是一個名字，它再次和新對象，即 'davycloud' 綁定在一起

也就是說，這中間總共產生了 3 個字符串對象。

我們仔細觀察不難看出，當我們想要 改變對象的時候，必須通過的是對象提供的接口（對於列表來說，就是 append 方法，或者下標操作，對於其它對象，可以是改變它的屬性），而 不可能通過重新賦值改變對象 。

賦值只是名字的綁定，再次強調。

這裡我們還能得到另外一個結論：

不可變對象被多次引用/綁定不會產生副作用。比如說:

<code># a, b 綁定到同一個對象
a = b = 'davy'

# a, b 分別綁定到一個對象
a = 'davy'
b = 'davy'
複製代碼/<code>

在上面的示例中，兩種綁定的語法含義是不同的，但是，因為字符串是不可變的，也就是說，即使 a 和 b 綁定到同一個字符串，它們也不會互相影響。既然這樣，那麼又何必在內存中重複創建兩個一模一樣的的 davy 字符串出來呢。不如直接複用好了，可以節省一點內存:

<code>>>> a = 'davy'
>>> b = 'davy'
>>> a is b
True
複製代碼/<code>

再次但是，這種優化並不是全局的，也就是說，並不是只要是相同的字符串就一定是唯一的對象：

<code>>>> a += 'cloud'
>>> b += 'cloud'
>>> a is b
False
>>> a
'davycloud'
>>> b
'davycloud'
>>> a == b
True
複製代碼/<code>

所以呢，大家知道有這種情況就好，對於不可變對象都要使用 == 去比較，而不要用 is，因為它可能會產生時而正確時而錯誤的詭異結果。

5. 瞬間交換的秘密

當一個賦值語句中右側出現了多個對象，或者多個對象的引用，它們會自動打包成一個元組。

在賦值語句的左邊，需要有相同數量的名字供解包：

<code>a = [1024]
b = 'davycloud'
a, b = b, a
複製代碼/<code>

這個例子中，綜合利用前 3 個規則：

• 先右後左
• 變量是對象的引用
• 左側是名字

不難得出一個結論，這裡兩個名字交換了對象的引用，對象本體並沒有移動。

6. 都是名字的錯

a 沒有賦值，直接地運行結果：

<code>>>> print(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
複製代碼/<module>/<stdin>/<code>

這裡看似很好解釋，變量 a 沒有定義嘛！加一行賦值語句不就行了。

但是：

• 這裡報的錯誤是 NameError: name 'a' is not defined，名字未定義錯誤，並不是變量未定義
• 仔細想想，這個 a 到底是什麼呢？數字？字符串？函數？類？模塊？

7. 我們都是變量

接上一個例子：

<code>a = 1

def a():
    pass

class a():
    pass

import sys as a
複製代碼/<code>

不僅是賦值，定義函數，定義類，導入模塊或模塊中的對象，都是在綁定名字。

定義函數是把一個名字綁定到一個函數對象，定義類是把名字綁定到一個類對象，導入一個模塊就是把一個名字綁定到一個模塊對象。

Python 中一切皆對象，所以，它們都是變量。

8. 傳參也不過是命名

既然說到了函數，那就繼續來看函數的傳參:

<code>def func(x):
    return x
複製代碼/<code>

這個函數毫無用處，但是正好用來解釋參數的傳入和傳出。

<code>a = func(1024)
b = func(a)
複製代碼/<code>

函數中的參數 x 其實也是一個名字，只是它的 作用域 是限定在 func 函數的內部。

給函數傳參就如同是賦值，給這個內部名字綁定一個對象，而出參就好似出現在賦值右側的變量，就是傳出來一個對象引用:

<code># 偽代碼
func(1024):
    x = 1024
a = x
複製代碼/<code>

“

關於變量的作用域這裡點到為止，有機會再詳細討論。

注意，上面的規則對所有的對象類型都是一樣的，無論是可變對象還是不可變對象。

根據前面的分析，很容易得出結論:

• 如果參數/返回是不可變對象，那麼它是不會產生副作用的
• 如果參數/返回是可變對象，那麼函數內部對它的操作都會影響其它綁定到這個對象上的變量

因此，對於可變對象的傳參需要格外謹慎。特別地，函數的默認參數不要使用可變對象。

因為默認參數的綁定是在函數定義階段發生的:

<code>def get_people(people=[]):
    return people
複製代碼/<code>

在調用 get_people 時，除非給 people 指定一個參數，否則它綁定的總是在函數定義時刻產生的那個列表。而我們的本意可能是，如果默認沒有參數，就生成一個空列表。

一個常規的做法是，在函數內部新建對象:

<code>def get_people(people=None):
    if people is None:
        people = []
    return people
複製代碼/<code>

9. 刪不掉的對象

Python 提供了 del 關鍵字可以用來

刪除

變量，然而實際上這個操作的後果只是把變量名字和對象解綁，然後刪掉這個名字。刪掉的名字如果再訪問，會觸發 NameError，就好像它從來沒存在過一樣。

而對象呢，它們只是減少了一個引用:

<code>a = [1, 2, 3]
b = a
del a    # 完全不會影響到 b
複製代碼/<code>

一個對象有多個變量引用到的情況下不會被清理很好理解，其實即使當前沒有任何名字綁定到這個對象，這個對象也不會立即刪除掉:

<code>>>> a = []
>>> id(a)
2292904305736

>>> del a
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
>>> b = []
>>> id(b)
2292904305736
複製代碼/<module>/<stdin>/<code>

總而言之，del 的含義就是 解綁，別指望它刪除對象。

“

對象的引用計數和銷燬是 Python 內部維護的，一般情況下我們無需關心。有興趣的可以查閱 Python 的垃圾回收相關內容。

10. 淺拷貝？零拷貝！

終極例子:

<code>a = [[]] * 3
a[0].append(1)
print(a)     # [[1], [1], [1]]
複製代碼/<code>

這裡迷惑性比較強，因為用到了列表的 * 操作。當對一個列表乘法操作時，一般的理解是對其中的元素進行 複製（copy）。

看到 copy 很容易又會提起所謂的 淺拷貝 和 深拷貝，這裡顯然不是深拷貝，那麼想當然的很容易理解為是淺拷貝，錯！

這裡不過又是一次隱形的賦值，讓我們把它展開：

<code>x = []
y = [x]
a = [x, x, x]  # a = y * 3 的等價寫法
a[0].append(1)
print(a)
複製代碼/<code>

最重要的就是第 3 行代碼：

• y * 3 是要把 y 中的元素複製 3 份
• 現在這個元素就是 x，
• 那麼就讓 x 重複出現 3 次吧
• 實際的效果就是 [x, x, x]，

x 是對象的引用，所以我們只是把對象的引用複製了 3 份，對象本體完全沒有觸及。

那麼如果要真正複製這個列表應該怎麼做呢？利用到系統提供的淺拷貝函數，或者是利用 切片:

<code># 列表內置的 copy 方法
a = [x.copy() for i in range(3)]

# 利用切片
a = [x[:] for i in range(3)]

# 利用 copy 標準庫
from copy import copy
a = [copy(x) for i in range(3)]
複製代碼/<code>

前面兩種方法是列表對象自帶的接口，而 copy 模塊則更加通用。

小結

• 變量指的是名字綁定了對象
• 綁定時，變量就是名字
• 使用時，變量代表對象的引用
• 變量改變的只有綁定關係
• 想要改變/複製對象，需要看對象有沒有提供方法

最後注意：不管你是想學Python還是想找python高薪工作，記住：項目實戰永遠是核心，如果你沒有Python入門到高級實戰視頻教程，可以關注我，後臺私信我 ‘py’ 自動獲取最新python教程資料！還有老司機解答哦！

本文的文字及圖片來源於網絡加上自己的想法,僅供學習、交流使用,不具有任何商業用途,版權歸原作者所有,如有問題請及時聯繫我們以作處理

閱讀更多 編程叫獸 的文章

關鍵字: 可變 Python 對象