Python Recursion Explained

def fact(n):
    if n == 1:      # This is base case
        return 1
    return n * fact(n - 1)   # This is recursive case


fact(5)

Output:

120

Explanation:

In this example, the function keeps breaking the problem into smaller pieces by calling itself with one number less each time.

It stops only when it reaches 1, and then slowly returns all the answers back in reverse order.
So fact (5) becomes 5×4×3×2×1 when everything is combined, and that gives you 120.

5. Execution Flow (Simple Explanation)

For simplicity, let us calculate it for fact(4).



Important point to remember is, the function fact() keeps shrinking the problem (at every step) until it reaches 1 (which is the base case).

6. Call Stack Trace (Simple Explanation)

Every time a function is called in Python, it creates a new “stack frame” and stores each function call on the stack.

Each frame stores three things:

•    the name of the function
•    the argument values
•    the return location

In this way, Python knows where to come back after completing the call.

Please remember two important things:

•    When a function calls itself, the stack grows.
•    When it hits the base case, the stack shrinks.

Call Stack Trace for fact(4):

def fact(n):
    if n == 1:
        return 1
    return n * fact(n - 1)

After this, call the above function, using below statement:

fact(4)

Now, we will understand how a stack grows and then unwinds:

STACK GROWING (Forward Phase)


 
When it hits the base case fact(1), then it returns 1

STACK SHRINKING (Backward Phase)


 
Visual Stack Diagram:



The above diagram clearly shows 3 important things:

•    How recursion builds the stack upward
•    How values flow downward during stack shrinking
•    Why base case fact(1) = 1 is necessary

Please note that if a base case is missed, then it can lead to infinite stack growth.

The call stack was the part I ignored earlier, but once I visualized how the stack grows and shrinks, recursion finally stopped feeling like magic and started making sense.

7. Real-World Example

a) Virus Scanning in Antivirus Software

When you click ‘Scan now’ button to scan a virus using Antivirus software, then a virus scanner checks the following things:

•    A folder
•    Inside it: it checks files + more folders
•    Inside them: it also checks subfolders
•    And inside them: it checks deeper for more files

In short, antivirus software uses recursive directory scanning to scan everything.

b) Google Maps Pathfinding (Shortest Route Search)

When you start finding a route from Point A to B, Maps performs the following steps:

•    First, it finds your route by checking big roads.
•    If no success, then it breaks the problem into smaller roads.
•    If smaller roads exist, then it breaks into even smaller ones, and this continues until Maps finds the exact path.

Please note that this step-by-step breakdown of roads into smaller roads is exactly how recursion works.

8. When Should You Use Recursion?

Recursion is used when a big problem naturally breaks down into smaller versions of itself.

Few examples:

•    File system scanning
•    Working with nested data
•    Searching and sorting algorithms (like quicksort, merge sort, and binary search)
•    Tree traversals
•    Mathematical problems (factorial, Fibonacci, permutations)

9. Why Recursion Matters

a) Cleaner Code: Using recursion, you can write fewer lines of code (compared to long loops).
b) Increases Code Readability: Honestly, well-written recursive code is always easier to understand.
c) Solves Naturally Recursive Problems Easily: There are few problems like directory scanning or tree traversal that can’t be solved without recursion.
d) Foundation for Competitive Programming & Interviews:
Recursion is required to understand Data Structures & Algorithms, and most coding interviews include at least one recursion question.

10. Common Mistakes Students Make

Based on my experience, I have seen multiple students make the following mistakes:

•    Forget to write a base case
•    Write a base case that doesn’t reduce the problem
•    Recursive function never stops - it keeps calling itself endlessly and fills up Python’s memory until the program crashes
•    Thinking recursion is advanced, but it is simply breaking a big problem into smaller ones

11. Python Recursion – Interview FAQs (Most Asked Questions)

1. What is recursion in Python?

Recursion is a technique where a function calls itself to solve a smaller part of the same problem until a stopping condition (base case) is reached.

2. What is a base case in recursion?

A base case is the condition where the recursive calls stop. Without a base case (important point), recursion will go into an infinite loop and cause a crash.

3. What happens if a recursive function has no base case?

It results in infinite recursion, eventually causing a Recursion Error in Python because the call stack overflows.

4. What is the recursion limit in Python?

Python limits recursion depth to prevent crashes.
You can check it using below written code:

import sys
print(sys.getrecursionlimit())

Default limit is around 1000 calls.

5. How is recursion different from loops?

•    Loops repeat using for or while.
•    Recursion repeats by calling the same function again.
Recursion is cleaner for tree-like or nested problems, while loops are better for simple repetitive tasks.

6. Is recursion faster than loops?

No. Loops are faster because recursion adds overhead of function calls. But recursion is preferred for certain problems because it is cleaner and clearer.

7. When should you use recursion?

You should always use recursion when the problem naturally breaks into smaller subproblems, like:
•    Tree traversal
•    Searching & sorting algorithms
•    Directory/file scanning
•    Mathematical sequences (factorial, Fibonacci)

8. Can recursion replace loops?

Yes, technically recursion can do everything loops can do.

But loops are preferred in those scenarios when:

•    Speed matters
•    Memory should be low
•    The problem is not naturally recursive

9. What is a recursive case?

It is the part of the function that makes a recursive call to solve a smaller version of the problem.

10. What is the call stack in recursion?

The call stack stores every function call until it returns. In recursion, each recursive call adds a new layer to the stack. When the base case is reached, the stack unwinds back upward.

If you still feel unsure at this point, don’t worry—every programmer takes a little time to get comfortable with recursion. Once it clicks, you will start enjoying solving these problems

12. Summary

Recursion often looks intimidating at first, but once you understand that it simply solves a big problem by breaking it into smaller ones, the entire topic becomes surprisingly easy.

In this guide, we walked through the idea step by step using clear examples, a simple flowchart, and short programs that show exactly how Python handles recursive calls. You also saw where recursion is used in real life, why developers rely on it so much, and what mistakes beginners usually make.

If you practice a few problems on your own, you’ll quickly realize that recursion is not a “hard concept” at all- it’s just a different way of thinking.

Learn more in our “Python Type Hinting" chapter.