Fibonacci Series in Python Using Recursion

In this blog, we will explore how to generate the Fibonacci series in Python using recursion, along with a step-by-step explanation of the code. We will also discuss the benefits and drawbacks of the Fibonacci series in python recursion and compare it with other methods for generating the Fibonacci series.

It is a popular mathematical sequence that appears frequently in nature and computer science. The Fibonacci series has numerous applications in programming, including generating random numbers, creating graphics and animations, and solving optimization problems. 

In Python, the Fibonacci series can be generated using recursion, which is a programming technique that allows a function to call itself. This method provides a simple and elegant solution to generate the Fibonacci series. 

What is Fibonacci series in Python?

In Python, the Fibonacci series is a sequence of numbers in which each number is the sum of the two preceding ones, often beginning with 0 and 1. It is described mathematically by the recurrence relation F(n) = F(n-1) + F(n-2) with F(0) = 0 and F(1) = 1.

The Fibonacci series can be created in Python using a variety of approaches such as recursion, iteration, or memoization. One frequent way is to iteratively calculate and store the Fibonacci numbers using a loop. Because of its intriguing mathematical features and self-replicating patterns, this series has applications in many domains, including mathematics, computer science, and nature, and it frequently arises in algorithms, number theory, and dynamic programming issues.

Python Program to print fibonacci series in python using recursion

Below given is the code of fibonacci series in python recursion for better understanding of concept:

# Fibonacci Series in Python Using Recursion

# Recursive function recur_fibo() is used
def recur_fibo(n):
   if n <= 1:
       return n
   else:
       return(recur_fibo(n-1) + recur_fibo(n-2))

num = 10

# check if the number of terms is valid
if num <= 0:
   print("Please enter a positive integer number")
else:
   print("Fibonacci Series:")
   
   # Use a for loop to iterate and calculate each term recursively
   for i in range(num):
       print(recur_fibo(i))

Code Logic and Explanation

• Defining a recursive function:
  • We start by defining our recursive function called recur_fibo(n), which takes a number n as input and returns the nth term of the Fibonacci sequence. 
  • If the value of ‘n’ is less than or equal to 1, it returns n since the first two terms of the Fibonacci sequence are 0 and 1.
  • Otherwise, the code returns the sum of the (n-1)th and (n-2)th terms of the Fibonacci sequence, which are calculated by recursively calling the same function.

• Initializing a variable:
  • We then initialize a variable num to 10, which represents the number of terms we want to generate in the Fibonacci sequence.

• Checking the validity of input:
  • We check if ‘num’ is less than or equal to 0.
  • If so, we print a message asking the user to enter a positive integer number.

• Generating the Fibonacci sequence:
  • If num is greater than 0, we print a message saying “Fibonacci Series:”, and use a for loop to iterate from 0 to (num-1) to generate each term of the sequence. 
  • For each iteration, we call the recur_fibo() function to calculate the current term of the sequence and print it.

• Displaying the output:
  • Once the loop completes, we have generated the desired number of terms in the Fibonacci sequence and the program ends.

Output:

Fibonacci Series:
0
1
1
2
3
5
8
13
21
34

Here’s the link to watch your YouTube video.

In this Python program, we print the fibonacci series program in python using recursion method. The recur_fibo() function is defined using recursion to calculate the nth term of the Fibonacci sequence. Now, taking ‘n’ as an input the function checks if it is less than or equal to 1. If ‘n’ is less than or equal to 1, the function returns ‘n’. Otherwise, it calculates the nth term of the sequence by adding the two previous terms together, which are recursively called using the recur_fibo() function.

The program then sets the value of ‘num’ to 10 and checks if ‘num’ is greater than 0. If ‘num’ is greater than 0, the program prints the Fibonacci sequence using a for loop to iterate through each term and recursively call the recur_fibo() function to calculate the value of each term.

Here the output of our program is: 0 1 1 2 3 5 8 13 21 34.

Why do we use the recursive function for Fibonacci Series

The recursive method is simple to implement and easy to understand, making it a good choice for small to medium-sized Fibonacci numbers. However, for larger values of n or applications that require high performance, this method may not be very efficient. To overcome this, we can use other methods like using a loop, using a generator function, and using a formula.

Loop method: In this method, a for loop is used to generate the series. This method is simple and easy to understand, but it may not be as efficient as the recursive method for larger values of n.

Generator function: This method uses a generator function to yield each term of the series. This method is memory-efficient and can be faster than the recursive method for larger values of n.

Formula method: This method is the most efficient for generating large Fibonacci numbers as it uses a formula to directly calculate the nth term of the series. But it may be more difficult to understand and implement than the recursive method.

In this program, we learned how to define a recursive function called recur_fibo() that calculates each term in the Fibonacci sequence. We then used a for loop to iterate through the sequence and print each term. This program is a great example of how recursion can be used to solve complex problems with minimal code. With a deeper understanding of recursion, you can apply this technique to other problems and algorithms in Python.

FAQs about Python Fibonacci Series Using Recursion

About The Author