# Python Program to Print the Fibonacci Sequence (with Explanation)

Python Program to Print the Fibonacci Sequence: The Fibonacci series is a well-known mathematical sequence that has fascinated mathematicians and computer scientists alike. It is a sequence of numbers where each number is the sum of the two preceding ones, starting with 0 and 1. In this blog post, we will explore different ways to print the Fibonacci series using Python.

We will cover a range of methods, from simple loops to advanced generators, each with its own advantages and disadvantages. Whether you are a beginner or an experienced programmer, you will find something useful in this blog post to help you better understand the Fibonacci series and how to generate it in Python.

## Python Program to Print the Fibonacci Sequence

The Fibonacci series is a sequence of numbers where each number is the sum of the two preceding ones. In mathematical terms, it can be defined as F(n) = F(n-1) + F(n-2), where F(0) = 0 and F(1) = 1. So let’s discuss the “Python Program to Print the Fibonacci Sequence” in different ways.

### Fibonacci Sequence Using Recursion

One of the simplest ways to print the Fibonacci series is by using recursion. In this method, we define a function that calls itself recursively to generate the next number in the series.

``````def fibonacci(n):
if n <= 1:
return n
else:
return fibonacci(n-1) + fibonacci(n-2)

terms = 10

if terms <= 0:
print("Please enter a positive integer.")
else:
print("Fibonacci sequence:")
for i in range(terms):
print(fibonacci(i))
``````

Explanation:

The function takes an integer `n` as input, which represents the number of terms in the sequence to generate. If `n` is less than or equal to 1, the function returns n, which is either 0 or 1 depending on the value of `n`. Otherwise, the function recursively calls itself twice, passing in `n-1` and `n-2` as arguments, and returns the sum of the two results.

The code then sets the variable `terms` to 10, which represents the number of terms to generate in the sequence. If `terms` is less than or equal to 0, the code prints a message asking the user to enter a positive integer.

Otherwise, the code prints a message indicating that it is printing the Fibonacci sequence and uses a `for` loop to generate and print each term in the sequence.

The `for` loop iterates over a range of integers from 0 to `terms - 1`, and calls the `fibonacci` function to generate the value of each term in the sequence. The value of each term is then printed to the console using the `print` function.

### Fibonacci Sequence Using While Loop

Another way to print the Fibonacci series is by using a loop. In this method, we start with the first two numbers in the series (0 and 1) and generate the next numbers by adding the previous two numbers.

``````terms = 10
n1, n2 = 0, 1
count = 0

if terms <= 0:
print("Please enter a positive integer.")
elif terms == 1:
print("Fibonacci sequence upto",terms,":")
print(n1)
else:
print("Fibonacci sequence:")
while count < terms:
print(n1)
nth = n1 + n2
n1 = n2
n2 = nth
count += 1
``````

Explanation:

The code sets the variable `terms` to 10, which represents the number of terms to generate in the sequence. It then sets `n1` and `n2` to 0 and 1 respectively, which are the first two numbers in the sequence. The variable `count` is initialized to 0, which will be used to keep track of how many terms have been generated so far.

If `terms` is less than or equal to 0, the code prints a message asking the user to enter a positive integer. If `terms` is 1, the code prints a message indicating that it is printing the Fibonacci sequence up to the first term, which is simply 0.

If `terms` is greater than 1, the code enters a `while` loop that will continue to generate terms in the sequence until `count` is equal to `terms`. In each iteration of the loop, the code prints the value of `n1`, which is the current term in the sequence. It then calculates the next term in the sequence, which is the sum of `n1` and `n2`, and stores it in a variable called `nth`.

Finally, the code updates `n1` and `n2` to be the previous two terms in the sequence, and increments `count` to keep track of how many terms have been generated so far. This code is a more efficient way to generate the Fibonacci sequence because it uses a loop instead of recursion, and it only needs to store two variables at any given time instead of an entire sequence of numbers.

### Fibonacci Sequence Using List and for loop

We can also use a list to store the Fibonacci series and print the elements of the list.

``````def fibonacci(n):
fib= [0, 1]
for i in range(2, n):
fib.append(fib[i-1] + fib[i-2])
return fib

terms = 10

if terms <= 0:
print("Please enter a positive integer.")
else:
print("Fibonacci sequence:")
series = fibonacci(terms)
for num in series:
print(num)``````

Explanation:

The code defines a function called `fibonacci` that takes an integer `n` as input, which represents the number of terms in the sequence to generate. The function initializes a list called `fib` with the first two numbers in the sequence, 0 and 1. It then enters a `for` loop that iterates over a range of integers from 2 to `n-1`, and appends the sum of the previous two numbers in the sequence to the list.

After the loop completes, the function returns the list of numbers in the Fibonacci sequence. The code then sets the variable `terms` to 10, which represents the number of terms to generate in the sequence. If `terms` is less than or equal to 0, the code prints a message asking the user to enter a positive integer.

Otherwise, the code prints a message indicating that it is printing the Fibonacci sequence and calls the `fibonacci` function to generate the sequence. The resulting list of numbers is stored in a variable called `series`, which is then printed to the console using a `for` loop that iterates over the elements in the list and prints each one.

### Fibonacci Sequence Using Generators

Generators are a powerful feature in Python that allows us to create iterators. We can use a generator to generate the Fibonacci series and print its elements.

``````def fibonacci():
a, b = 0, 1
while True:
yield a
a, b = b, a + b

terms = 10
fib = fibonacci()

if terms <= 0:
print("Please enter a positive integer.")
else:
print("Fibonacci sequence:")
for i in range(terms):
print(next(fib))
``````

Explanation:

The `fibonacci()` function defines two variables `a` and `b` and initializes them to 0 and 1, respectively. Then it enters an infinite loop, where it yields the current value of `a` in each iteration using the `yield` keyword. After that, it updates the values of `a` and `b` by swapping them and adding them together.

The `terms` variable is initialized with the number of terms of the Fibonacci sequence that we want to generate. Then, the function creates a Fibonacci sequence generator object `fib` using the `fibonacci()` function. If `terms` is less than or equal to zero, it prints an error message, indicating that the input is invalid.

Otherwise, it prints a message indicating that it is going to print the Fibonacci sequence and enters a loop where it iterates over `terms` and calls the `next()` function on the `fib` generator object to get the next value of the sequence, which it prints to the console using the `print()` function.

## Conclusion

In this blog post, we discussed the “Python Program to Print the Fibonacci Sequence” in different ways. We explored recursion, loops, lists, and generators to generate the series. Each method has its own advantages and disadvantages, and we should choose the method that suits our needs best.