Python字典递归搜索

它的工作方式是，这些键可以从它们关联的列表中转换为任何值。所以我想回答的问题是maximus会变成bumble吗。函数应该返回True，因为maximus->bee->bumble

到目前为止，我的函数使用以下逻辑：

for i in transformers[start]:
    if i in transformers values:
        if desired in transformers[start]:
            return True
        else:
            return search(transformers, i,desired)

发生的事情是，它通过第一个递归，说“好的，maximus现在是prime。”但是在第二个递归中，prime是start，它从函数返回，甚至不检查如果maximus变成bee会发生什么，因为一旦它碰到OldPrime，它就什么也没有返回

transformers = {
    "maximus" : ["prime", "bee", "bomber"],
    "prime" : ["oldPrime","youngerPrime"],
    "bee" : ["bumble","oldBumble"],
    "plareon" : ["moltrees"]
}

---

你应该把你的问题看作是一个问题。现在，帮你解决你的问题

如果您不想创建自己的逻辑来查找图中两个节点之间是否存在路径，可以使用此选项

现在，要查看是否可以从

form1

转换为

form2

，只需检查：

if nx.has_path(G, form1, form2):
    print("Yay, we can transform!")
else:
    print("Oops! I cannot transform :(")

您可能应该首先安装

networkx

。现在，这里是您的函数：

def can_transform (transformer, form, transformers):
    G = nx.DiGraph()
    for t in transformers:
        for f in t:
            G.add_edge(t, f)
    if nx.has_path(G, transformer, form):
        return True
    else:
        return False

---

更新：感谢帮助更正答案的hist评论。

我们可以使用递归来完成此操作。递归总是有基本情况和归纳情况

基本情况是：

“一个物体可以转变成它自己。”（1）

感应情况是：

“一个对象可以转换为请求的对象

req

，前提是它可以转换为下一个对象

nxt

，并且该对象可以转换为请求的对象。（2）

您可以通过递归实现这一点：

def can_transform(st, trans, req):
    if st == req:  # (1)
        return True
    else:  # (2)
        return any(can_transform(nxt, trans, req)
                   for nxt in trans.get(st, ()))

然而，上述方法存在一个潜在问题：我们可能陷入无限循环。例如，如果转换字典如下所示：

{
  'A': ['B','C'],
  'B': ['A']
}

我们看看

'A'

是否可以变成

'C'

，然后程序将搜索以下路径：

'A' -> 'B' -> 'A' -> 'B' -> ...

所以我们永远不会去寻找

'C'

我们可以通过维护一组已经访问过的元素来防止这种情况的发生

def can_transform(st, trans, req):
    visited = set()
    def recurse(st):
        if st == req:
            return True
        elif st not in visited:
            visited.add(st)
            return any(recurse(nxt)
                       for nxt in trans.get(st, ()))
        return False
    return recurse(st)

def can_变换（st、trans、req）：
访问=设置（）
def递归（st）：
如果st==req：
返回真值
未访问的elif st：
已访问。添加（st）
返回任意（递归（nxt）
对于在trans.get（st，（））中的nxt
返回错误
返回递归（st）

---

每次我们这样访问一个元素时，我们都会将其标记为已访问，这样我们就不能再访问它了。

请发布您的函数为什么

maximus

会是一个

bumble

而不是

oldPrime

？您不想退出吗，因为您找到了匹配项：

maximus->prime->oldPrime

？@Bahrom：我的理解是这样的我们看看maximus是否可以转化成一个bumble，我错过了这一点：“maximus可以转化成bumble吗？”“这是有向图吗？或者只是一张图表。如果它是一个不受限制的图，那么程序将测试如果

maximus

可以转换成

prime

，那么

prime

也可以转换成

maximus

。

>>nx.has_path（G，'prime'，maximus'）

返回

True

。Did+1，但您可能需要修复图形是定向的这一事实。

def can_transform(st, trans, req):
    visited = set()
    def recurse(st):
        if st == req:
            return True
        elif st not in visited:
            visited.add(st)
            return any(recurse(nxt)
                       for nxt in trans.get(st, ()))
        return False
    return recurse(st)