# What Is Recursion and How Do You Use It?

## What is a Recursive Function?

A recursive capacity is a capacity that calls itself. You basically make a circle with a capacity. As you can envision, these can be interesting capacities to compose. You don’t need your code to run until the end of time.

Like a circle, a recursive capacity will be constrained by a condition. When the condition is met, the capacity quits calling itself, which stops the circle. This is the means by which you can make a capacity that calls itself without it running until the end of time.

Despite the fact that a recursive capacity acts like a circle, it is executed by the PC in an unexpected way. Thus, a few calculations are more proficient in a circle and others profit by a recursive capacity. However, before we see how to utilize a recursive capacity, you need to realize how to think of one.

## How to Write a Recursive Function

All recursive functions have the same basic structure:

```
FUNCTION name
IF condition THEN
RETURN result
ELSE
CALL FUNCTION name
END FUNCTION
```

The above model is written in pseudo-code. It plots the structure of the capacity, which can be applied to any language. For straightforwardness, in this article, we will focus on Python.

The primary thing to note about a recursive capacity is that when the condition is met, the capacity leaves the recursion. This implies when you compose a recursive capacity, the primary thing you will need to decide is when to stop the recursion.

On the off chance that the condition isn’t met, the capacity will call itself. Thus, on the off chance that you need to send data to the following circle, you should send it as a contention in your capacity. This can give recursive capacities significantly more force.

### Recursive Function Example in Python

It will be much easier to understand how recursion works when you see it in action. To demonstrate it, let’s write a recursive function that returns the factorial of a number.

Factorials return the product of a number and of all the integers before it. For example, the factorial of 5 is 5 x 4 x 3 x 2 x 1 or, 120.

```
def factorialFunction(numberToMultiply):
if numberToMultiply == 1 :
return 1
else :
return numberToMultiply * factorialFunction(numberToMultiply - 1)
result = factorialFunction(3)
print(result)
//Outputs: 6
```

The above program will give you the result 6, which is the factorial of the number 3. This can be a little confusing at first. It will help if we run through the program step-by-step.

- When the function is called,
**numberToMultiply**equals 3. - The condition is not met, so we go into the
**else**condition. - Our function returns 3 * but is then paused. It must call itself to determine the rest of the value it is returning.
- When the function is called this time, the value of numberToMultiply equals 2.
- The condition is not met, so we go into the else condition.
- Our function returns 2 * but is then paused. It must call itself to determine the rest of the value it is returning.
- The function is called yet again. This time, the value of numberToMultiply equals 1.
- Our
**if**condition is met. The function returns 1. - The function from step 6 can now return 2 * 1 to the function on step 3.
- The function on step three can now return 3 * 2 * 1, which is 6.

### What's your reaction?

Excited

4
Happy

5
In Love

2
Not Sure

2
Silly

3