In what scenario do you prefer recursion over a loop? Your comment made me think of code readability and maintainability. But I'm not judging. Really curious how you manage to prefer recursion over loops.
Recursion is just function calls. The only things which are in scope are those required by this iteration, accepted as arguments. The only thing I need to produce is a return value. This is a small, well-defined interface, as opposed to the self-interfering spaghetti code of a loop.
By accepting values as arguments and calling functions with different values, the problem of when and what to assign variables goes away; the language does it automatically by binding arguments.
Also, recursion (like function calls in general) allows thinking in terms of values, which are timeless and explicit in the code, rather than state, which is implicit and varies during execution.
Semi-related: http://chriswarbo.net/blog/2012-10-02-looping_in_javascript....
In my experience, I almost always prefer recursion since it allows me to work more closely with the structure of the original data that I'm interested in instead of a set of a proxy indices which I have to track separately.
Suppose you want to compute the greatest common divisor of two non-negative integers. There's a famous algorithm that goes all the way back to Euclid's Elements, which you can write iteratively like this:
def gcd(a,b):
if a<b: a,b = b,a
while b != 0:
a,b = b,a%b
return a
def gcd(a,b):
if a<b: return gcd(b,a)
if b==0: return a
return gcd(b, a%b)
It turns out that if the gcd of a,b is d then there are always integers x,y such that ax+by=d, and it's sometimes useful to compute x,y along with d. (For instance: if d=1 then you have ax=1 mod b, so this gives you an efficient way of computing reciprocals in modular arithmetic.)
Here's how that goes, iteratively and then recursively. (I notice that I've used two extra state variables for the iterative version. That's what seems like the most natural approach. I'm not sure whether there's a convenient way to use only two.)
def xgcd(a,b):
p,q,r,s = 1,0,0,1 # a = p.a0+q.b0, b = r.a0+s.b0
if a<b: a,b, p,q, r,s = b,a, r,s, p,q
while b != 0:
k = a//b
a,b, p,q, r,s = b,a-k*b, r,s, p-k*r,q-k*s
return a,p,q
def xgcd(a,b):
if a<b:
d,x,y = xgcd(b,a)
return d,y,x
if b==0: return a,1,0
k = a//b
d,x,y = xgcd(b,a-k*b) # d = x.b + y.(a-kb)
return d,y,x-k*y
[EDITED to add:] Perhaps it's useful to think of it this way. If you wanted to explain how, say, that iterative xgcd function works, you'd do it with a loop invariant; in fact, I actually wrote one, in that first comment "explaining" what p,q,r,s signify. (In real code I would be more verbose about it.) The recursive function gets the same idea across in the language itself: each iteration of the loop becomes a call to xgcd, and the loop invariant becomes the fact that the corresponding call to xgcd actually computes what it's supposed to compute.
gcd(A, B) when B == 0 -> A;
gcd(A, B) when A < B -> gcd(B, A);
gcd(A, B) -> gcd(B, A rem B).
When programming languages emerged, the "dynamic" nature of
the assignment statement did not seem to fit too well into the
"static" nature of traditional mathematics.
[Edit: zap redundant sentence.]