Rust for Python Programmers: Complete Training Guide

A comprehensive guide to learning Rust for developers with Python experience. This guide covers everything from basic syntax to advanced patterns, focusing on the conceptual shifts required when moving from a dynamically-typed, garbage-collected language to a statically-typed systems language with compile-time memory safety.

How to Use This Book

Self-study format: Work through Part I (ch 1–6) first — these map closely to Python concepts you already know. Part II (ch 7–12) introduces Rust-specific ideas like ownership and traits. Part III (ch 13–16) covers advanced topics and migration.

Pacing recommendations:

Chapters	Topic	Suggested Time	Checkpoint
1–4	Setup, types, control flow	1 day	You can write a CLI temperature converter in Rust
5–6	Data structures, enums, pattern matching	1–2 days	You can define an enum with data and match exhaustively on it
7	Ownership and borrowing	1–2 days	You can explain why let s2 = s1 invalidates s1
8–9	Modules, error handling	1 day	You can create a multi-file project that propagates errors with ?
10–12	Traits, generics, closures, iterators	1–2 days	You can translate a list comprehension to an iterator chain
13	Concurrency	1 day	You can write a thread-safe counter with Arc<Mutex<T>>
14	Unsafe, PyO3, testing	1 day	You can call a Rust function from Python via PyO3
15–16	Migration, best practices	At your own pace	Reference material — consult as you write real code
17	Capstone project	2–3 days	Build a complete CLI app tying everything together

How to use the exercises:

• Chapters include hands-on exercises in collapsible <details> blocks with solutions

• Always try the exercise before expanding the solution. Struggling with the borrow checker is part of learning — the compiler’s error messages are your teacher

• If you’re stuck for more than 15 minutes, expand the solution, study it, then close it and try again from scratch

• The Rust Playground lets you run code without a local install

Difficulty indicators:

• 🟢 Beginner — Direct translation from Python concepts

• 🟡 Intermediate — Requires understanding ownership or traits

• 🔴 Advanced — Lifetimes, async internals, or unsafe code

When you hit a wall:

• Read the compiler error message carefully — Rust’s errors are exceptionally helpful

• Re-read the relevant section; concepts like ownership (ch7) often click on the second pass

• The Rust standard library docs are excellent — search for any type or method

• For deeper async patterns, see the companion Async Rust Training

---

Table of Contents

Part I — Foundations

1. Introduction and Motivation 🟢

• The Case for Rust for Python Developers

• Common Python Pain Points That Rust Addresses

• When to Choose Rust Over Python

2. Getting Started 🟢

• Installation and Setup

• Your First Rust Program

• Cargo vs pip/Poetry

3. Built-in Types and Variables 🟢

• Variables and Mutability

• Primitive Types Comparison

• String Types: String vs &str

4. Control Flow 🟢

• Conditional Statements

• Loops and Iteration

• Expression Blocks

• Functions and Type Signatures

5. Data Structures and Collections 🟢

• Tuples, Arrays, Slices

• Structs vs Classes

• Vec vs list, HashMap vs dict

6. Enums and Pattern Matching 🟡

• Algebraic Data Types vs Union Types

• Exhaustive Pattern Matching

• Option for None Safety

Part II — Core Concepts

7. Ownership and Borrowing 🟡

• Understanding Ownership

• Move Semantics vs Reference Counting

• Borrowing and Lifetimes

• Smart Pointers

8. Crates and Modules 🟢

• Rust Modules vs Python Packages

• Crates vs PyPI Packages

9. Error Handling 🟡

• Exceptions vs Result

• The ? Operator

• Custom Error Types with thiserror

10. Traits and Generics 🟡

• Traits vs Duck Typing

• Protocols (PEP 544) vs Traits

• Generic Constraints

11. From and Into Traits 🟡

• Type Conversions in Rust

• From, Into, TryFrom

• String Conversion Patterns

12. Closures and Iterators 🟡

• Closures vs Lambdas

• Iterators vs Generators

• Macros: Code That Writes Code

Part III — Advanced Topics & Migration

13. Concurrency 🔴

• No GIL: True Parallelism

• Thread Safety: Type System Guarantees

• async/await Comparison

14. Unsafe Rust, FFI, and Testing 🔴

• When and Why to Use Unsafe

• PyO3: Rust Extensions for Python

• Unit Tests vs pytest

15. Migration Patterns 🟡

• Common Python Patterns in Rust

• Essential Crates for Python Developers

• Incremental Adoption Strategy

16. Best Practices 🟡

• Idiomatic Rust for Python Developers

• Common Pitfalls and Solutions

• Python→Rust Rosetta Stone

• Learning Path and Resources

---

Part IV — Capstone

17. Capstone Project: CLI Task Manager 🔴

• The Project: rustdo

• Data Model, Storage, Commands, Business Logic

• Tests and Stretch Goals

---