Python 什么'；调用函数时使用和不使用'；返回'；在递归中？

我尝试创建递归函数来生成Pascal三角形，如下所示

    numRows = 5
    ans=[[1],[1,1]]
          
    def pascal(arr,pre,idx):
        if idx==numRows:
            return ans
           
        if len(arr)!=idx:
            for i in range (0,len(pre)-1,1):
                arr+=[pre[i]+pre[i+1]]
        
        if len(arr)==idx:
            arr+=[1]
            ans.append(arr)
            pascal([1],arr,idx+1)
        
    a = pascal([1],ans[1],2)
    return a

我得到的输出是一个空列表

[]

。但是如果我在调用

pascal

as时添加

return

            return pascal([1],arr,idx+1)

输出正确

[[1]，[1,1]，[1,2,1]，[1,3,1]，[1,4,6,4,1]

---

据我所知，

a

应该由

return ans

分配。那么为什么

a

在没有

return

的情况下调用

pascal

时无法得到答案，以及为什么在这种情况下需要

return

？

据我所知，如果你想得到一个值，你需要“return”语句

关键是，如果你没有“返回”，你将不会得到任何值返回

---

希望这有助于..

对于所有具有

return

关键字的algol语言，它完全退出最近的函数，其结果是return参数表达式的结果。例如

def test(v):
  if v == 0:
    return someFun(10)
  ...

如果

v

为零，则函数的结果是

someFun（10）

返回的值。函数的其余部分由…表示。。。除非

v

为非零，否则永远不会执行

如果我们在没有返回的情况下写入相同的代码：

def test(v):
  if v == 0:
    someFun(10)
  ...

现在，当

v

为零时，仍会调用someFun（10），但它返回的值被丢弃，为了使其具有任何真正的意义

someFun

需要做一些副作用，例如打印、存储值、更新对象。除此之外，函数的所有其余部分由。。。然后在

someFun（10）

完成后继续

---

对于Python和许多其他语言来说，根本没有

返回

并不意味着它不返回任何内容。在Python中，每个函数/方法的最后一行都有一个不可见的

返回None

。

当您使用递归时，通常会以某种方式组合返回。可以是一个和，比如斐波那契：

fibonacci(n+1) = fibonnaci(n)+fibonacci(n-1)

或者在矩阵上附加一行，就像你的例子一样。无论如何，如果你没有报税单，你就没有可以合并的信息！考虑FiBnNaCI案例不返回：

def fibonnaci（n）：
如果在执行pascal（[1]，arr，idx+1）

时n，则执行递归调用，但随后丢弃它返回的值。如果要将其返回给调用者，则需要显式使用

returnpascal（…）

事实上，无论如何，在这个例子中递归是不必要的。您可以轻松地重构代码，使用一个简单的

for

循环。例如：

def pascal(numRows):
    ans = [[1]]
    for _ in range(1, numRows):
        pre = ans[-1]
        arr = [1]
        for i in range(0,len(pre)-1,1):
            arr+=[pre[i]+pre[i+1]]
        arr+=[1]
        ans.append(arr)
    return ans

print(pascal(5))

（根据惯例，我在这里使用名称

\uu

作为循环变量的

，因为它是一个未在循环中使用的虚拟变量，但如果您愿意，可以使用其他名称，例如
行
。）

以上尽可能接近原始代码，但您也应该考虑使用<代码> ARR.AppEnter（value）代替<>代码> ARR+= = [Value] /代码>——这是将单个值附加到列表中的正常方式。
返回发送值。No return与
return None
相同，即使op希望递归执行，这可能会更有效