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 fn 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. Mojo nightly has added f-string support, but the multi-argument form is used here because it works across all Mojo versions and makes it clear that no implicit type coercion is occurring.

Mojo uses # for line comments, identical to Python. Unlike Python, Mojo has no triple-quoted string literal that can double as a block comment — """...""" is not valid in fn function bodies. Use multiple 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 requires the var keyword to introduce a new variable inside an fn function body. Bare assignment to an undeclared name is a compile-time error — unlike Python, where it silently creates a new variable. 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 in fn functions 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 alias keyword creates a compile-time constant — the value is substituted at compile time and cannot be changed at runtime. Python only has a naming convention (ALL_CAPS) that other programmers are supposed to respect; nothing prevents reassignment. Mojo alias values 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(). Python's in operator for containment checking has no direct single-method equivalent in Mojo; the idiom is .find() != -1. The .replace() method replaces all occurrences, matching Python's behaviour.

.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 behaviour. 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. Unlike Python's heterogeneous list literal syntax ([10, 20, 30]), Mojo requires an explicit type parameter and construction via .append(). Lists are zero-indexed like Python's, but Mojo does not support negative indices — use len(list) - 1 for the last element instead of list[-1].

Mojo does not yet have a built-in enumerate() equivalent for List. The standard idiom is range(len(collection)) with subscript access. Subscript access (fruits[index]) returns the value directly. Python's for fruit in fruits loop is cleaner — Mojo's syntax is currently more verbose for indexed iteration but gains nothing in ergonomics over index-based access.

Dict[K, V] is Mojo's typed hash map. Unlike Python's dict literal syntax ({"Alice": 95}), Mojo requires explicit construction and type parameters for both key and value. 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. Mojo does not support Python's while/else construct.

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 fn main() raises:.

Python's enumerate() elegantly yields both the index and value in one expression. Mojo does not have an equivalent of enumerate() for List in current versions — the idiomatic approach is range(len(collection)) with subscript access. This is a place where Python is genuinely more ergonomic; Mojo prioritises compile-time efficiency over iteration convenience.

Mojo's def keyword works like Python's: functions are flexible, can raise errors without declaring it, and behave dynamically. Adding type annotations (name: String, -> String) is optional in a def function but provides documentation and enables compile-time checks. 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. Unlike Python, Mojo def functions do not support calling arguments by keyword name (e.g., greet(punctuation=".") would not work in current versions) — arguments must be passed positionally.

Python returns multiple values as a tuple that can be destructured with low, high = .... Mojo uses an explicit Tuple[T1, T2] return type and elements are accessed by index (result[0]). Mojo does not yet support automatic tuple destructuring in assignment, so the Python idiom of low, high = find_min_max(...) is not valid syntax.

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 does not perform tail-call optimisation, and the stack size is limited by the OS rather than Python's configurable recursion limit.

Mojo's fn keyword defines a strict function: all parameters and the return type must have explicit type annotations, and the compiler enforces them. Python's type hints on def are advisory and ignored at runtime — a def add(x: int, y: int) still happily accepts a float. An fn function that receives the wrong type is a compile error, enabling zero-cost dispatch without dynamic type checks at runtime.

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. Mojo's fn functions must declare raises in their signature if they 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: multiple fn 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 behaviour 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 fn __init__(out self, ...) for explicit constructors — the out self parameter indicates that this function initialises 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 with from math import pi, the same as Python. Methods are called with instance.method() and always require parentheses, even for zero-argument methods. Unlike Python, Mojo does not have a @property decorator equivalent in current versions.

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 requires implementing the Stringable trait (listed in parentheses after the struct name) and then calling String(instance) explicitly to invoke __str__. The method name __str__ is the same in both languages. Mojo's explicit conversion is more verbose but makes it clear that a conversion is happening.

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. Current Mojo versions cannot provide default implementations inside a trait (no equivalent of @classmethod or mixin methods).

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: fn 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 specialised version for each concrete type used, like C++ templates. Python achieves the same result through runtime duck typing. Mojo's approach produces identical behaviour with zero runtime dispatch overhead.

Python's @total_ordering fills in five comparison methods from just __eq__ and one other. Mojo's Comparable trait requires all six comparison dunder methods to be implemented explicitly — there is no automatic derivation. This is more verbose, but each method is straightforward to write and the compiler verifies that none are missing.

Mojo's raise Error("message") is the equivalent of Python's raise ValueError("message"). Unlike Python's rich hierarchy of exception types (ValueError, TypeError, RuntimeError, etc.), Mojo has a single Error type that carries a message string. 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: is of type Error. Unlike Python, Mojo cannot catch specific error subtypes — there is only one Error type, so except ZeroDivisionError-style filtering is not available. All raised errors are caught by a bare except error: clause.

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 does not have a finally clause or a with statement equivalent in current versions. Cleanup logic that must run regardless of success or failure is managed through Mojo's lifetime system: when a value goes out of scope, its fn __del__(owned self) destructor is called automatically — even if an error propagated. This is the compile-time analogue of Python's context manager protocol.

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: vectorised 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 specialised 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. alias 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 — it is not available in the Compiler Explorer sandbox, so this example is marked as non-runnable here. 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 fn functions and SIMD operations.