Factorial Function in Python

Exploring different approaches to calculating the factorial of a number is a great way to develop your algorithmic thinking skills.

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 is defined as: n! = n * (n-1) * (n-2) * … * 2 * 1. For n = 0, the factorial is defined as: 0! = 1.

TL;DR

For ease and efficiency, you should probably use the built-in math library:

>>> import math
>>> math.factorial(10)
3628800

Algorithmic Thinking Course on LinkedIn Learning

Check out my Algorithmic Thinking Course on LinkedIn Learning and join over 38,000 other learners on this fascinating learning journey!

Some Approaches to Calculating Factorials with Python

We’ll start by focus on non-recursive methods that do not rely on any external packages. Here are a few efficient ways to calculate factorials in Python using basic language features.

Iterative Method

This is a straightforward and efficient way to calculate factorials using a loop.

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

# Example usage:
print(factorial_iterative(5))  # Output: 120

Using Reduce

The reduce function from the functools module can be used to apply a function cumulatively to the items of a sequence.

from functools import reduce

def factorial_reduce(n):
    return reduce(lambda x, y: x * y, range(1, n + 1), 1)

# Example usage:
print(factorial_reduce(5))  # Output: 120

Using a Generator

Using a generator can make the code much more memory-efficient.

def factorial_generator(n):
    def generator():
        result = 1
        for i in range(1, n + 1):
            result *= i
            yield result
    return list(generator())[-1]

# Example usage:
print(factorial_generator(5))  # Output: 120

Using a While Loop

A while loop can also be used for the factorial calculation.

def factorial_while(n):
    result = 1
    while n > 1:
        result *= n
        n -= 1
    return result

# Example usage:
print(factorial_while(5))  # Output: 120

Using List Comprehension

List comprehension is usually used for creating lists, but here we can use it for calculating the factorial in a single line.

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

# Example usage:
print(factorial_list_comprehension(5))  # Output: 120

Recursive Method

The recursive method is straightforward but not the most efficient due to the overhead of recursive calls.

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

# Example usage:
print(factorial_recursive(5))  # Output: 120

Using math.factorial

Python’s standard library provides a highly optimized factorial function.

import math

# Example usage:
print(math.factorial(5))  # Output: 120

Using Memoization

Memoization stores the results of expensive function calls and reuses them when the same inputs occur again, thus reducing the number of calculations.

from functools import lru_cache

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

# Example usage:
print(factorial_memoized(5))  # Output: 120

Using Itertools for Big Integers

For very large numbers, the iterative method with itertools can be more efficient and handle big integers gracefully.

import itertools

def factorial_itertools(n):
    return list(itertools.accumulate(range(1, n + 1), lambda x, y: x * y))[-1]

# Example usage:
print(factorial_itertools(5))  # Output: 120

Using NumPy for Vectorized Computation

NumPy can be used for efficient computation, although it might be overkill for simple factorials.

import numpy as np

def factorial_numpy(n):
    return np.prod(np.arange(1, n + 1))

# Example usage:
print(factorial_numpy(5))  # Output: 120

Summary

This article has explored various methods for finding factorials with Python. They are of varying degrees of efficiency. If you just want a quick solution, use math.factorial(). However, if you want to develop your algorithmic thinking skill and Python knowledge, have a go at some of the other approaches. I recommend reading the description then trying for yourself, rather than just copying the solution.

Compucademy