首页 > 代码库 > Python中的可变对象和不可变对象

Python中的可变对象和不可变对象

本文和大家分享的主要是python中可变对象与不可变对象相关内容,一起来看看吧,希望对大家学习python有所帮助。

什么是可变/不可变对象

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

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

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 = 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 = 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]) 相当于原地改变,并没有新的对象产生。

 

 

来源:博客园

Python中的可变对象和不可变对象