# The Fibonacci Series in Python

The Fibonacci series was discovered by the Italian mathematician Leonardo Fibonacci in 1202 and even earlier by Indian mathematicians. The series appears in unexpected areas such as economics, mathematics, art, and nature.

## Algorithm Sketch

In the following, we give a simple algorithm to calculate the Fibonacci numbers.

The series starts with the Fibonacci numbers zero and one. The algorithm calculates the next element of the series as the sum of both last elements. For this, the algorithm has to keep track only of the last two elements in the series. Thus, we maintain two variables `a` and `b`, being the second last and last element in the series, respectively.
This computation repeats for 10 iterations using a standard `for` loop:

```# Algorithm to Computer
# Fibonacci Series

a, b = 0, 1
for i in range(10):
print(b)
a, b = b, a+b
```

The output are the first 10 Fibonacci numbers:

```1
1
2
3
5
8
13
21
34
55```

For clarity of the code, we used the language feature of multiple assignments in the first and the last line.

This feature works as follows.

• On the left-hand side of the assignment, there is any sequence of variables such as a list or a tuple.
• On the right-hand side of the assignment, we specify the values to be assigned to these variables.

Both sequences on the left and on the right must have the same length. Otherwise, the Python interpreter will throw an error.

Note that all expressions on the right-hand side are first evaluated before they are assigned. This is an important property for our algorithm. Without this property, the last line would be wrong as expression `a+b` would consider the wrong value for `a`.

## How to Store First n Fibonacci Numbers in a List?

Recap, the Fibonacci series is the series of numbers that arises when repeatedly summing up the last two numbers starting from 0 and 1. Here’s an algorithm that stores the first n Fibonacci numbers in a list and returns the list:

```def fibo(n):
result = []
a, b = 0, 1
while a < n:
result.append(a)
a, b = b, a+b
return result

fib100 = fibo(100)
print(fib100[-1]== fib100[-2]+fib100[-3])
# True```

The `fibo` function in the code calculates all Fibonacci numbers up to the function argument `n`.

Again, we use the concise method of multiple assignment to store the value of `b` in the variable `a` and to calculate the new value of `b` as the sum of both. We maintain the whole sequence in the list variable `result` by appending the sequence value a to the end of the list.

The code calculates the Fibonacci sequence up to 100 and stores the whole list in the variable `fib100`. But to understand the code, you do not have to calculate the whole sequence. The print statement only compares whether the last element is equal to the sum of the second and third last element in the sequence. This is true by definition of the Fibonacci series.

## A Simple Python Puzzle About the Fibonacci Series

Can you solve the following puzzle about the Fibonacci algorithm?

Are you a master coder?

## Watch the Related Video Fibonacci One-Liner

I love one-liners. So much so that I’ve written a book Python One-Liners about how to compress Python code into a single line of Python code. As it turns out, you can express the Fibonacci algorithm in a single line of code. Watch the video to see how!

The one-liner code to compute the Fibonacci numbers in a single line is the following:

```# Dependencies
from functools import reduce

# The Data
n = 10

# The One-Liner
fibs = reduce(lambda x, _: x + [x[-2] + x[-1]],  * (n-2), [0, 1])

# The Result
print(fibs)```

You can read a detailed explanation in my full tutorial.

Related Tutorial: The Fibonacci Algorithm in a Single Line of Python Code

## Math-Based Explainer Video Fibonacci

Now, that you’ve learned all about the Fibonacci algorithm, I’m sure you want to test your skills!

The following puzzle is an advanced-level Fibonacci puzzle. Can you solve it?

Are you a master coder?

## Where to Go From Here?

Enough theory, let’s get some practice!

To become successful in coding, you need to get out there and solve real problems for real people. That’s how you can become a six-figure earner easily. And that’s how you polish the skills you really need in practice. After all, what’s the use of learning theory that nobody ever needs?

Practice projects is how you sharpen your saw in coding!

Do you want to become a code master by focusing on practical code projects that actually earn you money and solve problems for people?

Then become a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.

Join my free webinar “How to Build Your High-Income Skill Python” and watch how I grew my coding business online and how you can, too—from the comfort of your own home.

Join the free webinar now! 