Python 带初始化的递归函数

我正在尝试编写一个递归函数来对数字中的数字求和。我就是这样做的：

def f(N):
    sum = 0
    return foo(N,sum)

def foo(N, sum):
    if N < 10:
        sum = sum + N
#        print 'N=', N
        return sum
    else:
        sum = sum + N%10
#        print 'N=', N, 'sum= ', sum
        return sum and foo(N/10,sum)


res =  f(5)
print 'N=5', 'res=', res
res =  f(59)
print 'N=59', 'res=', res
res =  f(568)
print 'N=568', 'res=', res

def（N）：
总和=0
返回foo（N，总和）
def foo（N，总和）：
如果N<10：
总和=总和+N
#打印“N=”，N
回报金额
其他：
总和=总和+N%10
#打印“N=”，N，“sum=”，sum
返回金额和foo（N/10，金额）
res=f（5）
打印“N=5”、“res=”和“res”
res=f（59）
打印“N=59”、“res=”和“res”
res=f（568）
打印“N=568”，“res=”，res

---

是否可以只使用f函数进行更简单的递归，即不使用“foo”函数？

您不需要每次都传递求和

def f(N):
    if N < 10:
        return N
    else:
        return N%10 + foo(N/10)

def（N）：
如果N<10：
返回N
其他：
返回N%10+foo（N/10）

添加你喜欢的照片。这将构建表达式，并在到达底部后将它们添加到一起

---

注*如果N为负，则该值将中断。您可以在开始处添加一个简单的检查，并使用否定执行类似的操作。

您当前拥有的递归形式（通过递归调用传递当前和）是一种特殊的递归形式，称为。尾部递归调用通常使用帮助函数来启动它们。由于没有对递归调用的结果执行任何实际操作，因此它可以立即返回，而无需分配更多的堆栈空间。有些编译器对尾部递归代码进行优化，所以我个人更喜欢您现有的代码

当然，您可以通过结合递归调用返回当前结果，将函数重新写入单个递归函数

def foo(N):
    if N < 10:
        return sum
    else:
        return sum%10 + foo(N/10) 

def foo（N）：
如果N<10：
回报金额
其他：
返回金额%10+foo（N/10）

---

这种递归形式的缺点是可能会耗尽堆栈空间。在这种情况下，每个递归调用取决于所有后续调用的结果，因此原始函数调用的本地内存在等待其递归（以及该调用的递归）返回时可能会膨胀

python确实不是一种好的递归语言（循环更好），但出于教育目的，您可以执行以下操作

def foo(N, sum1=0):
    if N < 10:
        sum1 = sum1 + N
        return sum1
    else:
        sum = sum1 + N%10
        return foo(N/10,sum1)

foo(10) 
=> 1

这将数字转换为字符串，将字符改回整数，然后求和。它跳过了所有令人讨厌的划分

foo = lambda n: sum(map(int,str(n)))

foo(10)
=>1