python —— 可变与不可变类型

Posted 2020-12-30 fiona128

可变与不可变类型对象

可变和不可变，本质上就是改变了里面的数据后，内存地址是否有改变

可变类型、不可hash	不可变类型，可hash
列表	字符串
字典	数字
集合	元组
	不可变的集合

 

 

　　

　　

 

什么是可变/不可变对象

不可变对象，该对象所指向的内存中的值不能被改变。当改变某个变量时候，由于其所指的值不能被改变，相当于把原来的值复制一份后再改变，这会开辟一个新的地址，变量再指向这个新的地址。

可变对象，该对象所指向的内存中的值可以被改变。变量（准确的说是引用）改变后，实际上是其所指的值直接发生改变，并没有发生复制行为，也没有开辟新的出地址，通俗点说就是原地改变。

不可变对象的例子

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)没有变

 如果是可变对象add = aee，它们指向同一地址（id相同）是肯定的。aee的改变不会引起add的改变，所以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也一样

集合也是一样的：

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]没有变化

 

****关于内存地址相同的延伸：

小数据池

python 为了优化速度，避免整数频繁使用和占用内存空间。对较小的整数在【-5,256】范围内的整数对象是提前建立好的，不会被垃圾回收，公用同一个内存地址

数字的比较：

>>> a= 1000 # 使用Python编辑器，超过256，地址就不一样
>>> b = 1000
>>> a is b
False
>>> a = 233
>>> b = 233
>>> a is b
True

 

字符串的比较：

当字符串中有空格的时候，内存地址不同
>>> a = ‘a b c‘
>>> b = ‘a b c‘
>>> a is b
False
>>> a = ‘a b‘
>>> b = ‘a b‘
>>> a is b
False
>>> a = ‘ab‘
>>> b = ‘ab‘
>>> a is b
True

当字符串长度 >20，内存地址不同
>>> a = ‘s‘*20
>>> b = ‘s‘*20
>>> a is b
True
>>> a = ‘s‘*21
>>> b = ‘s‘*21
>>> a is b
False

大整数池：

终端（cmd）是每执行一次，都会重新创建，而在pycharm中，每次运行都是将所有代码加载到内存中，属于一个整体，所以会有一个大整数对象池的概念，即处于一个代码块的大整数是同一个对象。

# c1 和d1 处于一个代码块，相等
# c1.b和c2.b分别有自己的代码块，不相等
Pycharm中的程序：

class C1(object):
    a = 100
    b = 100
    c = 1000
    d = 1000


class D2(object):
    a = 100
    b = 100
    c = 1000


print(C1.a is C1.b)  # True
print(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