NOTE:Originally posted in my Substack: https://open.substack.com/pub/andresalvareziglesias/p/speeding-up-python-code-with-c-and

Python is not the paradigm of speed, we all know this. But we can speed up some critical parts of our apps with the help of our good old friend C.

## The Fibonacci sequence in plain Python

The Fibonacci sequence is a classic example used to teach software development. Is a series of numbers that starts with 0 and 1. Each subsequent number is the sum of the previous two. So, the sequence goes like this: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...

We can develop Fibonacci in python in this way:

```
import time
# Configure iterations
iterations = 30
# Define fibonacci in native python
def fibonacci(n):
if n <= 1:
return n
else:
return fibonacci(n-1) + fibonacci(n-2)
# Calculate in pure python
start_time = time.perf_counter()
print(f"Calculating {iterations} iterations of fibonacci...")
print(fibonacci(iterations))
end_time = time.perf_counter()
execution_time_ms = (end_time - start_time) * 1000
print(f"Execution time: {execution_time_ms:.2f} milliseconds")
print()
```

If we execute this pure Python (in a Google IDX virtual machine) version of Fibonacci we get:

- 10 iterations: 5.77 milliseconds
- 30 iterations: 984.36 milliseconds
- 50 iterations: (I have to cancel the process, too much time)

## The Fibonacci sequence in C

We can develop the same sequence in plain C:

```
#include <stdio.h>
int fibonacci(int n) {
if (n <= 1) {
return n;
} else {
return fibonacci(n - 1) + fibonacci(n - 2);
}
}
```

Compile the library with GCC:

```
gcc -o fibonacci.so -shared -fPIC -O2 fibonacci.c
```

Now, we have a native binary library with the fibonacci sequence function inside. We can embed this library inside a Python app with ctypes (the Python C types library, because Python itself is developed in C):

```
import time
from ctypes import c_double, c_int, CDLL
# Configure iterations
iterations = 30
# Import the C library
library = CDLL('./fibonacci.so')
fibonacciAsLibrary = library.fibonacci
fibonacciAsLibrary.restype = c_int
# Calculate as C library
start_time = time.perf_counter()
print(f"Calculating {iterations} iterations of fibonacci as C library...")
print(fibonacciAsLibrary(iterations))
end_time = time.perf_counter()
execution_time_ms = (end_time - start_time) * 1000
print(f"Execution time: {execution_time_ms:.2f} milliseconds")
print()
```

Now, if we execute this version on Fibonacci, we get:

- 10 iterations: 0.54 milliseconds
- 30 iterations: 6.92 millisecond
- 50 iterations: 82324.90 milliseconds

Better, isn’t?

## Use cases for Python and C integration

We can use this kind of integration in a lot of apps and scenarios, like:

- Speed up serializers and deserializers in our Django app
- Speed up critical parts on a workflow
- Low level interactions with the OS
- Etc.

And you? How will you use this litle trick in your project? I woult love to hear your comments!

## About the list

Among the Python and Docker posts, I will also write about other related topics (always tech and programming topics, I promise... with the fingers crossed), like:

- Software architecture
- Programming environments
- Linux operating system
- Etc.

If you found some interesting technology, programming language or whatever, please, let me know! I'm always open to learning something new!

## About the author

I'm Andrés, a full-stack software developer based in Palma, on a personal journey to improve my coding skills. I'm also a self-published fantasy writer with four published novels to my name. Feel free to ask me anything!

## Top comments (3)

An excellent idea, thank you Andrés!

Awesome post! I've never used C with Python but I should give it a try.

That's so perfect 👌👌

Thanks for follow my github

github.com/Mohammadparsa1384