python 可变不可变类型

发布网友 发布时间：2022-04-06 06:56

我来回答

共3个回答

懂视网 时间：2022-04-06 11:17

不可变对象

常见的不可变对象(immutable objects):

1. Number: int, float, complex
2. string
3. tuple
4. frozenset:set 的另外一种类型
   

让我们通过例子感受一下

例子

>>> x=1
>>> y=x
>>> id(x)==id(y)
True
>>> id(1)==id(y)
True

这里创建了两个 int 对象，并且让 x,y 指向同一个对象，然后我们试着修改一下 x,让 x+1

>>>x=x+1

这个时候 x 的 id 值和 y 的 id 以及 1 的 id 还一样吗？

>>> x=x+1
>>> id(x)==id(y)
False
>>> id(x)==id(1)
False
>>> id(1)==id(y)
True

从结果不难看出来，x 所指向的对象已经改变了，但是 1 并没有改变。这就是不可变对象，对于不可变对象来说，一旦创建之后就不允许被改变。

注意: 不可变并不严格等同绝对的不可变

>>> a=([1],2,3)
>>> id(a)
4338862696
>>> id(a[0])
4338949128
>>> a[0][0]=0
>>> id(a)
4338862696
>>> id(a[0])
4338949128

从上面的例子不难看出，我们改变了 a[0] 的值，但是并没有影响它的 id 值。一个不可变容器对象如果包含对可变对象的引用，当后者的值改变时，前者的值也会改变；但是该容器仍属于不可变对象，因为它的 id 值不会改变的。

可变对象

常见的可变对象(mutable objects):

1. list
2. dict
3. set
   

同样的通过例子感受一下

例子

>>> c = [1,2,3]
>>> b = c
>>> id(b)==id(c)
True

创建两个 list 对象，并且让 c,d 指向同一个对象，然后我们试着修改一下 c

c[0]=4

这个时候在看一下两个对象的 id 值是否一致

>>> id(c)==id(b)
True

修改之后，c,d 仍然指向同一个对象，所以不难得出结论,对于一个可变对象来说，修改 value 值并不会对它的 id 造成任何影响

函数参数

对于可变对象和不可变对象，他们两者在函数当作参数传递的时候表现也有所不同

例子

eg0

def update_list(nums_list):
 print(f'2 id:{id(nums_list)}')
 nums_list += [10]
 print(f'3 id:{id(nums_list)}')

 
number_list = [5, 6]
print(f'1:{number_list}, id:{id(number_list)}') 
update_list(number_list)
print(f'4:{number_list}, id:{id(number_list)}')

看一下结果

1:[5, 6], id:4457707912
2 id:4457707912
3 id:4457707912
4:[5, 6, 10], id:4457707912

在看另外一个例子

eg1

def add_num(number):
 print(f'2:{id(number)}')
 number += 1
 print(f'3:{id(number)}')


num = 1
print(f'1:{num}, id:{id(num)}') 
add_num(num)
print(f'4:{num}, id:{id(num)}')

看一下结果

1:1, id:4343768416
2 id:4343768416
3 id:4343768448
4:1, id:4343768416

有其他有些文章中，上面 eg0 被称为引用传递，eg1 被称为值传递。然而在官方文档中，并没有找到有关的这两个名词的任何内容，或者这种方式并不是上述的两者任意一种。

这里的重点是：对于可变对象，在函数中的值的改变，会导致对象改变；对于不可变对象，在函数中值的改变，对其不会造成任何影响

热心网友 时间：2022-04-06 08:25

python的数据类型和c不太一样，有一种分类标准，可变(mutable)/不可变(immutable).
我理解的可变，就是在内存中的那块内容（value）是否可以被改变。如果是不可变的，在对对象本身操作的时候，必须在内存的另外地方再申请一块区域(因为老区域#不可变#)，老的区域就丢弃了(如果还有其他ref，则ref数字减1，类似unix下的hard-link)。如果是可变的，对对象操作的时候，不需要再在其他地方申请内存，只需要在此对象后面连续申请(+/-)即可，也就是它的address会保持不变，但区域会变长或者变短。
不可变类型：string,integer,tuple
>>> var1 = 1
>>> var2 = var1
>>> var1,var2
(1, 1)
>>> id(var1),id(var2) #同指同一内存区域，id相同
(21200672, 21200672)
>>> var1 += 1
>>> var1,var2
(2, 1)
>>> id(var1),id(var2)#由于var1,var2数据不可变的，对var1+1后，申请另外一块区域，id(var1)变了，id(var2)不变,对此区域ref数字-1
(21200660, 21200672)
>>>
可变类型：list,dict
>>> lst1 = [1,2,3]
>>> lst2 = lst1
>>> lst1,lst2
([1, 2, 3], [1, 2, 3])
>>> id(lst1),id(lst2)
(28497360, 28497360)
>>> lst1.append(4)#可变类型的，append后，address会保持不变
>>> lst1,lst2
([1, 2, 3, 4], [1, 2, 3, 4])
>>> id(lst1),id(lst2)#lst1,lst2一直指向同一区域
(28497360, 28497360)
>>>
在操作这种类型的时候要特别小心，dict的key不用可变类型的，函数传参的时候不用可变类型的。
eg:
>>> def dis(arg=[]):
... arg.append('1')
... print arg
...
>>> dis()
['1']
>>> dis()
['1', '1']
>>> dis()
['1', '1', '1']
>>>
参考copy模块，了解更多。
==over==

热心网友 时间：2022-04-06 09:43

像列表、字典、集合这些是可变类型，它们原内存地址上的内容是可以发生变化的。而元祖、变量等，是不可变类型。就拿变量来举例：假设有一个名为a的变量，它就好比一个路牌，它所指向的地方就是它当前的所指的值，而我们平时所说的“更改变量的值”更准确地来说就只是把那个“路牌”所指的方向改了，它原来所指的地方上的值并没有发生变化。（也就是新建了一个内存地址，并指向了那里。）