Python 在递归函数中，如何控制函数调用的次数。即递归函数调用自身的次数

我现在有两个函数，其中一个是编写一个简单的递归函数，它将以n个步骤计算指数

第二个功能是我的主要问题，是n/2步。我对如何协商或控制由n表示的递归调用的数量感到困惑

这是一个作业问题，我不允许使用任何类型的循环，而“for”和“for”是不允许的，只要是，所以请对我放松，因为我知道它看起来很简单

def simple_recursive_power(x, n):
    print("n="+str(n))
    if n ==1:
        return x
    else:
        return x* simple_recursive_power(x,n-1)

print("the simple recurse method="+ str(simple_recursive_power(3,3)))

""the above works, the one below is working the wrong way""

def advanced_recursive_power(x, n):
    print("n="+str(n))
    if n <= 1:
        return x

    else:
        return x * advanced_recursive_power(x, n-1/2)


print("advanced recursion="+ str(advanced_recursive_power(3,3)))

def简单递归功率（x，n）：
打印（“n=”+str（n））
如果n==1：
返回x
其他：
返回x*简单递归幂（x，n-1）
打印（“简单递归方法=“+str（简单递归幂（3,3）））
“”上面的方法有效，下面的方法无效“”
def高级递归功率（x，n）：
打印（“n=”+str（n））
如果n占据一半周期的更好的指数函数不仅需要调整n，还需要更好的算法

简单的指数是这样工作的：分N步，每一步乘以X

如果要将步骤数减半，需要注意的关键细节是，如果乘以X*X，则一次要执行两个步骤

现在，这减少了函数调用的数量，但没有减少乘法的数量：例如，当N=7时，我们从
X*X*X*X*X*X
到
X*（X*X）*（X*X）
。如果我们可以预先计算X*X，我们实际上也可以减少乘法。。。这将计算
（X2=X*X）；X*X2*X2*X2
，有四个乘法，而不是七个：

def super_advanced_recursive_power(x, n):
    print("n="+str(n))
    if n % 2 == 0:
        start = 1
    else:
        start = x
    return start * simple_recursive_power(x * x, n // 2)

如果您传递电源，则可以大幅减少步数：

def arp(x, n):
    """Advanced recursive power equivalent to x ** n"""
    print('#', x, n)
    if n == 0:
        return 1
    elif n == 1:
        return x
    elif n % 2:  # odd exponential
        return x * arp(x * x, (n - 1) // 2)
    else:  # even exponential
        return arp(x * x, n // 2)

这只需要O（logn）个步骤

>>> arp(3, 15)
# 3 15
# 9 7
# 81 3
# 6561 1
14348907


这相当于将加法表示为一系列递减和递增：

def recursive_add(x, y):
    if y == 0:
       return x
    return (x + 1, y - 1)

这使用
x+y==（x+1）+（y-1）
。类似地，对于幂，关系
x**n==（x*x）**（n/2）
成立。虽然加法（线性）很慢，但幂（指数）很快

这个漏洞甚至可以重复使用术语。例如，
2**8
可以写成
（（2*2）*（2*2））*（（2*2）*（2*2））
——请注意术语
2*2
和
（2*2）*（2*2）
是如何重复的。我们可以将
2**8
重写为
（（2**2）**2）**2
）。这正是偶数指数的最后一项递归所做的

对于奇数指数，我们有一个问题，比如说，从
2**3
到
4**1.5
。因此，我们使用
x**n==x*（x**（n-1））
从奇数指数变为偶数指数。由于我们排除了
n==1
的情况，我们知道
n>=3
，因此直接进行
x*x，（n-1）//2
是安全的

净效果是n在每一步上减半，而不是一次。
n-1/2
并不能完成您希望它做的事情。请看。占一半周期的更好的指数函数不仅需要调整N，还需要更好的算法。你的第二个函数是N*2步，而不是N/2步。我试过了，N-（1/2），为了得到正确的结果，但它仍然会在N
N-（1/2）的特定值之后打印出荒谬的答案
相当于
n-1/2
。阅读链接。基本上，为了将步骤减半，我输入了前2个步骤，从而减少了可见步骤的数量？问题是，我需要减少n/2个步骤。但我很好奇你怎么能把递归减少这么多。你如何计算它们呢？我已经解释了它是如何工作的。希望能有帮助。
def recursive_add(x, y):
    if y == 0:
       return x
    return (x + 1, y - 1)