2

我目前有一个名为“modules_dict”的有序字典。在“modules_dict”中有类“module_class”的对象，每个对象都可以有“submods”的实例，这些实例也是“module_class”类，依此类推。

我的问题是：如果说存在名称为“digital”的类“module_class”，我该如何检查每个“module_class”及其任何“submods”，如果存在则替换它？

class module_class:
self.name
self.submods = OrderedDict()

例子：

modules_dict = {
"angel": module_class(submods = { 
    "analog": module_class(submods = { 
        "digital": module_class()})
    })
}

非理想解决方案（下面的“self”代表 module_class “digital”）：

for mod in modules_dict.values():
    for submod in mod.submods.values():
        for sub in submod:
            if self.name == sub.name:
                modules_dict[mod.name].submods[sub.name] = [self]

            for sm in sub.submods.values():
                for s in sm:
                    if self.name == s.name:
                        modules_dict[mod.name].submods[sub.name].submods[s.name] = [self]

显然不知道需要多少个 for 循环。我正在考虑使用递归，但我不知道如何更改字典“modules_dict”

4

1 回答 1

1

递归绝对是要走的路，特别是因为你不确定你可以处理多少嵌套的字典。

我尝试了另一个答案，但我无法让它发挥作用。我刚刚成功测试了这个：

def find_and_replace(d, key, replacement="replacement"):
    for k,v in d.items():
        if isinstance(v, dict):
            print "found nested dict"
            if find_and_replace(v, key):
                return True

        elif isinstance(v, str):
            if k==key:
                d.update({k:replacement})
                print "replaced [%s] with [%s]" % (v, replacement)
                return True

这是我的输出： 

>>> etc = {'this': {'that': {'theother': 'a'}}}
>>> find_and_replace(etc, "theother")
found nested dict
found nested dict
replaced [a] with [replacement]
>>> print etc
{'this': {'that': {'theother': 'replacement'}}}

条件是一个占位符，elif isinstance(v, str):供您实施对module实例的检查。我在这里检查字符串，但你明白了。

编辑：问题陈述中的类可以这样实现吗？

import collections
class module_class(object):
    def __init__(self, submods={}):
        self.name = "name"
        self.submods = collections.OrderedDict(submods)
于 2013-10-21T00:33:29.340 回答