python列表的长度是不可变的_python —— 可变与不可变类型

可变与不可变类型对象

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

可变类型、不可hash

不可变类型,可hash

列表

字符串

字典

数字

集合

元组

不可变的集合

什么是可变/不可变对象

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

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

不可变对象的例子

a = 2b = 2c = 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.0b = 2

print(a is b) # False, 一个int一个float,类型都不同

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

可变对象的例子

lis = [1, 2, 3]

lis2 = [1, 2, 3]

# 虽然它们的内容一样,但是它们指向的是不同的内存地址

print(lis islis2)

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 = 3dd =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 isD2.a) # True

print(C1.a isD2.b) # True

print(C1.c is C1.d) # True

print(C1.c is D2.c) # False

表情包
插入表情
评论将由博主筛选后显示,对所有人可见 | 还能输入1000个字符
相关推荐
©️2020 CSDN 皮肤主题: 游动-白 设计师:白松林 返回首页