本文和大家分享的主要是python中可變對象與不可變對象相關內容，一起來看看吧，希望對大家學習python有所幫助。

　　什么是可變/不可變對象

　　· 不可變對象，該對象所指向的內存中的值不能被改變。 當改變某個變量時候，由于其所指的值不能被改變，相當于把原來的值復制一份后再改變，這會開辟一個新的地址，變量再指向這個新的地址。

　　· 可變對象，該對象所指向的內存中的值可以被改變。 變量（準確的說是引用）改變后，實際上是其所指的值直接發(fā)生改變，并沒有發(fā)生復制行為，也沒有開辟新的出地址，通俗點說就是 原地改變 。

　　Python中， 數(shù)值類型（ 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相同

　　和數(shù)值類型的結果一樣。如果是下面這種情況，變量修改后不在是 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)沒有變

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

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

　　a = 2.0

　　b = 2print(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即引用的傳遞，現(xiàn)在兩個引用都指向了同一個對象（地址）

　　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 即引用的傳遞，現(xiàn)在兩個引用都指向了同一個對象（地址）。所以其中一個變化，會影響到另外一個。

　　再看看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]沒有變化

　　作為函數(shù)參數(shù)

　　作為函數(shù)參數(shù)，也是一樣的，可變類型傳遞的是引用，不可變類型傳遞的是內容。

　　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)  # 沒有變

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

　　有趣的例子

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

　　a1 = [1, 2, 3]

　　a2 = a1

　　print(id(a1), id(a2))# 實際上是a2指向了新的對象，id已經改變。# 所以現(xiàn)在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]) 相當于原地改變，并沒有新的對象產生。

 

 

來源：博客園