Python 函数返回的奇性

我花了很多时间搜索所有“my function returns none”和“nested dict search”消息，没有一条消息专门适用，也没有任何消息解决我的问题

我创建了一个函数来搜索嵌套字典并返回路径。这太棒了！我可以在函数中打印结果，但打印下面的返回值不返回任何结果。也许我已经看得太久了，它可能就在我面前，但我只是不知道这里出了什么问题。以下是我的完整代码：

def search(v, searchterm, vid, path=(),):
    if isinstance(v, dict):
        for k, v2 in v.items():
            p2 = path + ('{}'.format(k),)
            search(v2, searchterm, vid, p2)
    else:
      if searchterm in v:
         a = {}
         a[0] = path
         a[1] = v[vid]
         print(a)
         return(a)


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'}
None

您可以从函数中看到打印效果很好，但是return和printfrommain没有返回任何内容。我用Python编程已经有几年了，有很多函数、类和方法都写有返回，但这一个让我很为难。

您正在进行递归调用，而

print

语句是在嵌套调用中发出的。但是，没有使用

search

的返回值，这就是为什么它从未到达

main

函数

下面，我添加了一个

嵌套的

变量，该变量被检查，如果发现任何东西，则实际返回

def search(v, searchterm, vid, path=(),):
  if isinstance(v, dict):
    for k, v2 in v.items():
      p2 = path + ('{}'.format(k),)
      nested = search(v2, searchterm, vid, p2)
      if nested:
        # before, nothing was ever returned here
        return nested  
    else:
      if searchterm in v:
         a = {}
         a[0] = path
         a[1] = v[vid]
         print(a)
         return(a)

不相关，但在这里您可以充分利用python强大的dict文本

  mydata = {
    1: {
      1: ('data-1-1', 'reason-1-1', 'notes-1-1'),
      2: ('data-1-2', 'reason-1-2', 'notes-1-2')
    2: {
      1: ('data-2-1', 'reason-2-1', 'notes-2-1'),
      2: ('data-2-2', 'reason-2-2', 'notes-2-2')
    }

另外，如果所有字典键都是int，那么在进行递归调用时，最好使用

列表
，并在嵌套调用中发出
print
语句。但是，没有使用
search
的返回值，这就是为什么它从未到达
main
函数

下面，我添加了一个
嵌套的
变量，该变量被检查，如果发现任何东西，则实际返回

def search(v, searchterm, vid, path=(),):
  if isinstance(v, dict):
    for k, v2 in v.items():
      p2 = path + ('{}'.format(k),)
      nested = search(v2, searchterm, vid, p2)
      if nested:
        # before, nothing was ever returned here
        return nested  
    else:
      if searchterm in v:
         a = {}
         a[0] = path
         a[1] = v[vid]
         print(a)
         return(a)

不相关，但在这里您可以充分利用python强大的dict文本

  mydata = {
    1: {
      1: ('data-1-1', 'reason-1-1', 'notes-1-1'),
      2: ('data-1-2', 'reason-1-2', 'notes-1-2')
    2: {
      1: ('data-2-1', 'reason-2-1', 'notes-2-1'),
      2: ('data-2-2', 'reason-2-2', 'notes-2-2')
    }

另外，如果您的所有字典键都是int，您也可以在search（）中的3个路径中使用
列表
，只有1个返回：

def search(v, searchterm, vid, path=(),):
    if isinstance(v, dict):
        # Path 1
        for k, v2 in v.items():
            p2 = path + ('{}'.format(k),)
            search(v2, searchterm, vid, p2)
        # Nothing returned here
    else:
      if searchterm in v:
         # Path 2
         a = {}
         a[0] = path
         a[1] = v[vid]
         print(a)
         return(a)
      else:
         # Path 3
         # Nothing returned here

路径1调用路径2，这解释了为什么有些内容已打印但未返回到main（）。
在search（）中的3条路径中，只有1条返回：

def search(v, searchterm, vid, path=(),):
    if isinstance(v, dict):
        # Path 1
        for k, v2 in v.items():
            p2 = path + ('{}'.format(k),)
            search(v2, searchterm, vid, p2)
        # Nothing returned here
    else:
      if searchterm in v:
         # Path 2
         a = {}
         a[0] = path
         a[1] = v[vid]
         print(a)
         return(a)
      else:
         # Path 3
         # Nothing returned here

路径1调用路径2，这解释了为什么有些内容已打印但未返回到main（）。
您使用的是递归，第一行输出来自对
search（）
函数的递归调用中的print语句，第二行来自对同一函数的另一次调用中的return语句（元建议：最好不要事后猜测你的问题会如何被接受，因为一个问题中关于向下/接近投票的最初否定可能会自相矛盾地鼓励这样的回答。我要说你在这里特别幸运，因为你得到了向上投票！此外，问题作者并不总是判断他们的帖子是否正确的最佳人选。）重复，因此最好允许社区按照他们的意愿投票。如果您确实发布了一个已关闭的问题，您可以按照关闭原因或注释中提供的建议重新打开该问题。您使用的是递归，第一行输出来自对
search（）的递归调用中的print语句
function，第二行来自对同一函数的另一个调用中的return语句（元建议：最好不要事后猜测你的问题会如何被接受，因为一个问题中关于向下/接近投票的最初否定可能会自相矛盾地鼓励这样的回答。我要说你在这里特别幸运，因为你得到了向上投票！此外，问题作者并不总是判断他们的帖子是否正确的最佳人选。）副本，因此最好允许社区按照他们的意愿投票。如果您确实发布了一个已关闭的问题，您可以按照关闭原因或评论中提供的建议重新打开该问题。感谢您的帮助、解释和额外提示！我现在理解了原因。感谢您的帮助、解释和额外提示！我现在理解了原因。