前言
本文通過在一段示例代碼中發現的問題，來給大家詳細介紹了Python中的連接符（+、+=），下面話不多說，來看詳細的介紹吧。
假設有下面一段代碼：
|
1
2
3
4
5
6
7
8
9
10
|
a = [1, 2, 3, 4]b = [5, 6, 7, 8, 9]c = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]for item in (a, b, c): item += [0] * (10 - len(item))print aprint bprint c |
這段代碼的意思是，有三個列表，需要在長度不為 10 的列表尾部填充 0，讓其長度變為10。
輸出如下：
|
1
2
3
|
[1, 2, 3, 4, 0, 0, 0, 0, 0, 0][5, 6, 7, 8, 9, 0, 0, 0, 0, 0][11, 12, 13, 14, 15, 16, 17, 18, 19, 20] |
這里沒什么問題，一切正常。但是，現在變了需求，需要在長度不為 10 的列表的前面填充 0。
那么，我們嘗試做如下的改動：
|
1
2
3
4
5
6
7
8
9
10
|
a = [1, 2, 3, 4]b = [5, 6, 7, 8, 9]c = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]for item in (a, b, c): item = [0] * (10 - len(item)) + itemprint aprint bprint c |
直接來看一下輸出：
|
1
2
3
|
[1, 2, 3, 4][5, 6, 7, 8, 9][11, 12, 13, 14, 15, 16, 17, 18, 19, 20] |
結果卻不是我們想象的那樣。如果你沒有發現問題的所在，就繼續往下看吧。當然，如果你已經看出了其中的端倪，那就不需要在這里浪費時間了。
按照我們固有的思維，上面的方法是可行，例如下面的實例：
|
1
2
3
4
|
>>> l = [1, 2, 3, 4, 5]>>> l = [0]*5 + l>>> l[0, 0, 0, 0, 0, 1, 2, 3, 4, 5] |
這樣的操作讓列表如愿以償的得到我們所期望的改變。
但是，如果我們在其中多加幾個步驟呢：
|
1
2
3
4
5
6
7
8
|
>>> l = [1, 2, 3, 4, 5]>>> id(l)139935500860952>>> l = [0]*5 + l>>> l[0, 0, 0, 0, 0, 1, 2, 3, 4, 5]>>> id(l)139935500783272 |
到此，是不是已經看出問題所在了呢。通過 id() 方法的輸出可以看到，后邊的 “l” 已經不是前邊的 “l” 了。
再看看下邊的例子：
|
1
2
3
4
5
6
7
8
|
>>> l = [1, 2, 3, 4, 5]>>> id(l)139935500861024>>> l += [0]*5>>> l[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]>>> id(l)139935500861024 |
當用 += 時， “l” 前后是一個。此時，我們應該明白一個事實，文章開頭的例子并非莫名其妙，而是有原因的。
別著急，我們再來看看例子：
|
1
2
3
4
5
6
7
8
|
>>> t = (1, 2, 3, 4, 5)>>> id(t)139935501840656>>> t += (0,)*5>>> t(1, 2, 3, 4, 5, 0, 0, 0, 0, 0)>>> id(t)139935502151336 |
可以看到，當我們把列表換成元組時，結果又發生了變化。
那么我們對元組使用 + 操作呢：
|
1
2
3
4
5
6
7
8
|
>>> t = (1, 2, 3, 4, 5)>>> id(t)139935501081200>>> t = (0,)*5 + t>>> t(0, 0, 0, 0, 0, 1, 2, 3, 4, 5)>>> id(t)139935502151336 |
這與列表結果是一樣的，沒有什么不同。
那么，再來看看字符串呢：
|
1
2
3
4
5
6
7
8
|
>>> s = "hello">>> id(s)139935500909712>>> s += "world">>> s'helloworld'>>> id(s)139935500909664 |
結果如同元組，“s” 在使用 += 拼接一個字符串后，被重新賦了值，已然不是之前的變量。反映在內存中就是，“s” 被另外開辟了一個存儲空間來存放值。
這里，我們要談的 Python 連接符就是 + 與 +=。要注意在 Python 中這兩個符號有成含義，一個是運用在數學中的加法運算，一個是用在序列類型上的拼接功能。不過，作為加法運算符時，也遵循本文討論的使用規則。因為討論這兩個符號，本質上是討論 Python 的 immutable 和 mutable，即可變類型與不可變類型。對可變類型也說，我們可以在原地被變量進行修改，也就是說它的存儲空間是可讀可寫的，例如 list；而對于不可變類型來說，它的存儲空間則是只讀的，無法對其進行修改，如果需要對不可變類型進行某些操作來得到新的結果，則需要重新開辟一份存儲空間來存放這個新產生的結果。
由以上列舉的例子，我們可以得到如下的結論：
對于可變類型：
- +： 代表連接操作，其結果會創建一個新的對象。
- +=： 代表追加操作，即 in-place 操作，在原地把另一個對象的內容追加到對象中。
對于不可變類型： + 與 += 都代表連接或求和操作，兩者沒有什么區別，其操作的結果都會產生一個新的對象。
下面我們來分析一下文章開頭的例子，由于 for 迭代相當于賦值，為了簡單起見，我們只分析 a，如下所示：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
>>> a = [1, 2, 3, 4]>>> t = a>>> id(a)139712695835400>>> id(t)139712695835400>>> t += [0]*6>>> t[1, 2, 3, 4, 0, 0, 0, 0, 0, 0]>>> id(t)139712695835400>>> id(a)139712695835400>>> a[1, 2, 3, 4, 0, 0, 0, 0, 0, 0]>>>>>>>>> a = [1, 2, 3, 4]>>> t = a>>> id(a)139712695835464>>> id(t)139712695835464>>> t = [0]*6 + t>>> t[0, 0, 0, 0, 0, 0, 1, 2, 3, 4]>>> a[1, 2, 3, 4]>>> id(a)139712695835464>>> id(t)139712695835400 |
這里， t 是對 a 的一個引用，就相當于文章開頭例子的 item。用 += 對 t 進行操作實際上是對 a 進行操作，而 += 是原地操作，所以改變 t 時，a 也隨之變化；如果用 + 對 t 進行操作，在將結果賦值給 t，那么此時的 t 就不再指向 a 了，而是指向 [0]*6 + t，所以 a 沒有被改變。
總結
以上就是這篇文章的全部內容了，這里討論的只是一個簡單的問題，而我卻用了這么長的篇幅來談論這個問題，所以我想說的是，對于這些小問題，如果你沒有完全理解，那么在程序設計過程中可能會給你帶來麻煩。
