趣谈python的内存分配机制

趣谈python的内存分配机制

原文地址：http://www.javashuo.com/article/p-uwslygwm-bd.html

虽然咱们如今得益于时代和技术的发展，不用再担忧内存的问题；可是遥想当年，都是巴不得一个钢镚掰成俩份用，因此我就想深刻了解一下，在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 字节，无论其元素所指向的对象是什么。

咱们已经知道如何测量了，那么咱们就一块儿来探索吧！

一、空对象是“空”的吗？

不知道你们有没有好奇过，空的对象如空字符串、空列表、空字典，他们到底占不占用内存呢？若是占用内存，又占用多少呢？

直接揭晓答案吧：

import sys

print(sys.getsizeof(''))      # 49
print(sys.getsizeof([]))      # 64
print(sys.getsizeof(tuple())) # 48
print(sys.getsizeof(set()))   # 224
print(sys.getsizeof(dict()))  # 240

# 参照：
print(sys.getsizeof(None))    # 16
print(sys.getsizeof(False))   # 24
print(sys.getsizeof(0))       # 24
print(sys.getsizeof(1))       # 28
print(sys.getsizeof(True))    # 28

可见，虽然都是空对象，可是这些对象在内存分配上并不为“空”，并且分配得还挺大（记住这几个数字哦，后面会考）。

排序下就是：基础数字<空元组 < 空字符串 < 空列表 < 空集合 < 空字典。

若是必定要解释的话，个人理解就是：不一样类在建立的时候自带的属性不同，如引用计数、使用量信息等等，还有一部份内存是预分配的。

---

二、内存扩充是均匀的吗？

空对象并不为空，一部分缘由是 Python 解释器为它们预分配了一些初始空间。在不超出初始内存的状况下，每次新增元素，就使用已有内存，于是避免了再去申请新的内存。

那么，若是初始内存被分配完以后，新的内存是怎么分配的呢？

import sys
s = 'abcdefghijklmnopqrstuvwxyz'

a = []
for i in s:
    a.append(i)
    print(len(a) , f"a 的内存占用{sys.getsizeof(a)}")

b = set()
for i in s :
    b.add(i)
    print(len(b),f"b 的内存占用{sys.getsizeof(b)}")

c = dict()
for i in s :
    c[i] = i
    print(len(c) , f"c 的内存占用{sys.getsizeof(c)}")

咱们给三类循环添加了26个元素，结果如何呢？

由此能看出可变对象在扩充时的秘密：

• 超额分配机制：申请新内存时并非按需分配的，而是多分配一些，所以当再添加少许元素时，不须要立刻去申请新内存
• 非均匀分配机制：三类对象申请新内存的频率是不一样的，而同一类对象每次超额分配的内存并非均匀的，而是逐渐扩大的

---

三、列表等于列表？

以上的可变对象在扩充时，有类似的分配机制，在动态扩容时可明显看出效果。

那么，静态建立的对象是否也有这样的分配机制呢？它跟动态扩容比，是否有所区别呢？

先看看集合与字典：

# 静态建立对象
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 字节，与这里明显矛盾。

因此，这个秘密昭然若揭：在元素个数相等时，静态建立的列表所占的内存有可能小于动态扩容时的内存！

也就是说，这两种列表看似相同，实际却不一样！列表不等于列表！

EMMM.....Interesting......

---

四、消减元素就会释放内存？

前面提到了，扩充可变对象时，可能会申请新的内存。

那么，若是反过来缩减可变对象，减掉一些元素后，新申请的内存是否会自动回收掉呢？

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 的小秘密了，“胖子没法减重原理”：瘦子变胖容易，缩减身型也容易，可是体重减不掉，哈哈~~~

---

四、空字典等于空字典？

使用 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）要小不少！

也就是说，列表与元组在清空元素后，回到起点不变初心，然而，字典这家伙倒是“赔了夫人又折兵”，不只把“吃”进去的全吐出来了，还把本身的老本给亏掉了！

EMMM.....Interesting......

以上就是 Python 在分配内存时的几个小秘密啦，看完以后，又能够出去装逼了呢！

若有心得或者疑问，欢迎留言一块儿交流哦~

在这个大世界里还有不少秘密等待着咱们去探索，一块儿加油吧~！