编译为字节码占用内存过多

Question

我需要将一个非常大的字典导入到 python 中，并且遇到了一些意想不到的内存瓶颈。字典的形式如下，

d = {(1,2,3):(1,2,3,4), (2,5,6)=(4,2,3,4,5,6), ... }

因此每个键都是一个 3 元组，每个值都是一个相对较小的任意大小的元组（可能永远不会超过 30 个元素）。字典变大的原因是键的数量。我正在使用的一个较小的示例大约有 247257 个键。我通过模拟生成这个字典，这样我就可以写出一个定义这个字典的文本文件，对于我刚才提到的例子，这是一个 94MB 的文件。我遇到的瓶颈是初始编译为 python 字节代码占用了大约 14GB 的内存。因此，当我第一次导入字典时，我看到 RAM 使用量激增，10 秒后所有内容都已加载。如果 .pyc 文件已生成，则导入几乎是即时的。使用 pympler，我确定这本字典在内存中只有大约 200 MB。这是怎么回事？关于如何将此字典加载到 python 中或至少编译为字节代码，我还有其他选择吗？我正在用 C++ 运行生成模拟，但无法以我需要的任何格式编写文件。有没有什么选择（python 库等）？我正在与一些需要此数据作为字典的软件进行交互，因此请不要在该领域提出其他建议。另外，以防万一您想知道，我已经在文本文件中定义了字典，就像上面的定义一样，

d = {}
d[1,2,3] = (1,2,3,4)
d[2,5,6] = (4,2,3,4,5,6)
...

两者在编译为字节代码时都给出了相同的内存峰值。事实上，第二个似乎稍微差一些，这让我感到惊讶。必须有某种方法来控制初始编译所需的内存量。看起来它应该能够一次编译一个键值对。有什么想法吗？

其他信息： 使用Python 2.6.5

Answer 1

我想问题是，在解析文件时，会生成一个巨大的语法树，每个元素加起来的开销很小。生成字节码后，不再需要语法树并转储，从而生成 200MB 的数据。

您是否尝试过将数据以以下格式存储在单独的文件中，然后在 python 中动态加载？

1,2,3=1,2,3
2,5,6=4,2,3,4,5,6

Python 脚本应如下所示：

file = open("filename")
d = {}

for line in file:
    key, val = line.split("=")
    key = tuple(key.split(","))
    d[key] = tuple(val.split(","))

file.close()

Answer 2

http://docs.python.org/library/shelve.html

Answer 3

我猜测当您执行“import module_containing_humungous_dict_statement”时，您的编译峰值会发生。那么，无论您只有一条语句还是 247257 个单独的赋值语句，整个模块仍然会立即编译。您可以尝试使用单独赋值语句形式，然后打开文件，一次读取一行，然后执行它。那么你一次只会编译一行。可能需要一段时间。

Answer 4

我怀疑创建用作密钥的列表是昂贵的。定义一个函数，将三元组的三个部分作为输入并返回管道分隔的字符串。用它作为你的钥匙。

Answer 5

我阅读你的问题的方式是，你正在模拟器中生成Python源代码，并且生成的源代码具有硬编码的巨型字典的内容。如果这是真的，那么您可能很容易生成这个：

def giantdict():
  d0 = {(1, 2): (3, 4), (3, 4): (5, 6), ...}  # first 1000 key/value pairs here
  d1 = {(1, 2): (3, 4), (3, 4): (5, 6), ...}  # next 1000 key/value pairs
  d2 = {(1, 2): (3, 4), (3, 4): (5, 6), ...}  # next 1000 key/value pairs
  d3 = {(1, 2): (3, 4), (3, 4): (5, 6), ...}  # next 1000 key/value pairs
  # ... until you're done
  bigd = d0
  bigd.update(d1)
  del d1
  bigd.update(d2)
  del d2
  # ... continue updating with all the dN dictionaries
  return bigd

我不确定这是否会缩短编译时间，但这将是值得尝试的事情。如果在编译时将所有内容放入一个数据结构中会产生惩罚，那么将其拆分并在运行时组装各个部分可能会解决这个问题。

虽然这种代码（我的或你的）如果是人类编写的，会引起我的愤怒和愤怒，但我认为生成的代码不需要“好”，只要你知道没有人类永远需要阅读或维护它。

Answer 6

这是一个使用 defaultdict 自动嵌套索引值的类，并使用一些特殊的 __getitem__ 和 __setitem__ 方法来接受元组作为参数：

from collections import defaultdict

defdict3level = (lambda : defaultdict(lambda : 
                            defaultdict( lambda : 
                                defaultdict(tuple))))

class dict3level(object):
    def __init__(self):
        self.defdict = defdict3level()

    def __getitem__(self, key):
        if isinstance(key, tuple):
            if len(key)==3:
                return self.defdict[key[0]][key[1]][key[2]]
            elif len(key)==2:
                return self.defdict[key[0]][key[1]]
            elif len(key)==1:
                return self.defdict[key[0]]
        else:
            return self.defdict[key]

    def __setitem__(self, key, value):
        if isinstance(key, tuple) and len(key)==3:
            self.defdict[key[0]][key[1]][key[2]] = value
        else:
            self.defdict[key] = value

    def __getattr__(self, attr):
        return getattr(self.defdict, attr)

现在像以前一样执行所有分配：

d = dict3level()
d[1,2,3] = (1,2,3,4)
d[1,2,7] = (3,4,5,6)
d[2,5,6] = (4,2,3,4,5,6)

您仍然可以获得特定元组的特定条目：

# get a specific entry
print d[1,2,3]

但您也可以按级别导航您的字典：

# get all different 0'th index values
print d.keys()

# get all sub values in d[1,2,*]
print d[1,2].keys()
for key in d[1,2]:
    print "d[1,2,%d] = %s" % (key, d[1,2][key])

# no such entry, return empty tuple
print d[1,2,0]

给出：（

print d[1,2,3] -> (1, 2, 3, 4)
print d.keys() -> [1, 2]
print d[1,2].keys() -> [3, 7]
for key in d[1,2]:... -> 
    d[1,2,3] = (1, 2, 3, 4)
    d[1,2,7] = (3, 4, 5, 6)
print d[1,2,0] -> ()

不知道这将如何影响您的内存和/或酸洗问题，但生成的结构有很多更多的能力。）

Answer 7

http://bugs.python.org/issue5557