我正在使用Python的multiprocessing.Manager
来共享对一个进程将生成而其他进程将查看的数据集的访问权限。但是,我遇到的问题是manager.dict()
返回的dict代理不支持iteritems()
。
我可以迭代items()
,但这意味着构建dict中所有项目的新元组,这是一个很大的数字。有没有办法在不构建中间列表/元组的情况下完成它,因此只使用一定量的额外内存?
注意:如果解决方案要求生成过程暂停迭代,则可以。
答案 0 :(得分:2)
您可以迭代keys()
以减少内存占用。您必须防止被删除的密钥。
否则,这里有一个示例,它有两种不同的方式可以让您遍历dict中的项目。此示例中的iteritems()
方法仅适用于创建管理器对象的进程和管理器对象创建的子进程。这是因为需要管理器对象来创建新代理,而其他进程无法访问它。 iteritems2()
方法适用于其他进程,因为它不依赖于在这些进程中创建新代理。
import multiprocessing as mp
import multiprocessing.managers
class mydict(dict):
def __init__(self, *args, **kwargs):
dict.__init__(self, *args, **kwargs)
self.iters = {}
def iteritems(self):
print "iteritems", mp.current_process()
return dict.iteritems(self)
def _iteritems_start(self):
print "_iteritems_start", mp.current_process()
i = dict.iteritems(self)
self.iters[id(i)] = i
return id(i)
def _iteritems_next(self, iter_id):
try:
return self.iters[iter_id].next()
except StopIteration:
del self.iters[iter_id]
return None
class mydict_proxy(mp.managers.DictProxy):
def iteritems(self):
print "iteritems proxy", mp.current_process()
return self._callmethod("iteritems")
def iteritems2(self):
print "iteritems2 proxy", mp.current_process()
iter_id = self._callmethod("_iteritems_start")
def generator():
while True:
a = self._callmethod("_iteritems_next",
(iter_id,))
if a == None:
return
yield a
return generator()
_method_to_typeid_ = { "iteritems": "Iterator" }
_exposed_ = mp.managers.DictProxy._exposed_
_exposed_ += ("iteritems", "_iteritems_start", "_iteritems_next")
class mymanager(mp.managers.BaseManager):
pass
mymanager.register("mydict", mydict, mydict_proxy)
mymanager.register("Iterator", proxytype = mp.managers.IteratorProxy,
create_method = False)
def other(d):
for k, v in d.iteritems2():
d[k] = v.lower()
for k, v in d.iteritems():
d[k] = ord(v)
def main():
manager = mymanager()
manager.start()
d = manager.mydict(list(enumerate("ABCDEFGHIJKLMNOP")))
for (k, v) in d.iteritems():
print k, v
proc = mp.Process(target = other, args = (d,))
proc.start()
proc.join()
for (k, v) in d.iteritems():
print k, v
if __name__ == "__main__":
main()
请注意,尽管此代码可能会提高内存效率,但它可能会慢得多。
答案 1 :(得分:0)
您可以使用SyncManager类注册自己的类型。然后,您可以实现该类型的方法,例如仅从字典中获取有限数量的项目。
这是一个让你入门的例子:
import multiprocessing
from multiprocessing import managers
class TakerDict(dict):
"""Like a dict, but allows taking a limited number of items."""
def take(self, items=1):
"""Take the first `items` items."""
return [item for _, item in zip(range(items), self.items())]
# NOTE: add other dict methods to the tuple if you need them.
TakerProxy = managers.MakeProxyType('TakerProxy', ('take',))
managers.SyncManager.register('taker', TakerDict, TakerProxy)
if __name__ == '__main__':
manager = multiprocessing.Manager()
taker = manager.taker()
# in other processes, use e.g. taker.take(5)
因此,为了限制内存使用,您必须重复调用管理器进程以获取下一批元素。
但是,要做到这一点,你的dict必须支持索引(所以你可以从特定的偏移量恢复)。由于您无法访问dict中元素的基础顺序,因此最好使用列表(例如manager.list()
)。然后在您的子流程中,请求列表的len()
,并通过切片索引以获得适当大小的批处理 - 您不需要为此注册任何代理类型。
答案 2 :(得分:-2)
iteritems()
用于 list dict。你可以使用for循环。或者您可以说sorted()
将返回排序列表中的键,然后迭代该列表并执行dict[key]
。希望有所帮助。如果有更好的方法。请与我分享。我很想知道。