Python 中的sys模块极为根底而重要，它次要提供了一些给解释器应用（或由它保护）的变量，以及一些与解释器强交互的函数。

本文将会频繁地应用该模块的getsizeof()办法，因而，我先简要介绍一下：

  • 该办法用于获取一个对象的字节大小（bytes）
  • 它只计算间接占用的内存，而不计算对象内所援用对象的内存

这里有个直观的例子：

import sysa = [1, 2]b = [a, a]  # 即 [[1, 2], [1, 2]]# a、b 都只有两个元素，所以间接占用的大小相等sys.getsizeof(a) # 后果：80sys.getsizeof(b) # 后果：80

上例阐明了一件事：一个动态创立的列表，如果只蕴含两个元素，那它本身占用的内存就是 80 字节，不论其元素所指向的对象是什么。

好了，领有这把测量工具，咱们就来探索一下 Python 的内置对象都藏了哪些小机密吧。

1、空对象不是“空”的！
对于咱们熟知的一些空对象，例如空字符串、空列表、空字典等等，不晓得大家是否曾好奇过，是否曾思考过这些问题：
空的对象是不是不占用内存呢？如果占内存，那占用多少呢？为什么是这样调配的呢？

间接上代码吧，一起来看看几类根本数据结构的空对象的大小：

import syssys.getsizeof("")      # 49sys.getsizeof([])      # 64sys.getsizeof(())      # 48sys.getsizeof(set())   # 224sys.getsizeof(dict())  # 240# 作为参照：sys.getsizeof(1)       # 28sys.getsizeof(True)    # 28

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

排一下序：根底数字<空元组 < 空字符串 < 空列表 < 空集合 < 空字典。

这个小机密该怎么解释呢？

因为这些空对象都是容器，咱们能够抽象地了解：它们的一部分内存用于创立容器的骨架、记录容器的信息（如援用计数、使用量信息等等）、还有一部分内存则是预调配的。

2、内存裁减不是平均的！
空对象并不为空，一部分起因是 Python 解释器为它们预调配了一些初始空间。在不超出初始内存的状况下，每次新增元素，就应用已有内存，因此防止了再去申请新的内存。

那么，如果初始内存被调配完之后，新的内存是怎么调配的呢？

import sysletters = "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)  # 224sys.getsizeof(set_2)  # 736sys.getsizeof(dict_1) # 240sys.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)  # 80sys.getsizeof(list_2)  # 88sys.getsizeof(list_3)  # 96sys.getsizeof(list_4)  # 104

上一节的截图显示，列表在前 4 个元素时都占 96 字节，在 5 个元素时占 128 字节，与这里显著矛盾。

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

也就是说，这两种列表看似雷同，理论却不同！列表不等于列表！

4、消减元素并不会开释内存！
后面提到了，裁减可变对象时，可能会申请新的内存。

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

import sysa = [1, 2, 3, 4]sys.getsizeof(a) # 初始值：96a.append(5)      # 裁减后：[1, 2, 3, 4, 5]sys.getsizeof(a) # 裁减后：128a.pop()          # 缩减后：[1, 2, 3, 4]sys.getsizeof(a) # 缩减后：128

如代码所示，列表在一扩一缩后，尽管回到了原样，然而所占用的内存空间可没有主动开释啊。其它的可变对象同理。

这就是 Python 的小机密了，“瘦子无奈减重原理”：胖子变胖容易，缩减身型也容易，然而体重减不掉，哈哈~~~

5、空字典不等于空字典！
应用 pop() 办法，只会缩减可变对象中的元素，但并不会开释已申请的内存空间。

还有个 clear() 办法，它会清空可变对象的所有元素，让咱们试试看吧：

import sysa = [1, 2, 3]b = {1, 2, 3}c = {'a':1, 'b':2, 'c':3}sys.getsizeof(a) # 88sys.getsizeof(b) # 224sys.getsizeof(c) # 240a.clear()        # 清空后：[]b.clear()        # 清空后：set()c.clear()        # 清空后：{}，也即 dict()

调用 clear() 办法，咱们就取得了几个空对象。

在第一大节里，它们的内存大小曾经被查验过了。（后面说过会考的，请默写回看下）

然而，如果这时再查验的话，你会诧异地发现，这些空对象的大小跟后面查的并不齐全一样！

# 承接后面的清空操作：sys.getsizeof(a) # 64sys.getsizeof(b) # 224sys.getsizeof(c) # 72

空列表与空元组的大小不变，然而空字典（72）居然比后面的空字典（240）要小很多！

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

字典的这个机密藏得挺深的，说实话我也是刚刚获知，百思不得其解……

以上就是 Python 在分配内存时的几个小机密啦，看完之后，你是否感觉涨见识了呢？

你想明确了几个呢

以上就是本次分享的所有内容，想要理解更多 python 常识欢送返回公众号：Python 编程学习圈 ，发送 “J” 即可收费获取，每日干货分享