Fibonacci Series in Python Using Recursion

In this tutorial, we will understand how to display a Fibonacci Series in Python Using the Recursion method. The Fibonacci series is a sequence of numbers where each number is the sum of the two preceding ones, starting from 0 and 1. 

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. 

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 using recursion in Python and compare it with other methods for generating the Fibonacci series.

Python Program to Print the Fibonacci Series Using Recursion

# 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

In this Python program, we print the Fibonacci sequence 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