Introduction

The factorial of a non-negative integer is one of the basic building blocks of combinatorics and algorithm analysis. If the question is how to compute it, the answer is straightforward; if the question is whether factorial has a simple closed form, the answer is more subtle and leads to the gamma function and Stirling’s approximation.

What Factorial Means

For a non-negative integer n, the factorial n! is the product of all positive integers from 1 through n.

Examples:

• '0! = 1'
• '1! = 1'
• '5! = 5 * 4 * 3 * 2 * 1 = 120'

The definition is recursive as well:

• '0! = 1'
• 'n! = n * (n - 1)! for positive integers'

That recurrence is often the easiest way to reason about factorials mathematically.

Compute Factorial Iteratively

In programming, an iterative loop is a clear and efficient way to compute factorial for ordinary integer sizes.

1def factorial(n):
2    if n < 0:
3        raise ValueError("factorial is undefined for negative integers")
4
5    result = 1
6    for value in range(2, n + 1):
7        result *= value
8    return result
9
10
11print(factorial(5))

This runs in O(n) time and uses constant extra space.

Compute Factorial Recursively

The recursive form matches the mathematical definition directly:

1def factorial_recursive(n):
2    if n < 0:
3        raise ValueError("factorial is undefined for negative integers")
4    if n == 0:
5        return 1
6    return n * factorial_recursive(n - 1)
7
8
9print(factorial_recursive(5))

This is elegant, but recursion is usually less practical for large n because of call-stack overhead.

Use the Standard Library When Available

In Python, the best practical choice is often the built-in implementation:

import math

print(math.factorial(5))

Library implementations are well-tested and handle large integers correctly.

Is There a Closed Form?

For integer factorials, there is no simpler elementary closed form that replaces the product definition in a useful exact way. The standard exact expression is still the product or the recurrence.

What does exist is the gamma function, which extends factorial to non-integer values:

import math

print(math.gamma(6))

gamma(n + 1) equals n! for positive integers n. So while gamma is not a simpler exact formula for integer computation, it is the natural analytic extension of factorial.

Approximate Large Factorials

For large n, factorial grows extremely quickly. When you need an estimate rather than the exact integer, Stirling’s approximation is useful:

1import math
2
3def stirling(n):
4    return math.sqrt(2 * math.pi * n) * (n / math.e) ** n
5
6print(stirling(10))
7print(math.factorial(10))

The approximation is not exact, but it becomes increasingly accurate as n grows.

This is especially useful in probability, asymptotic analysis, and reasoning about the size of combinatorial expressions.

Common Pitfalls

The most common mistake is forgetting that factorial is defined only for non-negative integers in the basic discrete sense. Negative integers do not have factorial values under the usual definition.

Another issue is using recursion for large values without thinking about recursion depth or performance. The recursive definition is mathematically elegant but not always the best implementation choice.

People also underestimate how quickly factorial grows. Even moderate values can produce enormous integers, so use big-integer support or logarithmic approximations when appropriate.

Finally, do not confuse gamma with a simpler exact “closed form” for integer factorial. It is an extension of the concept, not a shortcut that makes large exact factorials cheap.

Summary

• Factorial multiplies all positive integers from 1 to n.
• The exact definition is usually the product formula or the recurrence n! = n * (n - 1)!.
• Iterative code is usually the most practical way to compute factorial exactly.
• 'math.factorial is the preferred Python implementation for exact results.'
• The gamma function extends factorial, and Stirling’s approximation estimates large values.