# Factorial of a Number in Python Using Recursion

(Last Updated On: 26/09/2023)

Recursion may be a powerful programming procedure that includes a work calling itself. It could be a valuable device for tackling issues that can be broken down into littler, easier subproblems. In this Python exercise, we’ll learn how to calculate the factorial of a number in Python using a recursive method.

## Python Program to Print Factorial of a Number Using Recursion

```# recursive function to calculate number factorial
def getFact(n):
return n if (n==1) else n * getFact(n - 1);

num = 5

# print output
print("Factorial of",num,"is",getFact(num))
```

To calculate the factorial of a number in Python using recursion, follow these steps:

1. Define a function to calculate the factorial of a number.

`def getFact(n):`

The first step of the code is to define a function named “getFact” that takes an integer argument “n”. This function will be used to calculate the factorial of the input number.

2. Use an if-else statement to define the base case.

`return n if (n==1) else n * getFact(n - 1);`

The next step is to use an if-else statement to define the base case of the recursive function. In this case, the base case is when “n” equals 1. If the input value is 1, the function returns 1. If the input value is not 1, the function calls itself recursively with “n-1” as the argument.

3. Define the recursive case.

```n * getFact(n - 1)
```

The recursive case is defined as the function calling itself with a smaller input value. In this case, the function multiplies the input value “n” by the result of calling the “getFact” function with “n-1” as the argument.

4. Call the function with the input value.

```num = 5

print("Factorial of",num,"is",getFact(num))
```

The final step is to call the “getFact” function with the input value “num”, which is set to 5 in this example. The function then calculates the factorial of 5 using recursion and returns the result, which is printed to the console using the print() function.

#### Output:

``````Enter any number: 5
Factorial is 120``````

The above program uses a recursive function in Python to calculate the factorial of a number. Here, ‘n’ is the number whose factorial we want to calculate. The function ‘getFact’ takes the variable ‘n’ and checks if its value is 1 or not. If it is, then it returns 1, else it calls the same function again with ‘n-1’ as the variable value and multiplies it with ‘n’. This continues until the value of ‘n’ becomes 1.

Here, we insert 5 as the value of ‘n’ and calculate its factorial with the help of the getFact function. The print statement displays the final output as: ‘Factorial of 5 is 120’.

#### Here are three applications of calculating the factorial of a number using recursion:

Combinatorics:

In combinatorics, factorial work is used to calculate the number of ways a set of objects can be orchestrated or chosen. For example, the number of stages of n objects is n!, and the number of combinations of n objects taken k at a time is n! / (k! * (n-k)!). Recursion can be utilized to calculate these values proficiently.

Likelihood hypothesis:

In the likelihood hypothesis, the factorial work is used to calculate the number of conceivable results in an try. For illustration, in case there are n conceivable results and k results are chosen, the number of conceivable combinations is n! / (k! * (n-k)!). Recursion can be utilized to calculate these values for huge input values.

Cryptography:

In cryptography, factorials are used within the calculation of key lengths for encryption calculations. For case, the length of a key for the RSA calculation is regularly a large prime number that’s the item of two other huge prime numbers. The length of the key is frequently communicated in terms of the number of bits it contains, which is calculated utilizing factorial work.

In general, calculating the factorial of a number using recursion has numerous applications in different areas, including counting combinatorics, likelihood hypothesis, and cryptography. Recursion may be a capable programming method that can be utilized to fathom complex issues proficiently and richly.

### Why do we use the recursion function for the Factorial of a Number

Some of the other methods to calculate factorials are While Loop, Math or Numpy library, Lambda function, or reduce function. The recursion function offers a more concise and elegant solution as we can define a single function that calls itself, thus, reducing the need for repetitive code and making it easier to read and implement.

Recursion is also useful for solving complex mathematical problems as it provides a way to break them down into smaller manageable subproblems.

In the above program, we broke down the factorial into a series of smaller calculations, each of which is similar to the original problem but with a smaller input value.

However, this method can sometimes lead to stack overflow errors if the recursion depth becomes too large. In that case, we should use an alternate approach or a different algorithm.

In this exercise, we learned how to calculate the factorial of a number in Python using recursion. We clarified each step of the code in detail, making it simple for apprentices to get it. Recursion could be an effective programming method that’s valuable for understanding numerous issues, and Python gives a straightforward and natural way to implement it. We hope this Python exercise was helpful, in which you’re presently able to calculate the factorial of any number using Python recursion.

### FAQs about Factorial of a Number using Recursion

What happens if the input value is not an integer?

If you insert a non-integral value, the program will result in a TypeError.

What will happen if I insert the value of n as zero?

The program will generate the output as 1 for input values of zero, as the factorial of 0 is defined as 1.

What will happen if I input a decimal or fractional number?

The program will result in an error as you can only calculate factorial for positive integers.

What is the maximum value of n this program accepts?

The maximum value of n is limited by the recursion depth of Python. If it exceeds the maximum allowed value, a recursion error will be displayed.