In this article we discuss recursion in Python programming. Recursion is a fundamental concept in Computer Science, and regardless of what your development goals are, it is good to have an understanding of at least the basics.
Topics covered:
- The basic concept of recursion
- What is a base case?
- Some examples of recursive algorithms
- Visualizing recursion
In terms of day-to-day development, the amount you use recursion will vary by context. Some developers may make little or no explicit use of it while for others it will be a mainstay. Regardless, recursion is part of the very fabric of computing, and even if you don’t use it explicitly in your everyday work, you can bet it’s happening a whole lot behind the scenes.
Here are some examples of where recursion is used in computing:
- traversing DOM elements
- processing recursively defined data such as that stored in trees
- command shells
- compilers and linkers
- evaluation of arithmetic expressions
- database systems
Recursion is so important and useful that almost all modern programming languages support it.
So what is recursion?
It’s probably best to look at an example first and then break it down to explain what is happening.
An Example of a Recursive Algorithm in Python
Type this code into a new Python file.
def countdown(n):
if n <= 0:
print("LIFTOFF!")
else:
print(n)
countdown(n - 1)
countdown(10)
Before you run it, have a think about what the output of this program might be. You can click below to see the solution.
What is going on here? Even though it’s a simple program, it contains the fundamental ingredients of recursion:
Base case
A base case is essential with recursion. Without it there is no way for the algorithm to “know” when to stop. Not having one is like having a while True loop – i.e. you get an infinite loop, except with recursion you will eventually hit your system’s maximum recursion limit. Here the base case is when n <= 0.
Movement toward the base case
The algorithm must approach the base case on each successive call, otherwise it can not terminate. Again comparing this to a while loop, not moving towards the base case is like not moving towards the condition for the while loop to exit. Each successive call here has n - 1 as its argument so we are approaching the base case. This is good.
A recursive call
The simple yet powerful idea here is that the function definition contains a call to itself within its body. Did you notice that the function definition for countdown() contains a call to the function countdown()?
Stages of recursion
One key thing to understand about recursion is that there are two stages to a recursive algorithm. Before anything is returned from the initial function call, all the subsequent recursive function calls are made, until the base case is reached. At that point, the call stack (which contains a frame for each function call), begins to unwind, until a value for the initial function call is returned.
This is probably best illustrated visually. Look at this representation of a call to the factorial(n) function, which calculates the product of decreasing values of n and whose mathematical symbol is !. For example 5! = 5 * 4 * 3 * 2 * 1
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n-1)
print(factorial(5))
Here’s what happens before the final value of 120 is returned and printed:
|-- factorial(5)
| |-- factorial(4)
| | |-- factorial(3)
| | | |-- factorial(2)
| | | | |-- factorial(1)
| | | | | |-- return 1
| | | | |-- return 2
| | | |-- return 6
| | |-- return 24
| |-- return 120
120
>>>
factorial(5) calls factorial(4) which calls factorial(3) etc, until the base case is reached (n == 1), then each of the function calls returns its value, in the reverse order to that in which they were called, until the value for the initial call factorial(5) is returned.
We can use the same kind of diagram for our first example of a recursive algorithm, countdown(n) although is is less clear what is happening since nothing (actually None) is returned by each successive function call, as we are using print to output the value for each stage of the count.
|-- countdown(5)
5
| |-- countdown(4)
4
| | |-- countdown(3)
3
| | | |-- countdown(2)
2
| | | | |-- countdown(1)
1
| | | | | |-- countdown(0)
LIFTOFF!
| | | | | | |-- return None
| | | | | |-- return None
| | | | |-- return None
| | | |-- return None
| | |-- return None
| |-- return None
None
How to Master Recursion in Python
Learners often find recursion confusing when they first encounter it. This is completely normal. Recursion has the paradoxical quality of being both very simple and intuitive on the one hand, and seemingly confusing and complex on the other. The way to gain confidence and competence with the topic is by looking at lots of examples of recursive algorithms and, more importantly, writing them for yourself. You may also have to spend a bit of hard thinking time wrapping your head around what is happening. Having a whiteboard handy may help as you trace a particular function call and try to anticipate what happens next. Don’t be discouraged if it takes a while for your understanding of recursion to grow. It is well worth the effort!
Happy computing!
