我正在使用 Pympler 进行一些合理性检查，以确保在尝试分析实际脚本时我理解结果，但我对结果有点困惑。以下是我尝试过的完整性检查:

完整性检查 1:我启动 Python (3) 控制台并执行以下操作:

from pympler import summary, muppy
sum = summary.summarize(muppy.get_objects())
summary.print_(sum)

这导致以下摘要:

                               types |   # objects |   total size
==================================== | =========== | ============
                         <class 'str |       16047 |      1.71 MB
                        <class 'dict |        2074 |      1.59 MB
                        <class 'type |         678 |    678.27 KB
                        <class 'code |        4789 |    673.68 KB
                         <class 'set |         464 |    211.00 KB
                        <class 'list |        1319 |    147.16 KB
                       <class 'tuple |        1810 |    120.03 KB
                     <class 'weakref |        1269 |     99.14 KB
          <class 'wrapper_descriptor |        1124 |     87.81 KB
  <class 'builtin_function_or_method |         918 |     64.55 KB
                 <class 'abc.ABCMeta |          64 |     62.25 KB
           <class 'method_descriptor |         877 |     61.66 KB
                         <class 'int |        1958 |     58.88 KB
           <class 'getset_descriptor |         696 |     48.94 KB
                 function (__init__) |         306 |     40.64 KB

如果我刚刚启动了一个新的 Python session ，内存中怎么会有所有这些字符串、字典、列表等？我不认为 Pympler 会总结所有 session 的结果(这没有任何意义，但这是我能想到的唯一可能性)。

SANITY CHECK 2:由于我不太了解 tabula rasa Python session 的汇总结果，所以让我们在定义了一些变量/数据结构之后看看汇总的差异。我启动另一个控制台并执行以下操作:

from pympler import summary, muppy
sum = summary.summarize(muppy.get_objects())
a = {}
b = {}
c = {}
d = {'a': [0, 0, 1, 2], 't': [3, 3, 3, 1]}
sum1 = summary.summarize(muppy.get_objects())
summary.print_(summary.get_diff(sum, sum1))

这导致以下摘要:

                         types |   # objects |   total size
============================== | =========== | ============
                  <class 'list |        3247 |    305.05 KB
                   <class 'str |        3234 |    226.04 KB
                   <class 'int |         552 |     15.09 KB
                  <class 'dict |           1 |    480     B
              function (_keys) |           0 |      0     B
           function (get_path) |           0 |      0     B
          function (http_open) |           0 |      0     B
            function (memoize) |           0 |      0     B
                function (see) |           0 |      0     B
           function (recvfrom) |           0 |      0     B
              function (rfind) |           0 |      0     B
      function (wm_focusmodel) |           0 |      0     B
    function (_parse_makefile) |           0 |      0     B
  function (_decode_pax_field) |           0 |      0     B
             function (__gt__) |           0 |      0     B

我以为我刚刚初始化了四个新词典(尽管有 3 个是空的)，那么为什么 Muppy 只显示 1 个新词典对象的差异？此外，为什么有成千上万的新字符串和列表，更不用说整数了？

健全性检查 3:我又开始了一个新的 Python session ，但这次我想看看 Pympler 如何处理更复杂的数据类型，比如字典列表。

from pympler import muppy, summary
sum = summary.summarize(muppy.get_objects())
a = [{}, {}, {}, {'a': [0, 0, 1, 2], 't': [3, 3, 3, 1]}, {'a': [1, 2, 3, 4]}]
sum1 = summary.summarize(muppy.get_objects())
summary.print_(summary.get_diff(sum, sum1))

结果如下:

                                                types |   # objects |   total size
===================================================== | =========== | ============
                                         <class 'list |        3233 |    303.88 KB
                                          <class 'str |        3270 |    230.71 KB
                                          <class 'int |         554 |     15.16 KB
                                         <class 'dict |          10 |      5.53 KB
                                         <class 'code |          16 |      2.25 KB
                                         <class 'type |           2 |      1.98 KB
                                        <class 'tuple |           6 |    512     B
                            <class 'getset_descriptor |           4 |    288     B
                                  function (__init__) |           2 |    272     B
  <class '_frozen_importlib_external.SourceFileLoader |           3 |    168     B
                 <class '_frozen_importlib.ModuleSpec |           3 |    168     B
                                      <class 'weakref |           2 |    160     B
                                  function (__call__) |           1 |    136     B
                                      function (Find) |           1 |    136     B
                                  function (<lambda>) |           1 |    136     B

尽管列表和词典的嵌套有点复杂，但据我统计，我添加了 5 个新词典和 4 个新列表。

谁能解释一下 Muppy 是如何计算物体数量的？

最佳答案

1 get_objects 在一个新的 Python session 中

summary.summarize(muppy.get_objects()) 返回启动期间实例化的任何对象，而 from pympler import summary, muppy 运行，这解释了大计数。

2 两次get_objects调用的区别

2.1。许多我们没有创建的新对象

请记住，summary.summarize() 生成的 sum 对象是在第一个快照之后创建的，这解释了“数以千计的新字符串和列表”。您可以通过将测试重写为以下方式来解决此问题:

from pympler import summary, muppy
o1 = muppy.get_objects()
a = {}
b = {}
c = {}
d = {'a': [0, 0, 1, 2], 't': [3, 3, 3, 1]}
o2 = muppy.get_objects()
summary.print_(summary.get_diff(summary.summarize(o1), summary.summarize(o2)))

这将减少 o1 和其他几个对象的大列表的无关差异:

>>> for o in diff['+']:
...     print("%s - %s" % (type(o), o if len(o) < 10 else "long list"))
...
<class 'str'> - o2
<class 'list'> - long list
<class 'dict'> - {'a': [0, 0, 1, 2], 't': [3, 3, 3, 1]}
<class 'list'> - ['o2', 'muppy', 'get_objects']
<class 'list'> - [0, 0, 1, 2]
<class 'list'> - [3, 3, 3, 1]

2.2。创建和报告的字典数量不匹配

要理解这一点，我们需要知道 pympler 到底在检查什么。

muppy.get_objects 实现 relies在

• Python 的 gc.get_objects()，它是“收集器跟踪的所有对象的列表”(gc.is_tracked)，堆栈帧除外。

  instances of atomic types aren’t tracked and instances of non-atomic types (containers, user-defined objects…) are. However, some type-specific optimizations can be present in order to suppress the garbage collector footprint of simple instances (e.g. dicts containing only atomic keys and values)

• 然后它添加从第 1 步获得的对象中引用的对象 ( gc.get_referents )，但是 excluding “容器对象”- 那些有 Py_TPFLAGS_HAVE_GC 的对象在他们类型的 __flags__ 中。 (这似乎是一个错误，因为排除所有容器对象会遗漏容器类型的“简单实例”，这些容器类型不受 GC 跟踪。更新 Should be fixed 在 v0.8 中发布，2019-11- 12)

如果您按照上面的建议存储对象列表 o2 并检查使用了哪些对象:

def tracked(obj_list, obj):
    import gc
    return {"tracked_by_muppy": any(id(item) == id(obj) for item in obj_list),
            "gc_tracked": gc.is_tracked(obj)}

你会看到:

• 空字典不会被 GC 跟踪，因为它们仅从局部变量引用，所以它们不会被 muppy 解释:

    tracked(o2, a)  # => {'tracked_by_muppy': False, 'gc_tracked': False}
  

• 非平凡的字典 d 是 GC 跟踪的，因此出现在 muppy 报告中:

    tracked(o2, d)  # => {'tracked_by_muppy': True, 'gc_tracked': True}
  

关于python - Pympler 总结似乎没有意义，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/36609625/