Factorial Program in Python

Creating factorial programs in Python is one of the most asked number problems. It is mostly asked in coding interviews, math problems, university assignments and even real-world applications like probability and algorithm design. This makes it important to learn how to write a factorial program in Python for beginners and developers.

In this guide, I will walk you through everything, from what a factorial actually is to multiple ways you can write a factorial program in Python. Whether you prefer loops, recursion, or built-in functions, I have got you covered. Let's start from the basics!

Read Also: Python Data Types

What is a Factorial?

The factorial of a number is the product of all positive integers starting from 1 to that particular number. It is written using an exclamation mark after the number, like n!. Its mathematical representation is something like this:

Note: There is one special rule you need to remember. The factorial of 0 is always 1. That is just a mathematical convention and you will need to handle it in your programs too.

Factorial Examples

Let me show you a few examples so the concept is completely clear before we jump into the code.

Simple enough right? Now let us get into the actual programs.

Related Article: Python For DevOps: A Complete Guide For Beginners

Factorial Program in Python

There are several ways to write a factorial program in Python and each one teaches you something different about the language. I will go through the most used approaches one by one so you can pick the one that fits your requirements or just learn all of them.

Method 1: Factorial Program in Python Using a For Loop

This is the most straightforward approach and perfect for beginners. We just loop from 1 to n and keep multiplying.

# Factorial Program in Python using For Loop

num = int(input("Enter a number: "))

factorial = 1

if num < 0:
    print("Factorial is not defined for negative numbers.")
elif num == 0:
    print("Factorial of 0 is 1.")
else:
    for i in range(1, num + 1):
        factorial *= i
    print(f"Factorial of {num} is {factorial}.")

Output for input 5:

How it works: It starts with a factorial set to 1 and then multiplies it by every number from 1 up to the input number using a for loop. We also handle the edge cases where the input is 0 or a negative number because factorials are only defined for non-negative integers.

Method 2: Factorial Program in Python Using a While Loop

The while loop method is not any different from the for loop. It just provides more manual control over the iteration. Some interviewers specifically ask for this version so it is good to know if you are preparing for an interview.

# Factorial Program in Python using While Loop

num = int(input("Enter a number: "))

factorial = 1
i = 1

if num < 0:
    print("Factorial is not defined for negative numbers.")
elif num == 0:
    print("Factorial of 0 is 1.")
else:
    while i <= num:
        factorial *= i
        i += 1
    print(f"Factorial of {num} is {factorial}.")

Output for input 6:

The logic here is the same as the for loop. The only difference is that we manually manage the counter variable i and increment it inside the loop ourselves.

Also Read: Python Regular Expressions: Your Ultimate Guide

Method 3: Factorial Program in Python Using Recursion

Recursion is where a function calls itself to solve a smaller version of the same problem. It is one of the most popular ways to explain factorial in programming. The reason is that the mathematical definition of factorial is naturally recursive. Here is how we do it:

# Factorial Program in Python using Recursion

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

num = int(input("Enter a number: "))

if num < 0:
    print("Factorial is not defined for negative numbers.")
else:
    print(f"Factorial of {num} is {factorial(num)}.")

Output for input 4:

How it works: Every time the function is called, it multiplies n by the factorial of n-1. This keeps going until it hits the base case which is factorial(0) or factorial(1) returning 1. Then it unwinds and multiplies everything back together.

Note: Always remember that Python has a default recursion limit of 1000 calls. For very large numbers, the iterative approach is safer.

Method 4: Factorial Program in Python Using math.factorial()

Python has a built-in function for this number problem inside the math module. It is also the fastest and cleanest option when you just need the answer without writing the logic yourself.

# Factorial Program in Python using math.factorial()

import math

num = int(input("Enter a number: "))

if num < 0:
    print("Factorial is not defined for negative numbers.")
else:
    print(f"Factorial of {num} is {math.factorial(num)}.")

Output for input 7:

This is the recommended approach for any real world use case. It is optimized, handles edge cases internally and saves you from writing extra code. The interviewers generally avoid this answer as they want you to build the logic by yourself.

Method 5: Factorial Program in Python Using a Function

Writing a reusable function is good practice and something you should get comfortable with early on. This approach wraps the for loop logic inside a clean function you can call anywhere in your code. The method is also best to impress the interviewers.

# Factorial Program in Python using a Function

def factorial(n):
    if n < 0:
        return "Factorial is not defined for negative numbers."
    elif n == 0:
        return 1
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

# Test with multiple numbers
test_numbers = [0, 1, 5, 6, 10]

for num in test_numbers:
    print(f"Factorial of {num} is {factorial(num)}.")

Output:

Factorial of 0 is 1.
Factorial of 1 is 1.
Factorial of 5 is 120.
Factorial of 6 is 720.
Factorial of 10 is 3628800.

This is the cleanest approach for projects where you need to calculate factorials multiple times throughout your code.

Read Also: Exponents in Python: A Comprehensive Guide for Beginners

Method 6: Factorial Program in Python Using Dynamic Programming

Dynamic programming is a smart approach when you are dealing with large numbers. This method solves the issue of recalculating the same factorials over and over as it stores the results and reuses them. Here is a basic example.

# Factorial Program in Python using Dynamic Programming

def factorial_dp(n):
    dp = [1] * (n + 1)
    for i in range(2, n + 1):
        dp[i] = dp[i - 1] * i
    return dp[n]

num = int(input("Enter a number: "))

if num < 0:
    print("Factorial is not defined for negative numbers.")
else:
    print(f"Factorial of {num} is {factorial_dp(num)}.")

Output for input 10:

Method 7: One-Line Factorial Program in Python Using reduce()

reduce() function from the functools module can help you calculate factorial in a single line. It is one of the best approaches to impress someone with a compact Pythonic solution. Here is the code:

# One-Line Factorial Program in Python using reduce()

from functools import reduce

num = int(input("Enter a number: "))

factorial = reduce(lambda x, y: x * y, range(1, num + 1)) if num > 0 else 1
print(f"Factorial of {num} is {factorial}.")

Output for input 5:

Related Article: Introduction to CherryPy: A Python Web Framework

Which Method Should You Use?

You might now be wondering which of the above methods is the best one. Well, each method is equally important based on the requirements. Here is a quick guide to help you decide:

Wrapping Up

We have explored seven best approaches to find the factorial of a number using Python programs. These methods are straightforward, and anyone with a basic understanding of programming can learn them. They just have to understand the perfect logic for each type of program.

It is also one of the most asked number platforms in different interviews and assessment tests. This means if you are preparing to attempt any Python interview soon, you should prepare with these programs.

Read Also: Introduction to Sanic Web Framework - Python Tutorial

FAQs

Q1. How to do factorial code in Python?

There are various methods to build a factorial program in Python. You can use a basic loop that multiplies numbers sequentially, import the standard math module, call math.factorial(n) for a fast solution, or create your own function using recursion or dynamic programming.

Q2. How do factorials work in Python?

A factorial program in Python tracks a running product by multiplying a chosen integer by every positive whole number below it down to 1. Python automatically handles very large integers, so you can calculate large factorial values without worrying about integer overflow.

Q3. What is the proof of 0! = 1?

By definition, the factorial of a number satisfies the relation:

If we substitute n = 0, we get:

This definition is also consistent with the concept of the factorial as the product of all positive integers up to n. Since there are no positive integers to multiply when n = 0, the result is defined as the empty product, which equals 1 by mathematical convention.