How to write factorial in Python?

Writing Factorials in Python: A Comprehensive Guide

Introduction

The factorial of a non-negative integer n, denoted by n!, is the product of all positive integers less than or equal to n. It is a fundamental concept in mathematics and has numerous applications in various fields, including computer science, physics, and engineering. In this article, we will explore how to write factorials in Python, including how to calculate the factorial of a given number, handle edge cases, and implement a recursive or iterative approach.

Calculating Factorials

To calculate the factorial of a given number, we can use the following formula:

n! = n × (n-1) × (n-2) × … × 2 × 1

Here is a Python function that calculates the factorial of a given number:

def factorial(n):

    """

    Calculate the factorial of a given number.



    Args:

        n (int): The input number.



    Returns:

        int: The factorial of the input number.



    Raises:

        ValueError: If the input number is negative.

    """

    if n < 0:

        raise ValueError("Factorial is not defined for negative numbers.")

    elif n == 0 or n == 1:

        return 1

    else:

        return n * factorial(n-1)

Iterative Approach

We can also calculate the factorial of a given number using an iterative approach:

def factorial_iterative(n):

    """

    Calculate the factorial of a given number using an iterative approach.



    Args:

        n (int): The input number.



    Returns:

        int: The factorial of the input number.



    Raises:

        ValueError: If the input number is negative.

    """

    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

Recursive Approach

We can also calculate the factorial of a given number using a recursive approach:

def factorial_recursive(n):

    """

    Calculate the factorial of a given number using a recursive approach.



    Args:

        n (int): The input number.



    Returns:

        int: The factorial of the input number.



    Raises:

        ValueError: If the input number is negative.

    """

    if n < 0:

        raise ValueError("Factorial is not defined for negative numbers.")

    elif n == 0 or n == 1:

        return 1

    else:

        return n * factorial_recursive(n-1)

Handling Edge Cases

We need to handle edge cases, such as:

• Negative numbers: Factorial is not defined for negative numbers.
• Zero: Factorial of zero is defined as 1.
• One: Factorial of one is defined as 1.

Here is a Python function that handles these edge cases:

def factorial_edge_cases(n):

    """

    Handle edge cases for the factorial function.



    Args:

        n (int): The input number.



    Returns:

        int: The factorial of the input number.



    Raises:

        ValueError: If the input number is negative.

    """

    if n < 0:

        raise ValueError("Factorial is not defined for negative numbers.")

    elif n == 0 or n == 1:

        return 1

    else:

        return n * factorial_edge_cases(n-1)

Implementing a Recursive Approach with Memoization

We can also implement a recursive approach with memoization to improve performance:

def factorial_memoization(n, memo = {}):

    """

    Calculate the factorial of a given number using a recursive approach with memoization.



    Args:

        n (int): The input number.

        memo (dict): A dictionary to store the memoized results.



    Returns:

        int: The factorial of the input number.



    Raises:

        ValueError: If the input number is negative.

    """

    if n < 0:

        raise ValueError("Factorial is not defined for negative numbers.")

    elif n == 0 or n == 1:

        return 1

    elif n in memo:

        return memo[n]

    else:

        result = n * factorial_memoization(n-1, memo)

        memo[n] = result

        return result

Implementing an Iterative Approach with Memoization

We can also implement an iterative approach with memoization to improve performance:

def factorial_memoization_iterative(n, memo = {}):

    """

    Calculate the factorial of a given number using an iterative approach with memoization.



    Args:

        n (int): The input number.

        memo (dict): A dictionary to store the memoized results.



    Returns:

        int: The factorial of the input number.



    Raises:

        ValueError: If the input number is negative.

    """

    if n < 0:

        raise ValueError("Factorial is not defined for negative numbers.")

    elif n == 0 or n == 1:

        return 1

    elif n in memo:

        return memo[n]

    else:

        result = 1

        for i in range(1, n + 1):

            result *= i

        memo[n] = result

        return result

Conclusion

In this article, we have explored how to write factorials in Python, including how to calculate the factorial of a given number, handle edge cases, and implement a recursive or iterative approach. We have also discussed the importance of memoization to improve performance. By following these guidelines, you can write efficient and accurate factorials in Python.

Table of Contents

• Introduction
• Calculating Factorials
• Iterative Approach
• Recursive Approach
• Handling Edge Cases
• Implementing a Recursive Approach with Memoization
• Implementing an Iterative Approach with Memoization
• Conclusion