Skip to content
CodeMDD.io | Coding Tutorials

Effortlessly Generate Fibonacci Sequence in Python

[

A Python Guide to the Fibonacci Sequence

By Mandy Wong (Intermediate)

In this tutorial, you’ll learn how to:

  • Generate the Fibonacci sequence using a recursive algorithm
  • Optimize the recursive Fibonacci algorithm using memoization
  • Generate the Fibonacci sequence using an iterative algorithm

To get the most out of this tutorial, you should know the basics of Big O notation, object-oriented programming, Python’s special methods, conditional statements, functions, and basic data structures like lists, queues, and stacks. Having some familiarity with these concepts will greatly help you understand the new ones you’ll be exploring in this tutorial.

Getting Started With the Fibonacci Sequence

The Fibonacci sequence is a well-known sequence of integer numbers that occurs naturally in many problems and has a recursive definition. To generate the Fibonacci sequence, you need to understand its pattern. The sequence starts with 0 and 1, and each subsequent number is the sum of the two preceding numbers.

def fibonacci(n):
    if n <= 0:
        return []
    elif n == 1:
        return [0]
    elif n == 2:
        return [0, 1]
    else:
        fib_seq = [0, 1]
        for i in range(2, n):
            fib_seq.append(fib_seq[i-1] + fib_seq[i-2])
        return fib_seq

This function takes an integer n as input and returns a list containing the first n Fibonacci numbers. The function first handles the base cases when n is less than or equal to 0, 1, or 2. In these cases, it returns the empty list, [0], or [0, 1] respectively. For n greater than 2, the function iteratively generates the Fibonacci sequence by appending the sum of the last two numbers in the sequence to the list.

Examining the Recursion Behind the Fibonacci Sequence

The recursive nature of the Fibonacci sequence is evident in its definition. Each number in the sequence is the sum of the two preceding numbers. This recursive relationship can be translated into a recursive algorithm to generate the sequence.

def fibonacci_recursive(n):
    if n <= 0:
        return []
    elif n == 1:
        return [0]
    elif n == 2:
        return [0, 1]
    else:
        fib_seq = fibonacci_recursive(n-1)
        fib_seq.append(fib_seq[-1] + fib_seq[-2])
        return fib_seq

The function fibonacci_recursive also takes an integer n as input and returns a list containing the first n Fibonacci numbers. It uses a recursive approach to generate the sequence. The base cases are the same as before, and for n greater than 2, the function recursively calls itself with n-1 and appends the sum of the last two numbers in the sequence to the list.

Generating the Fibonacci Sequence Recursively in Python

Now that you understand the recursive algorithm behind the Fibonacci sequence, let’s see how it can be implemented in Python using recursion.

def fibonacci_recursive(n):
    if n <= 0:
        return []
    elif n == 1:
        return [0]
    elif n == 2:
        return [0, 1]
    else:
        fib_seq = fibonacci_recursive(n-1)
        fib_seq.append(fib_seq[-1] + fib_seq[-2])
        return fib_seq

To generate the Fibonacci sequence recursively, you can define a recursive function fibonacci_recursive that takes an integer n as input. The base cases are the same as before. For n greater than 2, you can use the recursive relationship to obtain the preceding Fibonacci sequence (by calling fibonacci_recursive(n-1)) and append the sum of the last two numbers in the sequence to it.

Optimizing the Recursive Algorithm for the Fibonacci Sequence

While the recursive algorithm works, it can be computationally expensive for large values of n. Each call to the function results in two more recursive calls, leading to an exponential increase in the number of function calls. This can result in significantly slow execution times. To address this inefficiency, you can optimize the recursive algorithm using memoization or explore an iterative algorithm.

Memoizing the Recursive Algorithm

Memoization is an optimization technique that stores the results of expensive function calls and returns the cached result when the same inputs occur again. By memoizing the recursive Fibonacci algorithm, you can avoid redundant calculations and significantly speed up the execution.

def fibonacci_memoized(n, memo={}):
    if n <= 0:
        return []
    elif n == 1:
        return [0]
    elif n == 2:
        return [0, 1]
    elif n in memo:
        return memo[n]
    else:
        fib_seq = fibonacci_memoized(n-1, memo)
        fib_seq.append(fib_seq[-1] + fib_seq[-2])
        memo[n] = fib_seq
        return memo[n]

In this modified version fibonacci_memoized, an additional memo parameter is introduced to store the results of previously calculated Fibonacci sequences. Before diving into the recursive call, the function checks if the result for n is already present in the memo dictionary. If it is, the function returns the stored result immediately. Otherwise, the function proceeds with the recursive call, calculates the Fibonacci sequence, and stores it in the memo dictionary before returning it.

Exploring an Iterative Algorithm

Another way to optimize the generation of the Fibonacci sequence is to use an iterative algorithm. In this approach, you generate the sequence iteratively by building it up from the base cases.

def fibonacci_iterative(n):
    if n <= 0:
        return []
    elif n == 1:
        return [0]
    elif n == 2:
        return [0, 1]
    else:
        fib_seq = [0, 1]
        while len(fib_seq) < n:
            fib_seq.append(fib_seq[-1] + fib_seq[-2])
        return fib_seq

The function fibonacci_iterative takes an integer n as input and returns the first n Fibonacci numbers. It uses a while loop to iteratively generate the sequence, starting from the base cases [0, 1]. The loop continues until the length of the sequence reaches n, with each iteration appending the sum of the last two numbers to the sequence.

Generating the Fibonacci Sequence in Python

Now that you have explored both the recursive and iterative approaches, let’s look at how you can generate the Fibonacci sequence using recursion and a Python class, as well as using iteration and a Python function.

Using Recursion and a Python Class

class Fibonacci:
    def __init__(self, n):
        self.n = n
        self.fib_seq = self._generate_fibonacci()


    def _generate_fibonacci(self):
        if self.n <= 0:
            return []
        elif self.n == 1:
            return [0]
        elif self.n == 2:
            return [0, 1]
        else:
            fib_seq = Fibonacci(self.n - 1).fib_seq
            fib_seq.append(fib_seq[-1] + fib_seq[-2])
            return fib_seq


# Usage
fib = Fibonacci(10)
print(fib.fib_seq)

In this example, the Fibonacci class takes an integer n as input and generates the Fibonacci sequence as an attribute fib_seq. The sequence is generated using the recursive algorithm implemented inside the _generate_fibonacci method. The base cases and recursive relationship are the same as before.

Using Iteration and a Python Function

def fibonacci(n):
    fib_seq = [0, 1] if n >= 2 else [0] if n == 1 else []
    while len(fib_seq) < n:
        fib_seq.append(fib_seq[-1] + fib_seq[-2])
    return fib_seq


# Usage
fib_seq = fibonacci(10)
print(fib_seq)

In this example, the function fibonacci takes an integer n as input and returns the first n Fibonacci numbers. It uses an iterative approach, as explained earlier, to generate the sequence. The sequence is built up from the base cases [0, 1] using a while loop that continues until the desired length is reached.

Conclusion

In this tutorial, you have learned what the Fibonacci sequence is and how to generate it using Python. You explored the recursive algorithm and optimized it using memoization and explored an iterative algorithm as well. With this knowledge, you can now apply the Fibonacci sequence to various problems that require its use, such as calculating mathematical series or simulating natural growth processes. Happy coding!