Home

Learning Hub

Articles

A Deep Dive Into Fibonacci Series in Python

Coined after the Italian Mathematician Leonardo of Pisa, the Fibonacci sequence is popularly known as Fibonacci, among the most famous mathematical concepts. Oddly enough, its beauty lies in its intelligibility and its elegance appearances in multiple scientific domains. 

In this write-up, we will shed some light on the Fibonacci series and explore multiple Pythonic implementations to understand its nuances.

Comprehension of Fibonacci Series in Python

A Fibonacci sequence is a series of numbers where every number is the total of the two preceding ones, which radically begins with 0 and 1. It is one of the paramount concepts in mathematics and has multiple applications in varied domains like finance, computer science, art, and nature. 

For example:

The Fibonacci Sequence can be defined as:

F(n) = F(n-1) + F(n-2)

Where F(n) is the nth Fibonacci number, and F(n-1) and F(n-2) are the recent numbers. This habituation relation generates the infinite Fibonacci sequence.

Because of its easy definition yet intricate and immeasurable pattern, the Fibonacci sequence has been explored in depth for implementation in dynamic fields. 

Generating Fibonacci Series in Python

There are ample ways to write the Fibonacci series programme in Python. Below are some of the potential ways. 

Fibonacci Series in Python Using a For Loop

The easiest technique is to use a for loop in Python to compute and print each term in the Fibonacci sequence reiteratively. 

The two variables, a and b, with 0 and 1, represent the starting numbers. Then, use a for loop to recapitulate up to the number of terms needed. Here, we add the previous two terms inside the loop to cultivate the following time and print it. The loop constantly calculates each subsequent period using this logic.

n = 10

for i in range(n):

   print(a)

   a, b = b, a + b

This will print the first n terms of the Fibonacci sequence. The benefit is the straightforward logic utilising a basic for-loop construct.

Fibonacci Series in Python Using a While Loop

The straightforward way to print Fibonacci numbers is by utilising a while loop in Python. As in the For Loop, initialise two variables, a and b, with 0 and 1, showcasing the series’ commencing numbers. On the inside of the while loop, the current term is printed, and variables are updated by adding them. This continues recurrently to generate the sequence.

n = 10

while b < n:

   print(b)

   a, b = b, a+b

 The loop keeps running until the term exceeds n and prints the series of up to 10 terms. The while loop technique offers a continual way to develop the Fibonacci sequence.

Backtracking Fibonacci Generation

Backtracking provides yet another repeat approach via vivid solutions till the base case is reached. 

    if n == 0: 

        return a

    return fib(n-1, b, a+b)

print(fib(5))

Thusly, techniques such as loops, Recursion, dynamic programming, and backtracking can efficaciously produce the Fibonacci sequence in Python.

Fibonacci Series in Python Using Recursion

Recursion is the prettiest way to generate the Fibonacci series in Python. Also, it establishes a recursive function that invokes itself to determine the subsequent number in the sequence.   

   if n <= 1:

       return n

   else:

       return fib(n-1) + fib(n-2)

print(fib(7))

The fib() function calls itself repetitively to calculate the nth term by summing the (n-1)th and (n-2)th terms. This follows the mathematical definition of the Fibonacci sequence.

Recursion offers an easy and straightforward way to create the series. Nevertheless, it can be slow for more significant inputs because of repeated function calls.

Fibonacci Series in Python Using Dynamic Programming

It is possible to optimise the repetitive solution by using dynamic programming and memorisation methods. The common idea is to stock up pre-computed terms in a lookup table. Prior to adding up any term, checking is essential to ensure that it exists in the lookup table. This avoids recomputing the words and makes the algorithm quicker.

    if n in memo:

        return memo[n]

    memo[n] = fib_dynamic(n-1) + fib_dynamic(n-2)   

    return memo[n]

print(fib_dynamic(6))

To store the Fibonacci numbers, a dictionary memo is initialised. The function first checks whether the term pre-exists in a memo prior to computing it or not. This dynamic programming approach enhances efficacy.

Fibonacci Series in Python Using Caching

The Python lru_cache decorator can cache and reutilise the Fibonacci terms that have already been calculated. This also prevents redundant commutations:

@lru_cache(maxsize=1000)

def fib(n):

    if n == 0:

        return 0  

    elif n == 1:

        return 1

    else:

        return fib(n-1) + fib(n-2)

print(fib(5)) 

The @lru_cache caches the function output. Hence, any recursive arguments utilised multiple times in the cached return value improve performance.

Internship Assurance

DevOps & Cloud Engineering

Explore

Comparing Fibonacci Algorithms