python —— 可變與不可變類型

標籤：允許   table   charm   記憶體回收   不可   元素   class   char   回收   

可變與不可變類型對象

可變和不可變，本質上就是改變了裡面的資料後，記憶體位址是否有改變

可變類型、不可hash	不可變類型，可hash
列表	字串
字典	數字
集合	元組
	不可變的集合

 

 

　　

　　

 什麼是可變/不可變對象

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

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

不可變對象的例子

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

字串裡的不可變情況

astr = ‘good‘bstr = ‘good‘cstr = astr + ‘‘print(cstr is bstr) # Trueprint(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)沒有變

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

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

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

集合也是一樣的：

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

 和上面list的例子一致。

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

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

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

 

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

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

 ****關於記憶體位址相同的延伸：小資料池

python 為了最佳化速度，避免整數頻繁使用和佔用記憶體空間。對較小的整數在【-5,256】範圍內的整數對象是提前建立好的，不會被記憶體回收，公用同一個記憶體位址

數位比較：

>>> a= 1000 # 使用Python編輯器，超過256，地址就不一樣>>> b = 1000>>> a is bFalse>>> a = 233>>> b = 233>>> a is bTrue

 

字串的比較：

當字串中有空格的時候，記憶體位址不同>>> a = ‘a b c‘>>> b = ‘a b c‘>>> a is bFalse>>> a = ‘a b‘>>> b = ‘a b‘>>> a is bFalse>>> a = ‘ab‘>>> b = ‘ab‘>>> a is bTrue當字串長度 >20，記憶體位址不同>>> a = ‘s‘*20>>> b = ‘s‘*20>>> a is bTrue>>> a = ‘s‘*21>>> b = ‘s‘*21>>> a is bFalse

大整數池：

終端（cmd\）是每執行一次，都會重新建立，而在pycharm中，每次運行都是將所有代碼載入到記憶體中，屬於一個整體，所以會有一個大整數對象池的概念，即處於一個代碼塊的大整數是同一個對象。

# c1 和d1 處於一個代碼塊，相等# c1.b和c2.b分別有自己的代碼塊，不相等Pycharm中的程式：class C1(object):    a = 100    b = 100    c = 1000    d = 1000class D2(object):    a = 100    b = 100    c = 1000print(C1.a is C1.b)  # Trueprint(C1.a is D2.a)  # True
print(C1.a is D2.b)  # True
print(C1.c is C1.d)  # True
print(C1.c is D2.c)  # False

 

python —— 可變與不可變類型