Accelerating Python Programs with Rust: A Performance Comparison

Python excels in development speed and flexibility, but when it comes to performance, compiled languages like C++ or Rust often outshine it. For applications with stringent performance requirements, relying solely on Python might lead to sluggish execution, impacting user experience. Hence, exploring how Rust can be utilized to boost the runtime speed of Python programs becomes a compelling topic.

In this article, we will compare the performance of Python and Rust through an experiment involving the calculation of the 30th Fibonacci number over 50 iterations.

1. Performance Comparison between Python and Rust

1.1 Python Version:

import time
​
def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)
​
def main(test_times=50):
    start = time.time()
    for _ in range(test_times):
        fib(30)
    print(f"Total time spent: {time.time() - start} s")
​
main()
# Total time spent: 7.306154012680054 s

The Python version takes over 7 seconds to complete, which is suboptimal for most applications.

1.2 Rust Version:

“Blazingly fast” is how Rust’s official website describes its performance. Below is the Rust implementation for calculating the Fibonacci number:

use std::time;
​
fn fib(n: i32) -> u64 {
    match n {
        1 | 2 => 1,
        _ => fib(n - 1) + fib(n - 2)
    }
}
​
fn main() {
    let test_times = 50;
    let start = time::Instant::now();
    for _ in 0..test_times {
        fib(30);
    }
    println!("Total time spent: {:?}", start.elapsed())
}
// Total time spent: 179.774166ms

The Rust version completes in 179.774166 milliseconds, nearly 40 times faster than the Python counterpart!

While Rust demonstrates a clear performance advantage, its syntax may not be as elegant for Python developers, and it comes with a steeper learning curve.

For large projects, a fantastic solution could be using Python as the primary language and leveraging Rust to accelerate performance in specific areas.

2. Rewriting Slow Python Functions in Rust

The Python community has put effort into rewriting low-performance Python functions in Rust, and one popular method is using PyO3, an…