python不可变对象

清疚 2022-11-20 04:48 243阅读 0赞

### 目录 ###

*  1.python中的对象分类
 *   *  1.1 标准类型的对象（Numeric, Sequence, Mapping）
     *  1.2 其他类型的对象（internal,...）
     *  1.3 python对象特征
 *  2.不可变对象
 *   *  2.1 数字类型（以int型为例）
     *  2.2 字符串类型
     *  2.3 tuple(元组)
 *  3.总结

# 1.python中的对象分类 #

python中的对象分类如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MDQ4NzU2_size_16_color_FFFFFF_t_70_pic_center]

## 1.1 标准类型的对象（Numeric, Sequence, Mapping） ##

Interger 整型  
Boolean 布尔类型  
Float point real number 浮点型  
Complex number 复数型  
String 字符串  
List 列表  
Tuple 元组  
Dictionary 字典

所有标准对象均可用于布尔测试，同类型的对象之间可以比较大小，每个对象天生具有True值或False值，空对象，值为0的任何数字或者None的布尔值都是False。下列对象的布尔值是False：

*  None
 *  False(布尔类型)
 *  所有的值为零的数
 *  0(整型)
 *  0.0 (浮点型)
 *  0.0+0.0j (复数)
 *  空字符串
 *  \[\] 空列表
 *  \{\} 空字典
 *  () 空元组

值不是上面列出来的任何值的对象的布尔值都是True

## 1.2 其他类型的对象（internal,…） ##

类型对象  
Null 对象（None）  
文件  
可变/不可 **集合**  
函数/方法  
模块  
类

特别的，**type类型对象**  
对象的一系列固有行为和特性都是事先定义好，从这个角度来说，类型正是保存这些信息的最佳位置。描述一种类型所需要的信息不可以用一个字符串来搞定，所以类型不能是一个简单的字符串，也不能和数据保存在一起，所以用将类型定义成一个对象是最好的选择。

>>> type(2)
    <type 'int'>
    >>> type(int)
    <type 'type'>
    >>> type(type(1))
    <type 'type'>

通过调用type()函数，能够得到特定对象的类型信息。从上述代码中我们可以知道，所有类型对象的类型都是type，它是所有python类型的根和所有python标准类型的默认元类（metaclass）

## 1.3 python对象特征 ##

*  数字（整数，浮点数，二进制，分数等）  
    支持加法和乘法等
 *  序列（字符串，列表，元组）  
    支持索引，分片和合并
 *  映射（字典）  
    支持通过键的索引等
 *  集合是自成一体的一个分类（不会把键值映射到值，也没有逐位的排序顺序）。
 *

根据其是否可变又分为可变类型与不可变类型：  
1.不可变类型（数字，字符串，元组，不可变集合）：不支持原处修改  
2.可变类型（列表，字典，可变集合）：可以通过操作原处修改，而不用创建新的对象

这里的原处指的是该对象所占的内存地址（也就是标识id），对于容器而言，指的是**容器对象本身的内存地址（id）以及容器对象中的对象的引用的地址（id）**

# 2.不可变对象 #

不可变类型（数字，字符串，元组，不可变集合）：不支持原处修改。有了这个概念后，我最开始非常疑惑，他们怎么就不可变了，怎么证明他们是不可变的。

先解释下引用：

>>> a=345  
    >>> b=a  
    >>> a is b  
    True  
    >>>

在python一切数据皆是对象，而对象是通过引用传递的。在赋值时，不管这个对象是新创建的，还是一个已经存在的，都是将该对象的引用赋值给变量。故这里a实际上和b引用同一个对象，a is b为true！  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MDQ4NzU2_size_16_color_FFFFFF_t_70_pic_center 1]

## 2.1 数字类型（以int型为例） ##

对于a = 3这条语句而言，如下所示，python实际上执行3个步骤完成上述操作  
1.创建变量a（也就是变量a是占内存的，这和c不同，关于具体可以查看下面的博客链接）  
2.创建一个整型对象（分配一块内存）来存储3  
3.将变量与对象通过指针连接起来，从变量到对象的连接称为引用（变量引用对象）  
其中每个对象包含两个头部信息，一个是类型标识符，一个是引用计数器，类型标识符，标记了这个对象的类型，引用计数器标记了该对象被引用的次数，供回收机制使用。

可以看出我们之所以不用声明变量的类型，是因为变量的类型是在运行过程中根据对象的类型（类型标识符）确定的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MDQ4NzU2_size_16_color_FFFFFF_t_70_pic_center 2]  
参考：  
[python中的变量与对象][python]  
[Python“变量名”本身是否占用内存空间][Python]

整型对象是不可变的，我就打算进行测试，如下：

>>> a = 1
    >>> id(a)
    140734036812176
    >>> id(1)
    140734036812176
    >>> a is 1
    True 
    >>> b = 1
    >>> id(b)
    140734036812176
    >>> a is b
    True 
    >>>

发现上述部分证明了整型对象确实是不可变的，接下来我又做了下面的验证：

>>> id(512)
    1915753092688
    >>> id(512)
    1915753092688
    >>> a = 512
    >>> id(a)
    1915753092688
    >>> b = 512
    >>> id(b)
    1915753092080
    >>> c =512
    >>> id(c)
    1915753092016
    >>>

我开始慌了，不是说整型是不可变的么，其实我上面的验证，一开始从思路上就是有问题的，按照a = 3指示的3个步骤，每当a = 512,b= 512, c= 512时，都会开辟新的内存空间来存放512，也就是开辟了3个内存空间来存储512，分别由变量a,b,c来引用这三个整型对象，这3个内存空间的内容并没有修改，而我想对比的id，它们不同，说明这是3个不同的内存空间而已，这里的不可变对象，指的是无法在这3个内存空间上对整型对象进行修改。

那么你可能会问，为什么当值是1的时候，id都是相同的呢，这是因为下面的结论，对于小整数，python缓存了这些小整数，所以不用每次给这些小整数开辟内存空间去重新存放这些小整数对象。

结论：  
（1）但有一个特例，对于小整数\[-5, 256\]。考虑到小整数可能频繁使用，出于性能考虑，Python使用小整数对象缓冲池small\_ints缓存了\[-5，257）之间的整数，该范围内的整数在Python系统中是共享的。小整数对象在py启动过程中初始化，这些个小整数对象的ob\_refcnt不会改变且永远>0,所以在vm运行过程中不会被销毁，所以起到了缓冲的作用。

（2）对于超出了\[-5, 257)之间的其他整数，Python同样提供了专门的缓冲池（通用整数对象的缓冲池），供这些所谓的大整数使用，避免每次使用的时候都要不断的malloc分配内存带来的效率损耗。通过free-list，管理空闲空间。

（3）Python中的int对象就是c语言中long类型数值的扩展。

（4）整数对象回收时，内存并不会归还给系统，而是将其对象的ob\_type指向free\_list，供新创建的对象使用。

关于对上述的理解，如果有错误欢迎提出，因为我没有看源码，是在网上找的一些资料，如果后面有了新的认识会进行订正。

## 2.2 字符串类型 ##

>>> a = 'abc'
    >>> id(a)
    2443240301168
    
    #引用新生成的对象
    >>> b = a.replace('a','A')
    >>> id(b)
    2443240319536
    >>> id(a)
    2443240301168
    >>> b
    'Abc'

要始终牢记的是，a是变量，而’abc’才是字符串对象！有些时候，我们经常说，对象a的内容是’abc’，但其实是指，a本身是一个变量，它指向的对象的内容才是’abc’。

当我们调用a.replace(‘a’, ‘A’)时，实际上调用方法replace是作用在字符串对象’abc’上的，而这个方法虽然名字叫replace，但却没有改变字符串’abc’的内容。相反，replace方法创建了一个新字符串’Abc’并返回，如果我们用变量b指向该新字符串，就容易理解了，变量a仍指向原有的字符串’abc’，但变量b却指向新字符串’Abc’了

## 2.3 tuple(元组) ##

当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来。

最后来看一个“可变的”tuple：

>>> t = ('a', 'b', ['A', 'B'])>>> t('a', 'b', ['A', 'B'])
    >>> t[2][0] = 'X'
    >>> t[2][1] = 'Y'
    >>> t
    ('a', 'b', ['X', 'Y'])

这个tuple定义的时候有3个元素，分别是’a’，'b’和一个list。不是说tuple一旦定义后就不可变了吗？怎么后来又变了？

别急，我们先看看定义的时候tuple包含的3个元素：‘a’, ‘b’, \[‘A’, ‘B’\]

当我们把list的元素’A’和’B’修改为’X’和’Y’后，tuple变为：‘a’, ‘b’, \[‘X’, ‘Y’\]

表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

>>> t = ('a', 'b', ['A', 'B'])
    >>> id(t[2])
    1915751584712
    >>> t[2][0] = 'X'
    >>> id(t[2])
    1915751584712
    >>>

参考链接：  
[python对象分类][python 1]  
[python不可变对象][python 2]

# 3.总结 #

不可变对象是指的其值在原处不可修改，而谈论一个容器的值，是指的其包含的对象的值，因此对于容器而言其包含的对象等价于此处的值，也就是讨论容器的可变性时，则指其直接包含的对象的引用（id）是否可变，而不是根据容器的值（其包含的对象的值）是否可变，例如上面所述的不可变容器tuple的例子，可以看出tuple的值改变了但是其对象的引用并没有改变，因此tuple是属于不可变对象。

对于可变容器对象list,例如，可以看出其对象的引用是可以改变的，因此list是可变对象。

>>> a = [1,2,3,4]
    >>> id(a[0])
    140731715920272
    >>> a[0] = 2
    >>> id(a[0])
    140731715920304

因此对于不可变对象数字、字符串和元组，他们的值在其原处均不可修改（对于容器是指其对象的引用不可更改），而对于可变对象list，dict，他们包含的对象的引用是可以修改的。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MDQ4NzU2_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/c9dcf3e8706d45b3b887239325a413b8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MDQ4NzU2_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/4e76f30447d24840a133dc9f13df8030.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MDQ4NzU2_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/28eff767bda24a7a97ada1c93541b831.png
[python]: https://www.cnblogs.com/my_captain/p/9063224.html
[Python]: https://www.cnblogs.com/lcbbr/p/13446883.html
[python 1]: https://www.cnblogs.com/harvyxu/p/8535930.html
[python 2]: https://www.cnblogs.com/harvyxu/p/8537368.html