Python 中的 sys 模块极为根底而重要,它次要提供了一些给解释器应用(或由它保护)的变量,以及一些与解释器强交互的函数。
本文将会频繁地应用该模块的 getsizeof() 办法,因而,我先简要介绍一下:
- 该办法用于获取一个对象的字节大小(bytes)
- 它只计算间接占用的内存,而不计算对象内所援用对象的内存
这里有个直观的例子:
import sys
a = [1, 2]
b = [a, a] # 即 [[1, 2], [1, 2]]
# a、b 都只有两个元素,所以间接占用的大小相等
sys.getsizeof(a) # 后果:80
sys.getsizeof(b) # 后果:80
上例阐明了一件事:一个动态创立的列表,如果只蕴含两个元素,那它本身占用的内存就是 80 字节,不论其元素所指向的对象是什么。
好了,领有这把测量工具,咱们就来探索一下 Python 的内置对象都藏了哪些小机密吧。
1、空对象不是“空”的!
对于咱们熟知的一些空对象,例如空字符串、空列表、空字典等等,不晓得大家是否曾好奇过,是否曾思考过这些问题:
空的对象是不是不占用内存呢?如果占内存,那占用多少呢?为什么是这样调配的呢?
间接上代码吧,一起来看看几类根本数据结构的空对象的大小:
import sys
sys.getsizeof("") # 49
sys.getsizeof([]) # 64
sys.getsizeof(()) # 48
sys.getsizeof(set()) # 224
sys.getsizeof(dict()) # 240
# 作为参照:sys.getsizeof(1) # 28
sys.getsizeof(True) # 28
可见,尽管都是空对象,然而这些对象在内存调配上并不为“空”,而且调配得还挺大(记住这几个数字哦,前面会考)。
排一下序:根底数字 < 空元组 < 空字符串 < 空列表 < 空集合 < 空字典。
这个小机密该怎么解释呢?
因为这些空对象都是容器,咱们能够抽象地了解:它们的一部分内存用于创立容器的骨架、记录容器的信息(如援用计数、使用量信息等等)、还有一部分内存则是预调配的。
2、内存裁减不是平均的!
空对象并不为空,一部分起因是 Python 解释器为它们预调配了一些初始空间。在不超出初始内存的状况下,每次新增元素,就应用已有内存,因此防止了再去申请新的内存。
那么,如果初始内存被调配完之后,新的内存是怎么调配的呢?
import sys
letters = "abcdefghijklmnopqrstuvwxyz"
a = []
for i in letters:
a.append(i)
print(f'{len(a)}, sys.getsizeof(a) = {sys.getsizeof(a)}')
b = set()
for j in letters:
b.add(j)
print(f'{len(b)}, sys.getsizeof(b) = {sys.getsizeof(b)}')
c = dict()
for k in letters:
c[k] = k
print(f'{len(c)}, sys.getsizeof(c) = {sys.getsizeof(c)}')
别离给三类可变对象增加 26 个元素,看看后果如何:
由此能看出可变对象在裁减时的机密:
- 超额分配机制:申请新内存时并不是按需分配的,而是多调配一些,因而当再增加大量元素时,不须要马上去申请新内存
- 非平均分配机制:三类对象申请新内存的频率是不同的,而同一类对象每次超额分配的内存并不是平均的,而是逐步扩充的
3、列表不等于列表!
以上的可变对象在裁减时,有类似的分配机制,在动静扩容时可显著看出成果。
那么,动态创立的对象是否也有这样的分配机制呢?它跟动静扩容比,是否有所区别呢?
先看看汇合与字典:
# 动态创建对象
set_1 = {1, 2, 3, 4}
set_2 = {1, 2, 3, 4, 5}
dict_1 = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}
dict_2 = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6}
sys.getsizeof(set_1) # 224
sys.getsizeof(set_2) # 736
sys.getsizeof(dict_1) # 240
sys.getsizeof(dict_2) # 368
看到这个后果,再比照上一节的截图,能够看出:在元素个数相等时,动态创立的汇合 / 字典所占的内存跟动静扩容时齐全一样。
这个论断是否实用于列表对象呢?一起看看:
list_1 = ['a', 'b']
list_2 = ['a', 'b', 'c']
list_3 = ['a', 'b', 'c', 'd']
list_4 = ['a', 'b', 'c', 'd', 'e']
sys.getsizeof(list_1) # 80
sys.getsizeof(list_2) # 88
sys.getsizeof(list_3) # 96
sys.getsizeof(list_4) # 104
上一节的截图显示,列表在前 4 个元素时都占 96 字节,在 5 个元素时占 128 字节,与这里显著矛盾。
所以,这个机密昭然若揭:在元素个数相等时,动态创立的列表所占的内存有可能小于动静扩容时的内存!
也就是说,这两种列表看似雷同,理论却不同!列表不等于列表!
4、消减元素并不会开释内存!
后面提到了,裁减可变对象时,可能会申请新的内存。
那么,如果反过来缩减可变对象,减掉一些元素后,新申请的内存是否会主动回收掉呢?
import sys
a = [1, 2, 3, 4]
sys.getsizeof(a) # 初始值:96
a.append(5) # 裁减后:[1, 2, 3, 4, 5]
sys.getsizeof(a) # 裁减后:128
a.pop() # 缩减后:[1, 2, 3, 4]
sys.getsizeof(a) # 缩减后:128
如代码所示,列表在一扩一缩后,尽管回到了原样,然而所占用的内存空间可没有主动开释啊。其它的可变对象同理。
这就是 Python 的小机密了,“瘦子无奈减重原理”:胖子变胖容易,缩减身型也容易,然而体重减不掉,哈哈~~~
5、空字典不等于空字典!
应用 pop() 办法,只会缩减可变对象中的元素,但并不会开释已申请的内存空间。
还有个 clear() 办法,它会清空可变对象的所有元素,让咱们试试看吧:
import sys
a = [1, 2, 3]
b = {1, 2, 3}
c = {'a':1, 'b':2, 'c':3}
sys.getsizeof(a) # 88
sys.getsizeof(b) # 224
sys.getsizeof(c) # 240
a.clear() # 清空后:[]
b.clear() # 清空后:set()
c.clear() # 清空后:{},也即 dict()
调用 clear() 办法,咱们就取得了几个空对象。
在第一大节里,它们的内存大小曾经被查验过了。(后面说过会考的,请默写回看下)
然而,如果这时再查验的话,你会诧异地发现,这些空对象的大小跟后面查的并不齐全一样!
# 承接后面的清空操作:sys.getsizeof(a) # 64
sys.getsizeof(b) # 224
sys.getsizeof(c) # 72
空列表与空元组的大小不变,然而空字典(72)居然比后面的空字典(240)要小很多!
也就是说,列表与元组在清空元素后,回到终点不变初心,然而,字典这家伙却是“赔了夫人又折兵”,不仅把“吃”进去的全吐出来了,还把本人的老本给亏掉了!
字典的这个机密藏得挺深的,说实话我也是刚刚获知,百思不得其解……
以上就是 Python 在分配内存时的几个小机密啦,看完之后,你是否感觉涨见识了呢?
你想明确了几个呢
以上就是本次分享的所有内容,想要理解更多 python 常识欢送返回公众号:Python 编程学习圈 ,发送“J”即可收费获取,每日干货分享