Speed Up Your Python with Rust: Optimizing Python with Rust

Introduction

The book "Speed Up Your Python with Rust" (2022) by Maxwell Flitton is a practical guide for Python developers looking to overcome the performance limitations of the interpreted language. In a world where execution speed is critical (data processing, web services, system utilities), Rust offers the power of a systems language without a garbage collector. The book teaches how to create native Python extensions in Rust using the PyO3 library. This is not just a syntax translation — it is a deep dive into the architecture of interaction between the two languages.

What the book is about

The book is structured as a step-by-step journey from the basics of Rust to creating production-ready Python modules. The author starts with tool installation, then introduces Rust syntax, the ownership system, and borrowing. Next, the focus is on PyO3: how to wrap functions, classes, handle exceptions, and pass complex data types. Dedicated chapters cover loop optimization, working with arrays (numpy compatibility), parallelism via Rust threads, and asynchrony. The book concludes with an analysis of real projects: speeding up a JSON parser, optimizing a sorting algorithm, and integrating with web frameworks.

Who this book is for

The book is aimed at intermediate and advanced Python developers who encounter performance bottlenecks. Knowledge of Rust is not required — the author explains concepts from scratch, but assumes an understanding of pointers, stack/heap, and basic memory management. It will also be useful for systems programmers looking to expand their toolkit with the Python ecosystem.

What the reader will learn

• Rust basics: syntax, type system, ownership, borrowing, lifetimes.
• PyO3: creating Python modules in Rust, type conversion, memory management.
• Profiling: how to find bottlenecks in Python code and decide what to rewrite in Rust.
• Loop optimization: replacing Python iterations with zero-cost Rust iterators.
• Working with numpy: creating fast functions for numerical computations.
• Parallelism: using Rust threads (std::thread) and asynchrony (tokio) inside Python.
• Error handling: correctly passing exceptions between languages.
• Building and distribution: configuring Cargo, compiling for different platforms, integrating with setuptools.

Strengths

The main advantage of the book is its practical focus. Each chapter contains ready-made code examples that can be run immediately. The author doesn't just show "how," but also explains "why": why Rust is faster, why ownership prevents data races, why PyO3 chose a particular API. The profiling chapter deserves special mention — it teaches not to blindly rewrite all code, but to find critical sections. The book is written in a lively style, with humor and real cases from the author's experience. Another plus is its relevance: PyO3 is actively developed, and the book covers version 0.16+ (2022).

Who it is recommended for

I recommend the book to all Python developers who want to go beyond "gluing libraries together" and learn to create high-performance components. It will be especially useful for backend engineers, data engineers, and CLI tool developers. If you already know Rust and want to use it with Python, the book provides ready-made recipes. Beginners in programming may find it challenging due to the abundance of low-level concepts, but with persistence, this book can also serve as an excellent springboard.