Python.CodeCompared.To/Mojo

Mojo's print() works exactly like Python's: it accepts any number of values, joins them with spaces, and adds a newline. The entry point is def main() raises: rather than the implicit top-level execution Python uses. The raises qualifier allows the function to propagate errors freely — a useful habit for main() so any called function can use raise without an additional declaration.

Mojo's print() accepts multiple comma-separated arguments and joins them with spaces — identical to Python's print(). The only visible difference in this example is the var keyword on the first two lines. The multi-argument form is the idiomatic one, and it makes clear that no implicit type coercion is occurring.

Mojo uses # for line comments, identical to Python. A triple-quoted string on a line of its own is a docstring rather than a comment — the compiler reads it and even lints its wording — so use consecutive line comments for longer explanations.

Python's built-in str() converts any value to a string for concatenation. Mojo uses an explicit String(value) constructor call that works the same way. Both produce a human-readable string representation. Alternatively, passing values as separate print() arguments avoids the conversion step entirely and is the more common Mojo idiom.

Mojo introduces a new variable with the var keyword. Bare assignment to an undeclared name still compiles, but the compiler warns that implicit declaration is deprecated — where Python accepts it silently. Types are inferred from the initial value exactly as in Python, so no annotation is needed when the type is obvious from context.

Python's type hints (name: str = "Alice") are advisory — the interpreter ignores them at runtime. Mojo's type annotations are enforced at compile time: assigning the wrong type is a compile error. Mojo uses String (capital S) rather than Python's str, and Float64 rather than float. Plain Int is machine-word-sized (64-bit on modern hardware).

Once a var variable is declared, reassignment uses plain = without the var keyword — the same as Python. Compound assignment operators (+=, -=, *=, /=) all work as expected. The difference from Python is only at the point of initial declaration, where var is required.

Mojo's comptime keyword creates a compile-time constant — the value is substituted at compile time and cannot be changed at runtime. (Older material writes alias, which still compiles with a deprecation warning.) Python only has a naming convention (ALL_CAPS) that other programmers are supposed to respect; nothing prevents reassignment. A comptime value can appear in type parameter positions where only compile-time-known values are allowed, such as SIMD vector widths.

Python's built-in conversion functions (int(), float(), str()) accept almost any value and handle conversion automatically. Mojo uses explicit constructor-style calls: Float64(whole), String(whole). Mojo never performs implicit numeric coercion — mixing Int and Float64 in an expression without an explicit conversion is a compile error.

Mojo's String type behaves much like Python's: + concatenates strings, and len() returns the byte length. All Mojo strings are UTF-8 encoded and immutable by default, matching Python's string immutability. One key difference: Mojo's len() counts bytes, not Unicode code points, so multi-byte characters produce a larger count than Python's character-counting len().

Mojo's String type provides the same .upper() and .lower() methods as Python. Both return a new string without modifying the original — string immutability is the same in both languages. These method names were intentionally chosen to match Python's, easing the transition.

Mojo's .find() returns the byte index of the first occurrence, or -1 if not found — the same semantics as Python's str.find(). Containment is the in operator, exactly as in Python. The .replace() method replaces all occurrences, matching Python's behavior.

.strip() removes leading and trailing whitespace and .split() without arguments splits on whitespace runs — both behave identically to Python. Mojo's .split() returns a List[String] rather than Python's list, but the usage is the same: index it with [i] or iterate with a for loop.

.startswith() and .endswith() have identical names and semantics in Mojo and Python. Both return a Bool value. This is one of the areas where Mojo's Python-superset design makes the transition completely seamless — the code is character-for-character identical.

Python's int has arbitrary precision — it grows as large as memory allows. Mojo's integer types have fixed bit widths: Int8, Int16, Int32, Int64, and their unsigned counterparts (UInt8, etc.). Plain Int is machine-word-sized (64-bit on a 64-bit system). Unlike Python, Mojo integers can overflow — an Int8 holding 128 wraps in release builds and panics in debug builds.

Python's float is always IEEE 754 double-precision (64-bit). Mojo provides three floating-point types: Float16, Float32, and Float64. Floating-point literals default to Float64, matching Python's behavior. Use Float32 or Float16 to match the precision expected by GPU and SIMD hardware in machine-learning workloads — the primary domain Mojo targets.

Mojo's arithmetic operators are identical to Python's: +, -, *, // (floor division), % (modulo), and ** (exponentiation). This is intentional — Mojo is a Python superset. The difference is that Mojo resolves these at compile time when types are known, potentially emitting a single CPU instruction instead of a Python bytecode dispatch chain.

Mojo's Bool type uses the same capitalized literals (True, False) and the same English-word operators (and, or, not) as Python. This is one of the areas where the transition from Python to Mojo is effortless — the code looks identical. The difference is that Bool in Mojo is a strictly typed value, not a subclass of int as it is in Python.

Mojo's List[T] is a typed, resizable array. The literal [10, 20, 30, 40] works as in Python once the variable's element type is declared, and every element must have that type. Lists are zero-indexed like Python's, but a negative index is rejected — numbers[-1] is a compile error that suggests numbers[len(numbers) - 1].

Both loops carry over unchanged: for fruit in fruits yields each element, and enumerate() yields index-and-value pairs exactly as Python's does.

Dict[K, V] is Mojo's typed hash map. The dict literal {"Alice": 95, "Bob": 87} works as in Python once the variable declares its key and value types. Subscript access and assignment (dict["key"] = value) work identically to Python. Accessing a missing key raises an error in Mojo — use .get() for safe access with a default value.

Mojo's Dict.get(key, default) returns the value for key if present, otherwise returns default — exactly the same semantics as Python's dict.get(key, default). This is one of the many areas where Mojo's Python-superset design means existing Python knowledge transfers directly without adjustment.

Python's dict.items() yields key-value pairs in a single loop. Mojo's Dict provides .keys() and .values() iterators, but not .items() in current versions. Iterating over .keys() yields references — copy each key with String(key) before using it as a subscript argument to avoid aliasing errors from the iterator holding a reference into the dict's own memory.

Mojo's conditional syntax is identical to Python's: if, elif, else, colon-terminated conditions, and indentation-based blocks. Comparison operators (>=, ==, !=, <, >, <=) are the same as Python's. This is a zero-adjustment area for Python programmers moving to Mojo.

Mojo's range(start, stop, step) is functionally identical to Python's: stop is exclusive and the three-argument form sets the step. The for number in range(...) syntax is the same in both languages. This example is shown to confirm that Python intuition transfers completely — the code is literally identical.

Mojo's while loop syntax is identical to Python's. The only visible difference in this example is var countdown on the first line — once declared, countdown behaves exactly as in Python. Python's while/else carries over too: the else block runs when the loop ends without a break.

break and continue behave identically in Python and Mojo — no adjustment needed. This example is shown specifically to confirm that Python loop-control intuition transfers directly. The code is character-for-character identical inside def main() raises:.

Python's enumerate() carries over exactly: it yields index-and-value pairs, unpacked in the for header.

Mojo's def looks like Python's and checks what Python's does not: every parameter needs a type, a function that can raise must say raises, and both are enforced at compile time. The body uses the same return-value semantics as Python — the return keyword is required (unlike Ruby).

Default argument syntax is nearly identical between Python and Mojo's def functions — the same param: Type = default form. A call may also name its arguments, as in Python: greet(punctuation=".") keeps the default name.

Both languages return several values as a tuple and unpack it at the call site. Mojo spells the return type out — Tuple[Int, Int] — and the unpacking declares its names with var: var low, high = find_min_max(3, 7, 1).

Recursive def functions look nearly identical in Python and Mojo. The only change here is the Mojo type name Int (capital I) instead of Python's int. Both languages use the same recursive call syntax.

Mojo and Python share the def keyword and mean quite different things by it. Python's type hints are advisory and ignored at runtime — def add(x: int, y: int) still happily accepts a float. Mojo requires the annotations and enforces them: passing the wrong type is a compile error, which is what allows dispatch with no runtime type checks. (Mojo used to spell the strict form fn and keep def loose; 1.0 removed fn and made def the strict one.)

Python silently allows a function to mutate any mutable object passed to it — there is no indication at the call site or in the signature that mutation will occur. Mojo requires the mut keyword on the parameter to declare that mutation is intended. Without mut, the parameter is borrowed immutably and cannot be modified. A reader can see from the signature whether a function mutates its arguments, making the contract explicit.

In Python, any function can raise any exception at any time — nothing in the signature indicates this. A Mojo function must declare raises if it can propagate an error. This makes the error contract visible and compiler-checked. atol() is Mojo's built-in for parsing a String to Int — it raises automatically if parsing fails, which is why parse_age must also declare raises.

Mojo supports function overloading: several def definitions with the same name but different parameter types. The compiler selects the correct version at compile time based on the argument types. Python achieves similar behavior by checking isinstance() at runtime — Mojo does the same dispatch statically with no runtime cost and without the branching code in the function body.

Python's @dataclass and Mojo's @fieldwise_init both auto-generate a constructor that accepts one argument per field in declaration order. The critical difference is value semantics: assigning a Mojo struct copies it, whereas assigning a Python object copies a reference. Copyable and Movable are built-in traits that must be listed explicitly to enable copying and moving the struct.

Mojo structs use def __init__(out self, ...) for explicit constructors — the out self parameter indicates that this function initializes the struct rather than receiving a pre-allocated instance. Python's __init__(self, ...) receives an already-allocated object. Both set fields via self.field = value. Mojo field declarations (var width: Float64) must appear explicitly in the struct body before they can be assigned in __init__.

Read-only methods take self (borrowed, immutable) — matching Python's convention where self refers to the current instance. Mojo imports standard library items explicitly, as Python does, from under std: from std.math import pi. Methods are called with instance.method() and always require parentheses, even for zero-argument methods.

In Python, any method can modify instance attributes — self is always a mutable reference. Mojo requires methods that modify the struct to declare mut self instead of self. Read-only methods use plain self (borrowed). This distinction is enforced by the compiler: calling a mut self method on an immutable binding is a compile error, making mutation intent explicit in the API.

Python calls __str__ automatically when an object is passed to print(). Mojo uses the Writable trait (listed in parentheses after the struct name) with a write_to(self, mut writer) method that writes into the writer rather than returning a String. String(instance) converts the struct to a string explicitly, but print(instance) also works directly since Person conforms to Writable.

Mojo's trait keyword is the equivalent of Python's ABC with @abstractmethod. A trait declares required method signatures — structs that list the trait must implement every method, or the compiler rejects the code. Unlike Python ABCs, Mojo traits are checked at compile time with no runtime overhead. A trait may also give a method a default body, which a struct inherits unless it defines its own.

A Mojo struct implements a trait by listing it in parentheses after the struct name, alongside built-in traits like Copyable and Movable. The compiler verifies that all trait methods are implemented — unlike Python ABCs, where a class can be instantiated with abstract methods still missing and only fail at runtime when those methods are called. Multiple traits are listed together in one set of parentheses.

Mojo achieves polymorphism through parametric functions: def print_area[ShapeType: Shape](shape: ShapeType) accepts any type ShapeType that implements the Shape trait. The square-bracket [ShapeType: Shape] is a compile-time type parameter — the compiler generates a specialized version for each concrete type used, like C++ templates. Python achieves the same result through runtime duck typing. Mojo's approach produces identical behavior with zero runtime dispatch overhead.

Mojo's Comparable makes the same bargain as Python's @total_ordering: implement __lt__ and __eq__, and the other four comparisons come with the trait.

Mojo's raise Error("message") is the equivalent of Python's raise ValueError("message"). Error carries a message string and is the everyday choice; a function may instead declare a type of its own — def check(value: Int) raises TooSmall — and raise values of that struct. The function signature must include raises to declare that errors may propagate from this function.

Mojo uses the same try / except syntax as Python. The caught value in except error: has the type the called function raises — Error here. A function that declares its own error type, raises TooSmall, hands the except block a TooSmall, whose fields it can read.

When a raises function calls another raises function without a try block, the error propagates up the call stack automatically — exactly as Python exceptions propagate through uncaught call frames. Mojo's raises annotation on each function in the chain makes the propagation path compiler-verified: a function that calls a raises function must itself declare raises or wrap the call in try/except.

A Mojo struct method can combine multiple qualifiers: mut self means the method may mutate the struct, and raises means it may propagate an error. Python methods always have implicit mutation access and can raise anything — Mojo makes both properties explicit in the signature. A caller can see at a glance what a method does to state and whether it can fail.

Mojo has finally and it runs on the same paths Python's does — body succeeded, exception raised and caught, or an early return. It also has with, driven by __enter__ and __exit__ exactly as Python's context managers are. Both were measured on Mojo 1.0; older Mojo material says neither exists and points you at destructors instead. Destructors are still there and still run when a value goes out of scope, which remains the compile-time analogue of a context manager — but they are no longer the only way to guarantee cleanup.

SIMD[DType, width] is a vector type that maps directly to CPU SIMD instructions. The operation prices * 0.9 applies the discount to all four elements in a single CPU instruction instead of a loop. The width must be a power of two. This is one of Mojo's headline features for ML developers: vectorized math written with familiar operators — no NumPy import required for simple cases, no gap between the code and the machine instructions.

SIMD types support all standard arithmetic operators element-wise: +, -, *, /. The .reduce_add() method sums all elements into a scalar, equivalent to Python's sum(). On modern hardware, the four-element addition is performed in a single CPU instruction. The Python equivalent requires a list comprehension and zip() — clear and readable, but many times slower for large numerical arrays.

Square-bracket parameters like [batch_size: Int] are resolved at compile time — the compiler generates specialized code for each value of batch_size. Python determines everything at runtime: the list length, the element type, the function dispatch. Mojo's compile-time parameters allow the compiler to emit SIMD instructions of exactly the right width with no runtime branching. comptime constants serve as named compile-time values usable as type parameters.

Mojo can import and call any Python library directly via Python.import_module(). This requires a CPython installation to be available at runtime, which the servers that compile the Mojo here do not have — which is why there is nothing to run. In a full Mojo installation, this works seamlessly: you can mix Mojo's performance-critical code with the entire Python ecosystem — NumPy, pandas, scikit-learn, PyTorch — in a single file, gradually replacing hot paths with typed Mojo functions and SIMD operations.