How to find the factorial of a number in Python

The factorial operation multiplies a number by all positive integers below it, making it essential for calculations in probability, permutations, and mathematical sequences. Python provides multiple approaches to compute factorials efficiently.

This guide covers practical factorial implementations with tips and real-world examples. The code samples were developed with Claude, an AI assistant built by Anthropic, to ensure clarity and best practices.

Basic iterative approach with a loop

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

print(factorial(5))

120

The factorial function implements a straightforward iterative approach that multiplies numbers sequentially. This method offers several advantages for factorial calculation:

• Memory efficiency since it only stores a single running product
• Predictable performance with linear time complexity
• Simple debugging due to its step-by-step nature

The function uses a for loop to iterate through numbers from 1 to n, maintaining a running product in the result variable. Each iteration multiplies the current number with the accumulated result. This approach mirrors the mathematical definition of factorial while remaining computationally efficient.

Standard factorial methods

Python's standard library provides more elegant factorial implementations that improve upon the basic loop approach through built-in functions and functional programming patterns.

Using the built-in math.factorial() function

import math

print(math.factorial(5))
print(math.factorial(10))

120
3628800

The math.factorial() function provides a clean, optimized implementation that outperforms manual loops. Python's standard library maintains this function in C, making it significantly faster than Python-based implementations.

• Accepts a non-negative integer as input and returns its factorial
• Handles edge cases automatically, including raising appropriate exceptions for invalid inputs
• Optimizes memory usage through efficient algorithms

The example demonstrates calculating factorials for 5 and 10, producing results of 120 and 3,628,800 respectively. This built-in function eliminates the need to write custom factorial logic while ensuring reliable performance at scale.

Implementing factorial with recursion

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

print(factorial_recursive(5))

120

The recursive approach breaks down factorial calculation into smaller subproblems. The factorial_recursive function calls itself with progressively smaller values until it reaches the base case of 0 or 1.

• Each recursive call multiplies n with the factorial of n - 1
• The base case (n == 0 or n == 1) stops the recursion and returns 1
• For factorial_recursive(5), the function creates a chain: 5 × 4 × 3 × 2 × 1

While recursion offers an elegant mathematical solution that mirrors the factorial definition, it consumes more memory than iteration. Each recursive call adds a new frame to the call stack until the base case resolves.

Using functools.reduce() for factorial calculation

from functools import reduce
import operator

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

print(factorial_reduce(6))

720

The reduce() function from functools offers a functional programming approach to factorial calculation. It progressively applies multiplication to a sequence of numbers, combining them into a single result.

• The operator.mul function handles multiplication between two numbers. reduce() uses this to multiply each number in the sequence.
• The range(1, n + 1) creates a sequence from 1 to n.
• The final argument 1 serves as the initial value. This ensures proper calculation even for edge cases.

This implementation combines elegance with efficiency. It transforms the iterative process into a streamlined functional operation that processes the sequence in a single pass.

Advanced factorial techniques

Building on these standard approaches, Python enables even more sophisticated factorial implementations through techniques like memoization, sequence generation, and concise lambda expressions.

Optimizing with memoization

factorial_cache = {}

def factorial_memo(n):
    if n in factorial_cache:
        return factorial_cache[n]
    if n == 0 or n == 1:
        return 1
    factorial_cache[n] = n * factorial_memo(n - 1)
    return factorial_cache[n]

print(factorial_memo(7))

5040

Memoization dramatically speeds up factorial calculations by storing previously computed results in the factorial_cache dictionary. When the function encounters a number it has already calculated, it retrieves the cached result instead of recalculating it.

• The function first checks if the result exists in factorial_cache
• For new calculations, it stores each result before returning it
• This optimization particularly benefits recursive calls by eliminating redundant calculations

The factorial_memo function combines the elegance of recursion with the efficiency of caching. Each factorial value gets computed exactly once. This approach significantly reduces processing time for repeated calculations while maintaining the clarity of recursive implementation.

Creating a factorial sequence generator

def factorial_generator(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
        yield result

for i, fact in enumerate(factorial_generator(5), 1):
    print(f"{i}! = {fact}")

1! = 1
2! = 2
3! = 6
4! = 24
5! = 120

The factorial_generator function creates a sequence of factorial numbers using Python's generator functionality. Instead of calculating all factorials at once, it yields each result as soon as it's computed. This approach conserves memory and enables efficient iteration through factorial sequences.

• The yield statement pauses execution after each factorial calculation, making the function memory-efficient for large sequences
• Using enumerate with a start value of 1 pairs each factorial with its corresponding index number
• The f-string formatting creates readable output by displaying both the number and its factorial value

This generator pattern proves particularly useful when you need to process factorials one at a time or work with large sequences without storing all results in memory simultaneously.

Implementing factorial as a lambda function

factorial_lambda = lambda n: 1 if n <= 1 else n * factorial_lambda(n - 1)

print(factorial_lambda(4))
print(factorial_lambda(8))

24
40320

The factorial_lambda function demonstrates Python's concise lambda syntax for recursive factorial calculation. This one-line approach packs the same recursive logic we saw earlier into a more compact form.

• The if n <= 1 condition serves as the base case, returning 1 when reached
• For values above 1, the function multiplies n with the factorial of n - 1 through recursion
• While elegant, this implementation trades readability and debugging ease for brevity

The example shows calculations for 4 and 8, producing 24 and 40,320 respectively. Lambda functions work well for simple recursive operations but consider using standard functions for more complex factorial implementations that require error handling or optimization.

Using factorial() to calculate combinations for lottery odds

The factorial() function enables precise calculation of lottery odds by determining the total possible combinations when selecting numbers from a fixed set.

def combinations(n, r):
    return factorial(n) // (factorial(r) * factorial(n - r))

# Calculate the odds of winning a lottery (choosing 6 numbers from 49)
lottery_odds = combinations(49, 6)
print(f"Odds of winning the lottery (6 from 49): 1 in {lottery_odds}")

The combinations() function calculates how many different ways you can select r items from a total of n items, where order doesn't matter. It implements the mathematical combinations formula using factorials.

• The double forward slash operator (//) performs integer division
• The function divides n! by the product of r! and (n-r)! to eliminate counting duplicate selections

In the lottery example, the function determines all possible ways to pick 6 numbers from a pool of 49. This calculation reveals the exact probability of winning by showing how many different ticket combinations exist.

Approximating e^x using Taylor series with factorials

The factorial() function enables precise approximation of exponential values through Taylor series expansion, where we sum the powers of x divided by their factorials to estimate e^x with increasing accuracy.

def exp_approximation(x, terms=10):
    result = 0
    for n in range(terms):
        result += x**n / factorial(n)
    return result

# Compare our approximation with math.exp
import math
x = 2
print(f"Our approximation: {exp_approximation(x)}")
print(f"Math.exp result: {math.exp(x)}")

The exp_approximation function calculates e^x using a mathematical technique called power series expansion. It breaks down the complex exponential calculation into a sum of simpler terms.

• Each term divides x raised to a power by the factorial of that power
• The terms parameter controls accuracy. More terms yield better approximations
• The function compares its result with Python's built-in math.exp to verify accuracy

This implementation demonstrates how complex mathematical functions can be approximated through simple arithmetic operations. The default value of 10 terms usually provides sufficient accuracy for most practical applications.

Common errors and challenges

Implementing factorial functions requires careful handling of edge cases, memory constraints, and recursion limits to prevent common runtime errors and performance issues.

Handling negative inputs in factorial() functions

The factorial() function requires special attention when handling negative numbers. Most implementations silently return incorrect results instead of raising appropriate errors. The code below demonstrates this common pitfall where negative inputs produce mathematically invalid outputs.

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

# This will create an empty range and return 1, which is incorrect
print(factorial(-5))

The factorial() function silently accepts negative numbers and returns 1 because range(1, n + 1) creates an empty sequence when n is negative. The loop never executes. Let's examine a proper implementation that validates inputs.

def factorial(n):
    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

try:
    print(factorial(-5))
except ValueError as e:
    print(f"Error: {e}")

The improved factorial() function adds input validation to catch negative numbers before calculation begins. It raises a ValueError with a descriptive message instead of silently returning incorrect results.

• Always validate inputs at the start of mathematical functions
• Use try-except blocks to handle errors gracefully in production code
• Watch for silent failures when working with mathematical functions. They often return misleading results instead of errors

This pattern applies beyond factorials. Many mathematical operations have domain restrictions that require explicit validation to prevent subtle bugs in your applications.

Avoiding stack overflow in recursive factorial() implementation

Recursive factorial functions can hit Python's recursion limit when calculating large numbers. The factorial_recursive() function creates a new stack frame for each recursive call. This quickly exhausts available memory when processing inputs like 1000.

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

# This will cause a RecursionError for large inputs
print(factorial_recursive(1000))

Each recursive call to factorial_recursive() adds a frame to Python's call stack. When calculating large factorials, these frames accumulate rapidly until they exceed Python's built-in recursion limit. The following code demonstrates a more efficient approach.

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

# Using iteration instead of recursion for large numbers
print(factorial_iterative(1000))

The factorial_iterative() function solves the stack overflow problem by using a simple loop instead of recursion. This approach maintains a single running product in memory rather than creating multiple stack frames.

• Iterative solutions scale better for large numbers since they use constant memory
• Watch for recursion limits when processing inputs above 1000
• Consider using iteration whenever deep recursion might occur

The iterative method trades elegant recursive code for practical reliability. While both approaches work for small numbers, iteration prevents memory issues that could crash your program when handling larger calculations.

Preventing memory leaks in memoized factorial() functions

The factorial_memo() function caches results to speed up calculations. However, storing every factorial value in memory can quickly consume available RAM when processing large sequences. The code below demonstrates how the cache grows unbounded with each new calculation.

factorial_cache = {}

def factorial_memo(n):
    if n in factorial_cache:
        return factorial_cache[n]
    if n == 0 or n == 1:
        return 1
    factorial_cache[n] = n * factorial_memo(n - 1)
    return factorial_cache[n]

for i in range(1000):
    factorial_memo(i)

The factorial_cache dictionary accumulates every calculated value without any cleanup mechanism. Processing 1000 numbers fills memory with unnecessary cached results. The code below implements a more efficient caching strategy.

from functools import lru_cache

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

for i in range(1000):
    factorial_memo(i)

The @lru_cache decorator from Python's functools module provides an elegant solution to memory management in recursive functions. It automatically maintains a fixed-size cache of the most recently used results instead of storing every calculation.

• The maxsize parameter limits cache entries to prevent unbounded memory growth
• Least recently used results get discarded when the cache reaches capacity
• The decorator handles all caching logic automatically without manual dictionary management

Monitor memory usage when caching recursive calculations. Large input sequences or parallel processing can still strain resources even with lru_cache. Consider adjusting the cache size based on your application's memory constraints and performance requirements.