Python.CodeCompared.To/Rust

println! is a macro (note the !), not a function. Like Python's print(), it appends a trailing newline. Every standalone Rust program requires a fn main() entry point — the runner adds this boilerplate automatically.

Rust's println! uses {} placeholders filled left-to-right from its arguments, similar to Python's str.format(). Since Rust 1.58, you can capture variable names directly inside {}, matching Python f-string syntax.

{:?} invokes the Debug trait, which produces machine-readable output similar to Python's repr(). Use {:#?} for pretty-printed (indented) debug output.

The format! macro builds a String without printing it, analogous to Python's f-string used for assignment. Rust format specifiers use :.2 (digits after the decimal), matching Python's :.2f convention.

Rust uses // for line comments and /* */ for block comments, matching C-style conventions. Python's triple-quoted strings are sometimes used as multi-line comments, but Rust has dedicated block comment syntax.

In Rust, let bindings are immutable by default — reassigning them is a compile error. Python variables are always mutable references; Rust enforces immutability at the language level.

Mutation requires the explicit mut keyword. This makes it immediately visible at the declaration site whether a variable is intended to change — a form of documentation that Python lacks.

Rust infers types at compile time — you rarely need to annotate locals. Unlike Python's dynamic typing, Rust's types are fixed at compile time; the compiler catches type mismatches before any code runs.

Rust has many integer types (i8, i16, i32, i64, i128, u8…u128, usize) and two float types (f32, f64). Python has a single unbounded int and float.

Rust allows re-declaring a variable with the same name via let, which creates a new binding that shadows the old one. Shadowing can even change the type, whereas Python reassignment just rebinds the same name.

Rust const requires an explicit type annotation and must be a compile-time value. Unlike Python's uppercase convention, Rust's const is enforced by the compiler — the value is inlined everywhere it is used.

Rust booleans are lowercase true/false. Rust uses &&, ||, and ! for logical operators; Python uses the English keywords and, or, not.

Rust has two string types: &str (a borrowed reference to UTF-8 bytes, often a string literal) and String (an owned, heap-allocated, growable string). Python has only one str type.

The + operator on a String takes ownership of the left operand and appends the right (&str). After first + second, first is no longer usable. For repeated concatenation, prefer format! to avoid confusion.

Rust's string methods mirror Python's: trim() replaces strip(), to_uppercase() replaces upper(). Methods return new values — strings in Rust are immutable by default.

Rust's split_whitespace() is a lazy iterator; calling .collect() materializes it into a Vec. Python's split() returns a list directly. Rust's join() is a method on slices, while Python's is on the separator string.

Rust uses method calls where Python uses the in operator and methods. ends_with accepts both a &str and a char — note the single quotes for the char literal '!'.

Rust strings are UTF-8 encoded bytes. text.len() returns bytes, not characters. Use text.chars().count() for character count, matching Python's len(). Rust's char type is a Unicode scalar value (like Python's single-character string).

Python integers have arbitrary precision and never overflow. Rust integers have fixed sizes; overflow panics in debug mode and wraps in release mode. Use underscores in numeric literals for readability — both Python and Rust support this.

In Rust, dividing two integers does integer division automatically — there is no // operator. Python's / always returns a float; Rust's / returns the same type as its operands. Rust has no ** exponentiation operator; use i32::pow() or f64::powi().

Rust requires at least one operand to be a float literal for float division. Mathematical constants live in std::f64::consts. Formatting with {:.2} rounds for display (like Python's round() used in f-strings).

Rust requires explicit casts with as for numeric conversions — implicit widening does not exist. Parsing a string returns a Result; .unwrap() panics on failure. Python's constructors int() and float() raise ValueError on failure instead.

Rust's ownership model means each value has exactly one owner at a time. Assigning a heap value (String) to another variable moves it — the original is no longer usable. Python uses reference counting and garbage collection, so aliases are always safe.

.clone() creates a deep copy of a value, allowing both the original and the copy to coexist as independent owners. This is analogous to Python's copy.deepcopy(). Cloning is explicit in Rust — the compiler never clones silently.

Passing &numbers lends the value to the function without transferring ownership. The function receives a shared reference (&Vec) and may read but not modify the data. Python functions always receive references implicitly — there is no equivalent opt-in.

A mutable reference (&mut T) allows a function to modify the caller's data. Rust enforces that only one mutable reference to a value can exist at a time — this eliminates data races at compile time. Python has no such restriction.

Simple types like integers, booleans, and chars implement the Copy trait, meaning assignment copies their value on the stack instead of moving ownership. Heap types like String and Vec do not implement Copy and are moved instead.

Vec is Rust's growable list, equivalent to Python's list. The vec! macro creates a vector with initial values. Negative indexing does not exist in Rust — use .last() or compute the index.

Rust slice syntax uses .. ranges (exclusive end) instead of Python's : syntax. The & prefix borrows the slice without copying. Rust ranges also support inclusive end with ..=.

HashMap must be imported from std::collections. Indexing with [] panics if the key is missing; use .get() for safe access, which returns Option<&V>. Python's dict.get(key, default) maps to .get(key).unwrap_or(&default).

HashSet stores unique values with O(1) lookup, like Python's set. Elements can be collected from any iterator with .collect(). Both Python and Rust HashSets are unordered.

Rust tuples are indexed with .0, .1, etc., rather than [0], [1]. Like Python, they support destructuring assignment. Rust tuple types are part of the type system: (i32, i32) and (i32, &str, bool) are distinct types.

Const generics let a definition be parameterized over a value — here the array length N — not just over types. Python has no equivalent: every list is dynamically sized and length is purely a runtime property. Because the length is part of the Rust type and fixed at compile time, [i32; 3] and [i32; 5] are distinct types served by one total, stored inline on the stack with no heap allocation.

Rust uses else if (not elif) and requires curly braces around every block. Parentheses around the condition are optional and conventionally omitted. Indentation is not syntactically significant in Rust.

In Rust, if is an expression that returns the last value in the chosen branch (with no semicolon on that line). Python's ternary x if cond else y maps naturally to Rust's if cond { x } else { y }.

Rust's match is exhaustive — the compiler requires all possible values to be handled (use _ as a catch-all). Python's match (added in 3.10) is similar but not enforced by the interpreter.

Both Python and Rust support guard conditions in match arms using if. Rust match arms use => to separate the pattern from the body. Multiple comma-separated patterns can share one arm: "a" | "b" => ....

Rust match supports range patterns (80..=89 means 80 through 89 inclusive). This is more concise than Python's guard-based approach. Range patterns use ..= (inclusive) — exclusive ranges are not valid in match patterns.

Rust's range 0..5 is exclusive (like Python's range(5)) and 1..=5 is inclusive. Ranges are iterators — they work directly in for loops without a separate range() call.

The &fruits borrows the vector for iteration, leaving the original usable afterward. Iterating without & would move the vector and consume it. Python's for loop always borrows implicitly.

Rust's .enumerate() is an iterator adapter, chained after .iter(). It yields (usize, &T) tuples. Python's enumerate() is a built-in that wraps any iterable.

Rust's while loop is identical in structure to Python's. Note that count must be declared mut to allow mutation. Rust has no while True: — use loop { } for an infinite loop.

Rust's loop keyword creates an unconditional infinite loop, replacing Python's while True:. A loop block can also return a value: let result = loop { break 42; };.

Rust iterators are lazy — nothing runs until you call a consuming adapter like .collect(), .sum(), or .count(). This matches Python's map() and filter() which also return lazy iterators (wrapped with list() to evaluate).

.sum() requires a type annotation to resolve ambiguity. .chain() lazily concatenates two iterators without allocating an intermediate collection. Python's + on lists creates a new list eagerly.

Rust function parameters must have explicit type annotations — there is no type inference for function signatures. The return type (if any) is declared after ->. Functions without an explicit return type implicitly return the unit type ().

In Rust, omitting the semicolon from the last expression returns it implicitly. This is idiomatic Rust. You can also use return explicitly for early returns. Python always uses the explicit return keyword.

Rust returns multiple values by returning a tuple, just like Python. The caller destructures it with let (a, b) = .... The &[i32] parameter type is a slice — a view into any contiguous sequence of i32 values.

Python type hints are optional and ignored at runtime — the interpreter does not enforce them. Rust type annotations on function signatures are mandatory and enforced at compile time. Calling multiply("a", "b") would fail at runtime in Python but is a compile error in Rust.

Both languages spell asynchronous code with async and await, and in both an async function is lazy — calling it produces a coroutine/future that does nothing until it is driven. The difference is the runtime: Python bundles an event loop you start with asyncio.run(), whereas Rust's std ships none, so production code adds a runtime such as tokio. The little block_on here is the moral equivalent of asyncio.run — it polls a single future to completion on the current thread.

Rust closures use |params| body syntax. Type annotations are usually inferred from usage. Unlike Python lambdas (limited to a single expression), Rust closures can contain full block bodies with |params| { ... }.

Rust closures capture their environment automatically, but the compiler determines how — by shared reference, mutable reference, or move. Use move |...| to force ownership transfer into the closure (needed when the closure outlives the enclosing scope).

Higher-order functions in Rust use generic type parameters with trait bounds: F: Fn(i32) -> i32 accepts any callable matching that signature. Fn, FnMut, and FnOnce correspond to closures that borrow, mutably borrow, or consume their captured environment.

Rust's sort_by_key() takes a closure that maps each element to a sortable key, directly equivalent to Python's key= parameter. For more complex comparisons, use sort_by(|a, b| a.cmp(b)).

A Rust struct is a named collection of fields with explicit types — similar to a Python class with only __init__ and data attributes. Structs have no inheritance. Methods are added separately in an impl block.

Methods are defined in an impl block separate from the struct definition. The first parameter &self is an immutable reference to the instance — equivalent to Python's self. Use &mut self if the method needs to modify the struct.

Rust has no built-in constructors — the convention is to define an associated function named new (no self parameter, called with ::). This mirrors Python's __init__ and @classmethod. The shorthand Rectangle { width, height } uses field init shorthand when variable names match field names.

Rust enums are used for any type with a fixed set of variants. Unlike Python's enum.Enum, Rust variants don't need values — the variant name itself is the data. The #[derive(Debug)] attribute auto-generates the {:?} formatter.

Rust enums can carry data in each variant — each variant can have a different structure. This is a "tagged union" or "algebraic data type," far more powerful than Python's enum.Enum. Pattern matching extracts the inner data safely.

Option is Rust's null-safety mechanism. A function returning Option forces callers to handle the None case explicitly — there is no way to accidentally use a None as if it were a value. Python's None can appear in any variable without any compiler enforcement.

if let Some(value) = expression is shorthand for a match that handles only one variant. It is idiomatic for when you only care about the Some case. The equivalent for None is if let None = ..., though .is_none() is cleaner.

Stabilised in the 2024 edition, let chains let a let pattern and ordinary boolean tests be joined with && in one if — close kin to Python's walrus operator in if (value := settings.get("timeout")) and value > 10. The Rust Some(..) pattern also distinguishes "key missing" from "value present", which Python's .get() blurs by returning None. Before 2024 this needed a nested if let { if value > 10 { ... } }; a binding from an earlier link is visible to later links.

Rust uses Result instead of exceptions. Errors are values — the caller is forced to handle them at the type level. Python's try/except is invisible in signatures, so callers may not know what exceptions a function raises without reading the documentation.

The ? operator unwraps Ok or returns early with the Err value, propagating errors up the call stack. It is the idiomatic replacement for Python's raise ... from ... chains, and keeps happy-path code flat without deeply nested error checks.

.unwrap() extracts the Ok value or panics on Err, analogous to Python code that doesn't catch exceptions. .expect("message") is the same but includes a custom panic message. Use these only in tests or when you are certain the value is Ok.

panic! terminates the current thread with a message, analogous to Python's assert or raising an unhandled exception. Panics are for programming errors (broken invariants), not expected failure conditions — those should use Result.

A let ... else binding handles the failure case up front, much like Python's try/except with an early return: it pattern-matches on the success value and binds it in the surrounding scope, and if the match fails it runs the else block, which must diverge (return, break, continue, or panic!). Unlike if let, whose binding is trapped inside its block, the value from let-else remains in scope, so the rest of the function reads straight down with no extra indentation.

A Rust trait is like a Python abstract base class — it defines a set of methods a type must implement. Rust traits are enforced at compile time with zero runtime overhead, whereas Python ABCs are checked at instantiation time.

Rust's impl TraitName for StructName is the equivalent of Python class inheritance from an ABC. Multiple traits can be implemented for the same struct. Unlike Python, traits cannot carry instance state — only behavior.

The Display trait implements {} formatting (like Python's __str__), and Debug implements {:?} formatting (like __repr__). For types where the default debug format is sufficient, use #[derive(Debug)] instead.

Rust generics use trait bounds to express constraints on type parameters. T: Display means "any type that implements Display." Python uses duck typing — if the object has the required method, it works; Rust enforces the contract at compile time.

Cargo.toml is Rust's project manifest, combining the roles of Python's pyproject.toml and requirements.txt. Running cargo add reqwest adds a dependency; cargo build downloads and compiles everything. There is no separate "activate virtualenv" step.

Rust's use brings a path into scope, like Python's from module import name. The standard library is available via the std:: prefix without any imports — use just shortens the path.

Rust modules can be inline (using mod name { }) or in separate files (src/math_utils.rs). Items are private by default — use pub to expose them. Python modules are always public; everything in a .py file is accessible by default.

Cargo is Rust's all-in-one build tool, package manager, and test runner. Unlike Python's fragmented toolchain (pip, venv, pytest, setuptools), Cargo handles everything. cargo check is especially useful during development — it verifies types without the cost of code generation.