變數賦值的幾種形式細節

本文解釋python中變數賦值的形式，並解釋一些細節。後面還有一篇文章解釋python中按引用賦值的文章。

python中變數賦值的幾種形式。

x = "long"                  # (1).基本形式
x, y = "long", "shuai"      # (2).元組對應賦值
[x, y] = ["long", "shuai"]  # (3).列表對應賦值
a, b, c, d = "long"         # (4).序列賦值
a, *b = 'long'              # (5).解包賦值
a = b = "long"              # (6).多目標賦值
a += 3                      # (7).二元賦值表示式
((a, b), c) = ('lo','ng')   # (8).巢狀賦值序列
 

注意：python的數值是不可變物件，無法在原處修改資料，所以不支援自增、自減。

a++
++a
a--
--b

其中(1)-(3)無需過多解釋，唯一需要注意的是，當使用逗號的時候，python總會臨時或永久地建立成tuple來儲存元素，所以x, y = "long", "shuai"在內部完全等價於(x, y) = ("long", "shuai")。

實際上，列表元素也可以賦值給元組，或者元組賦值給列表，只要兩邊的序列元素個數能對應，無所謂左右兩邊的序列型別：

>>> (x,y) = (1,2)
>>> (x,y) = [1,2]
>>> [x,y] = (1,2)
>>> [x,y] = [1,2]
>>> (x,y) = 'ab'
>>> [x,y] = 'ab'
 

對於(4)賦值方式，是序列賦值的行為，在python中，只要是序列，都可以這樣賦值。正如這裡的變數賦值情況等價於：

a = "l"
b = "o"
c = "n"
d = "g"

如果換成其它的序列也一樣。例如：

a, b, c, d = ("shell","perl","php","python")
a, b, c, d = ["shell","perl","php","python"]

但是變數和序列中的元素必須一一對應。如果變數名與元素個數不同，則會報錯，除非只有一個變數名，這表示將整個序列賦值給這個變數。

如果想要將序列中的元素賦值給不等的變數，可以考慮先將序列進行切片。

>>> str='long'
>>> a, b, c = list(str[:2]) + [str[2:]]
>>> a,b,c
('l', 'o', 'ng')

(5)的賦值方式則正好是讓變數名少於元素個數的方式。這種賦值形式稱為序列解包(下文會專門解釋這種賦值方式)，多出來的元素會全部以列表的方式賦值給最後一個變數名。正如這裡等價於：

a="l"
b=["o", "n", "g"]

下面兩種賦值方式得到的結果是一樣的，a是字串，b是列表，b都包含3個元素：

a, *b = ("shell","perl","php","python")
a, *b = ["shell","perl","php","python"]

賦值的結果：

shell
['perl', 'php', 'python']

(6)的賦值方式等價於：

b = "long"
a = b

python賦值時，總是先計算"="右邊的結果，然後將結果按照賦值方式賦值給"="左邊的變數。所以，這裡的過程是先將"long"賦值給變數b，再將b賦值給變數a。

因為總是先計算右邊，所以交換變數非常的方便。

a, b = "a", "b"

# 交換：
a, b = b, a

# 交換結果：
a = "b"
b = "a"

(7)的賦值方式a += 3在結果上等價於a = a + 3，在其它語言中這兩種賦值方式是完全等價的，但在python中這種增強賦值的方式要比後者更高效率些，為什麼效率要高一些，下文會稍作解釋。在很大程度上來說，Python中只要是簡化的形式，基本上都比更復雜的等價形式效率更高。

(8)的賦值方式((a, b), c) = ('lo', 'ng')是將序列進行巢狀序列賦值，將'lo'賦值給元組(a, b)，'ng'賦值給c，元組又進一步賦值a='l', b='o'。這種賦值方式在python中很好用，特別是在表示式中賦值的時候，比如for迴圈和函式引數：

for (a, b, c) in [(1, 2, 3), (4, 5, 6)]:...
for ((a, b), c) in [((1, 2), 3), ((4, 5), 6)]:...

def f(((a, b), c)):...
f(((1, 2), 3))

關於序列解包

在前面簡單介紹了一下序列解包：

a, *b = 'long'

當使用一個*字首變數的時候，表示將序列中對應的元素全部收集到一個列表中(注意，總是一個列表)，這個列表名為*開頭的那個變數名。*號可以出現在任意位置處，只要賦值的時候能前後對應位置關係即可。

注意其中的幾個關鍵字：序列、對應的元素、列表

• 序列意味著可以是列表、元組、字串等等
  
• 列表意味著只要收集不報錯，賦值給解包變數的一定是一個列表
  
• 對應的元素意味著可能收集到0或任意個元素到列表。

不管如何，收集的結果總是列表，只不過可能是空列表或者只有一個元素的列表。

例如：

L = ['aa','bb','cc','dd']
a, *b = L           # a='aa',b=['bb','cc','dd']
a, b, *c = L        # a='aa',b='bb',c=['cc','dd']
a,*b,d = L          # a='aa',d='dd',b=['bb','cc']
*a,d = L            # a=['aa','bb','cc'],d='dd'
a,b,c,*d = L        # a='aa',b='bb',c='cc',d=['dd']
a,b,c,d,*e = L      # a='aa',b='bb',c='cc',d='dd',e=[]

兩個注意事項：

1. 因為序列解包是根據元素位置來進行賦值的，所以不能出現多個解包變數
   
2. 如果將序列直接賦值給單個解包變數時(即沒有普通變數)，這個解包變數必須放在列表或元組中
   

a,*b,c,*d = L     # 錯誤
*a = L            # 錯誤
[*a] = L          # 正確
(*a) = L          # 正確

之所以單個解包變數時必須放在元組或變數中，看下面兩個等價的例子就很容易理解了：

a, *b = L
(a, *b) = L

最後，序列解包是切片的便捷替代方式。能用序列解包的，都能用切片來實現，但切片要輸入額外的各種字元。例如：

a,b,c = L[0],L[1],L[2:]
a,b,*c = L

需要注意，解包返回的一定是列表，但序列切片返回的內容則取決於序列的型別。例如下面元組的切片返回的是元組，而不是列表：

>>> T=('aa','bb','cc','dd')
>>> a,b,c = T[0],T[1],T[2:]
>>> a,b,c
('aa', 'bb', ('cc', 'dd'))

二元賦值表示式

python支援類似於a += 3這種二元表示式。比如：

a += 3   ->   a = a + 3
a -= 3   ->   a = a - 3
a *= 3   ->   a = a * 3
...

在python中的某些情況下，這種二元賦值表示式可能比普通的賦值方式效率更高些。原因有二：

1. 二元賦值表示式中，a可能會是一個表示式，它只需計算評估一次，而a = a + 3中，a要計算兩次。
   
2. 對於可變物件，可以直接在原處修改得到修改後的值，而普通的一元賦值表示式必須在記憶體中新建立一個修改後的資料物件，並賦值給變數

第一點無需解釋。關於第二點，看下面的例子：

L = [1,2,3]
L = L + [4]     # (1)：慢
L += [4]        # (2)：快
L.append(4)     # (3)：快，等價於(2)

L = L + [5,6]   # (4)：慢
L += [5,6]      # (5)：快
L.extend([5,6]) # (6)：快，等價於(5)

對於上面(1)和(4)的一元賦值表示式，先取得L，然後建立一個新的列表物件，將L的資料拷貝到新列表物件中，並將4或5,6放進新列表物件，最後賦值給L。這個過程中涉及到了幾個步驟：新分配記憶體、記憶體中列表資料拷貝、放入新資料。所以，效率較差，特別是L比較大的時候，拷貝L也是高開銷的動作。

而(2)(3)是等價的，(5)(6)也是等價的，它們都是直接在記憶體中的原始列表處修改，不會有拷貝操作，新建的資料物件僅僅只是一個元素。

所以，使用二元賦值表示式通常可以作為可變物件賦值的一種優化手段。