Python嵌套字典搜索函数返回None异常排查

嘿，作为老Python开发者碰到这种问题确实有点挠头，但其实这是递归函数里一个很容易踩的小坑——你的递归调用没有把找到的结果传递回上层调用，而且字典遍历分支没有处理返回逻辑，导致最终函数默认返回了None。

具体问题点 #

看你的search函数：

• 当处理字典类型的v时，你循环调用了search(v2, searchterm, vid, p2)，但既没有接收这个递归调用的返回值，也没有在找到结果时把它返回给上一层。哪怕深层递归找到了目标并返回了a，这个结果也会被直接丢弃，上层函数继续执行到最后，因为没有明确的返回语句，就默认返回None。
• 函数的字典分支末尾没有任何返回逻辑，遍历完所有键值对后，函数自然返回None。

修复后的代码 #

def search(v, searchterm, vid, path=()):
    if isinstance(v, dict):
        for k, v2 in v.items():
            p2 = path + ('{}'.format(k),)
            # 接收递归调用的返回值
            result = search(v2, searchterm, vid, p2)
            # 如果找到结果，立即返回给上层
            if result is not None:
                return result
        # 遍历完所有字典项都没找到，返回None
        return None
    else:
        if searchterm in v:
            a = {}
            a[0] = path
            a[1] = v[vid]
            print(a)
            return(a)
        # 没找到目标，返回None
        return None

def main():
    mydata = {}
    mydata[1] = {}
    mydata[1][1] = 'data-1-1','reason-1-1','notes-1-1'
    mydata[1][2] = 'data-1-2','reason-1-2','notes-1-2'
    mydata[1][3] = 'data-1-3','reason-1-3','notes-1-3'
    mydata[1][4] = 'data-1-4','reason-1-4','notes-1-4'
    mydata[1][5] = 'data-1-5','reason-1-5','notes-1-5'
    mydata[1][6] = 'data-1-6','reason-1-6','notes-1-6'
    mydata[1][7] = 'data-1-7','reason-1-7','notes-1-7'
    mydata[1][8] = 'data-1-8','reason-1-8','notes-1-8'
    mydata[1][9] = 'data-1-9','reason-1-9','notes-1-9'
    mydata[1][10] = 'data-1-10','reason-1-10','notes-1-10'
    mydata[2] = {}
    mydata[2][1] = 'data-2-1','reason-2-1','notes-2-1'
    mydata[2][2] = 'data-2-2','reason-2-2','notes-2-2'
    mydata[2][3] = 'data-2-3','reason-2-3','notes-2-3'
    mydata[2][4] = 'data-2-4','reason-2-4','notes-2-4'
    mydata[2][5] = 'data-2-5','reason-2-5','notes-2-5'
    mydata[2][6] = 'data-2-6','reason-2-6','notes-2-6'
    mydata[2][7] = 'data-2-7','reason-2-7','notes-2-7'
    mydata[2][8] = 'data-2-8','reason-2-8','notes-2-8'
    mydata[2][9] = 'data-2-9','reason-2-9','notes-2-9'
    mydata[2][10] = 'data-2-10','reason-2-10','notes-2-10'
    b = search(mydata,'reason-2-4', 2)
    print(b)

if __name__ == '__main__':
    main()

运行结果 #

{0: ('2', '4'), 1: 'notes-2-4'}
{0: ('2', '4'), 1: 'notes-2-4'}

关键修改说明 #

1. 接收递归返回值并传递：在字典遍历的循环里，把递归调用的结果存在result里，一旦result不为None（也就是找到了目标），就立刻把它返回给上一层调用，这样结果就能层层传递到最开始的调用处。
2. 明确所有分支的返回逻辑：不管是字典遍历完没找到，还是非字典类型没匹配到目标，都明确返回None，避免函数隐式返回None导致的混淆。

内容的提问来源于stack exchange，提问作者SLAVA