可變/不可變對象定義

不可變對象

該對象所指向的記憶體中的值不能被改變。當改變某個變數時候，由於其所指的值不能被改變，相當於把原來的值複製一份後再改變，這會開闢一個新的地址，變數再指向這個新的地址。

可變對象

該對象所指向的記憶體中的值可以被改變。變數（準確的說是引用）改變後，實際上是其所指的值直接發生改變，並沒有發生複製行為，也沒有開闢新的出地址，通俗點說就是原地改變。

Python中，數值類型（int和float）、字元串str、元組tuple都是不可變類型。而列表list、字典dict、集合set是可變類型。

不可變對象的例子

先說明一點is 就是判斷兩個對象的id是否相同， 而 == 判斷的則是內容是否相同。

a = 2
b = 2
c = a + 0 
c += 0

print(id(a), id(b), id(2))  # id都相同
print(c is b) #True

再來看字元串

astr = 'good'
bstr = 'good'
cstr = astr + ''
print(cstr is bstr) # True
print(id(astr), id(bstr), id('good'))  # 三個id相同

 和數值類型的結果一樣。如果是下麵這種情況，變數修改後不在是good

astr = 'good'
print(id(astr))
astr += 'aa'
print(id(astr)) # id和上面的不一樣

 由於是不可變對象，變數對應記憶體的值不允許被改變。當變數要改變時，實際上是把原來的值複製一份後再改變，開闢一個新的地址，astr再指向這個新的地址（所以前後astr的id不一樣），原來astr對應的值因為不再有對象指向它,就會被垃圾回收。這對於int和float類型也是一樣的。

再來看看tuple。

add = (1, 2, 3)
aee = (1, 2, 3)
print(id(add), id(aee), id((1, 2, 3)))  # id各不相同

aee = (1, 2, 3)
print(id(aee))
aee += () # 加空元組
print(id(aee))  # id變了！
print(aee)  #（1 ，2，3）

 雖然看上去都是(1 ,2, 3)按理說應該和上面一致才對。難道這是可變對象？再看

add = (1, 2, 3)
aee = add 
print(id(aee), id(add)) # 這兩個id一樣
aee += (4, 5, 6)
print(id(aee)) # aee的id變了！
print(add) # add還是(1, 2, 3)沒有變

又和數值類型於str類型一致了。如果是可變對象add = aee，它們指向同一地址（id相同）是肯定的。但不是同一對象的不同引用，因為如果是的話，aee的改變會引起add的改變，再tuple中並不是這樣。所以tuple是不可變對象，但又和str和數值類型稍微有點區別。平常說的tuple不可變更多時候是指裡面存放的值不能被改變（有些特殊情況，如tuple裡面存放了list，可改變list里的元素。但實際上這個tuple並沒有被改變）。

對於str、int、float只要在它們再類型相同的情況下，值也相同，那麼它們的id相同。（為什麼要說類型相同？）

a = 2.0
b = 2
print(a is b)  # False, 一個int一個float，類型都不同

 2和2.0就不在一個地址上。

可變對象的例子

lis = [1, 2, 3]
lis2 = [1, 2, 3]
# 雖然它們的內容一樣，但是它們指向的是不同的記憶體地址
print(lis is lis2)
print(id(lis), id(lis2), id([1, 2, 3]))  # 三個id都不同

 再看賦值的情況下

alist = [1, 2, 3]
# alist實際上是對對象的引用，blist = alist即引用的傳遞，現在兩個引用都指向了同一個對象（地址）
blist = alist
print(id(alist), id(blist))  # id一樣
# 所以其中一個變化，會影響到另外一個
blist.append(4)
print(alist)  # 改變blist, alist也變成了[1 ,2 ,3 4]
print(id(alist), id(blist))  # id一樣，和上面值沒有改變時候的id也一樣 

blist = alist這一句。alist實際上是對對象的引用，blist = alist即引用的傳遞，現在兩個引用都指向了同一個對象（地址）。所以其中一個變化，會影響到另外一個。

再看看set

abb = {1, 2, 3}
acc = abb
print(id(abb), id(acc))
acc.add(4)
print(abb)  # {1, 2, 3, 4} 
print(id(abb), id(acc)) # 相等 

和上面list的例子一致。

可變對象由於所指對象可以被修改，所以無需複製一份之後再改變，直接原地改變，所以不會開闢新的記憶體，改變前後id不變。

當然不可變對象就不是這樣了, 可以和這個對比一下

abc = 3
dd = abc
dd = 43
print(abc)  # 3，並不隨dd的改變而改變

 但是如果是拷貝，就僅僅是將內容拷貝過去，傳遞的並是不引用。這在想使用列表的值又不想修改原列表的時候特別有用。

blist = alist[:]  # or alist.copy()
print(alist is blist)  # False
blist.append(4)
print(alist)  # 還是[1，2 ，3]沒有變化

作為函數參數

test_list = [1, 2, 3, 4]
test_str = 'HAHA'

def change(alist):
    alist.append(5)

def not_change(astr):
    astr.lower()

change(test_list)
not_change(test_str)
print(test_list)  # 改變了原來的值
print(test_str)  # 沒有變

 當然了，如果不想改變原來列表的值，參數可以傳入列變的拷貝。alsit[:]

有趣的例子

再看一個有趣的例子，我們知道list是可以使用+添加一個列表的。

a1 = [1, 2, 3]
a2 = a1
print(id(a1), id(a2))
# 實際上是a2指向了新的對象，id已經改變。
# 所以現在a2、a1並不是同一對象的兩個引用了，a2變化a1不會改變
a2 = a2 + [4] # 這個等式中，右邊的a2還是和a1的id一樣的，一旦賦值成功，a2就指向新的對象
print(id(1), id(a2))  # 不等，a2的id變化了
print(a1) # [1, 2, 3]沒有變

 如果是這樣寫

a1 = [1, 2, 3]
a2 = a1
print(id(a1), id(a2))
a2 += [4]  # 相當於調用了a2.extend([4]),原地改變並沒有新的對象產生
print(id(1), id(a2))  # 相等，a2的id沒有變化
print(a1) 

 不同的地方在於a2 += [4]，這句相當於調用了a2.extend([4])相當於原地改變，並沒有新的對象產生。