Find Factorial of a Number in Python

The factorial of a number is one of the foundational concepts in mathematics and programming. Written as n!, it represents the product of every positive integer from 1 up to n. Python gives you several clean ways to calculate it, from a single built-in function call to writing your own loops and recursive functions.

Factorials appear everywhere in mathematics, from permutations and combinations to probability theory and calculus. In programming, calculating the factorial of a number is a common exercise that demonstrates fundamental concepts like iteration, recursion, and the use of standard library functions. This article walks through every practical approach Python offers for computing factorials, complete with code you can run immediately.

What Is a Factorial?

The factorial of a non-negative integer n is the product of all positive integers less than or equal to n. It is denoted by n! and defined as:

n! = n x (n - 1) x (n - 2) x ... x 2 x 1

For example, the factorial of 5 is calculated as 5 x 4 x 3 x 2 x 1 = 120. There is one special case to remember: the factorial of 0 is defined as 1. This is not arbitrary. It serves as the base case in many mathematical formulas, and it ensures that expressions involving combinations and permutations remain consistent when selecting zero items from a set.

Here are the first several factorial values for reference:

0! = 1
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720
7! = 5040
8! = 40320
9! = 362880
10! = 3628800

Notice how quickly the values grow. Factorial growth is faster than exponential growth, which is why large factorials can produce extremely large numbers. Python handles this well because it supports arbitrarily large integers natively.

Using math.factorial()

The simplest and fastest way to compute a factorial in Python is with the built-in math.factorial() function from the standard library. It is implemented in C under the hood, making it significantly faster than anything you would write in pure Python.

import math

number = 6
result = math.factorial(number)
print(f"The factorial of {number} is {result}")

Output:

The factorial of 6 is 720

The function accepts a single argument that must be a non-negative integer. Passing a negative number raises a ValueError, and passing a float raises a TypeError. This strict behavior protects you from silent errors in your calculations.

Using a For Loop

Writing a factorial function with a for loop is the clearest way to understand what the operation actually does. You start with a result of 1 and multiply it by each integer from 1 up to n.

def factorial_loop(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

number = 7
print(f"The factorial of {number} is {factorial_loop(number)}")

Output:

The factorial of 7 is 5040

This approach is iterative, meaning it uses a fixed amount of memory regardless of how large n gets. The loop runs exactly n times, giving it a time complexity of O(n). It also naturally handles the edge case where n is 0, because range(1, 1) produces an empty sequence and the result stays at 1.

Adding Input Validation

A more robust version includes checks to reject invalid input before the calculation begins:

def factorial_safe(n):
    if not isinstance(n, int):
        raise TypeError("Factorial requires an integer argument")
    if n < 0:
        raise ValueError("Factorial is not defined for negative numbers")
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

# Valid input
print(factorial_safe(5))   # 120

# Invalid inputs will raise errors:
# factorial_safe(-3)       # ValueError
# factorial_safe(4.5)      # TypeError

Raising specific exceptions rather than returning error strings makes your function behave consistently with Python conventions. Code that calls your function can then use standard try/except blocks to handle problems gracefully.

Using Recursion

Recursion is a technique where a function calls itself to solve smaller instances of the same problem. Factorials map naturally to recursion because n! can be defined as n * (n - 1)!, with the base case being 0! = 1.

def factorial_recursive(n):
    if n == 0 or n == 1:
        return 1
    return n * factorial_recursive(n - 1)

number = 8
print(f"The factorial of {number} is {factorial_recursive(number)}")

Output:

The factorial of 8 is 40320

The recursive version is elegant and closely mirrors the mathematical definition. However, it comes with a significant limitation: each recursive call adds a new frame to Python's call stack. By default, Python's recursion limit is set to 1000, meaning factorial_recursive(1000) will raise a RecursionError.

Memoized Recursion with lru_cache

If you need to compute factorials of many different values during a program's execution, you can cache results to avoid redundant calculations. Python's functools.lru_cache decorator makes this straightforward:

from functools import lru_cache

@lru_cache(maxsize=None)
def factorial_memo(n):
    if n == 0 or n == 1:
        return 1
    return n * factorial_memo(n - 1)

print(factorial_memo(10))   # 3628800
print(factorial_memo(7))    # 5040 (retrieved from cache instantly)

Once factorial_memo(10) has been computed, calling factorial_memo(7) returns immediately because the result for 7 was already calculated and stored during the first call. This is especially useful when your program needs factorials repeatedly, such as in combinatorics calculations.

Using functools.reduce()

The reduce() function from the functools module applies a two-argument function cumulatively to the items of a sequence. You can use it to multiply all numbers from 1 to n together in a single expression:

from functools import reduce
import operator

def factorial_reduce(n):
    if n == 0:
        return 1
    return reduce(operator.mul, range(1, n + 1))

print(factorial_reduce(6))  # 720
print(factorial_reduce(0))  # 1

Here, operator.mul is a function that multiplies two numbers. The reduce() call starts with 1 (the first element of the range), multiplies it by 2, then multiplies that result by 3, and so on until it reaches n. You could also write this with a lambda instead of operator.mul:

from functools import reduce

result = reduce(lambda a, b: a * b, range(1, 7))
print(result)  # 720

While this is a valid approach, it is less readable than a plain for loop for many programmers. Use it when you prefer a functional programming style or when you want a concise one-liner.

Handling Edge Cases

A well-written factorial function should account for several edge cases to prevent unexpected behavior:

def factorial_complete(n):
    """Calculate factorial with full input validation."""
    if not isinstance(n, int):
        raise TypeError(f"Expected int, got {type(n).__name__}")
    if n < 0:
        raise ValueError("Factorial is not defined for negative numbers")
    if n == 0 or n == 1:
        return 1
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result

# Test all edge cases
print(factorial_complete(0))    # 1
print(factorial_complete(1))    # 1
print(factorial_complete(10))   # 3628800

The key edge cases to consider are: zero (returns 1 by mathematical definition), one (also returns 1), negative integers (should raise ValueError since factorials are undefined for negative numbers), and non-integer types like floats or strings (should raise TypeError).

Which Method Should You Use?

Each approach has its strengths depending on your situation:

• math.factorial() — Best for production code. It is the fastest option because it runs optimized C code behind the scenes. Use this whenever you simply need a factorial value and there is no reason to write your own implementation.
• For loop — Best for learning and for situations where you need custom logic inside the loop. It is easy to read, uses constant memory, and works well with large values of n.
• Recursion — Best for understanding the mathematical definition and for teaching purposes. Avoid it for large inputs due to Python's recursion limit and stack overhead.
• functools.reduce() — Best when you prefer a functional programming style. It produces compact code but can be harder to read for programmers unfamiliar with the reduce pattern.

For performance-sensitive applications, math.factorial() outperforms every pure-Python alternative. If you need repeated factorial computations across many values, combining memoization with either recursion or an iterative lookup table will give you the best results.

Key Takeaways

1. Use math.factorial() by default: It is Python's built-in solution, implemented in optimized C code, and handles all edge cases including zero and large numbers automatically.
2. Understand the iterative approach: Writing a factorial with a for loop teaches you how the operation works and gives you a foundation you can customize with input validation or logging.
3. Be cautious with recursion: While recursive factorial mirrors the mathematical definition, Python's default recursion limit of 1000 makes it unsuitable for large inputs. Use it for learning, not for production.
4. Validate your inputs: A solid factorial function checks for negative numbers, non-integer types, and zero. Raising ValueError and TypeError follows Python conventions and makes your code predictable.
5. Consider memoization for repeated calculations: If your program computes factorials for many values, caching results with @lru_cache eliminates redundant work and dramatically improves performance.

Whether you reach for math.factorial() in production or write your own version to sharpen your skills, calculating factorials in Python is a practical exercise that reinforces core programming concepts. Start with the built-in function for reliability, and explore the other methods when you want to understand what is happening under the surface.