Go.CodeCompared.To/Python

Python needs no package clause, no import, and no main function — top-level code runs the moment the file is loaded. print is a built-in function (not a statement) and adds a newline like fmt.Println. There is no compile step at all: the interpreter parses and runs the script directly.

Python is interpreted: there is no go build and no compiled binary to ship — the Python interpreter must be present wherever the script runs. python3 file.py runs in one step, and the bare python3 command opens a REPL for quick experiments, which Go has no built-in equivalent for.

Python's f-strings interpolate any expression inline: f"{name} {version:.2f}" embeds variables and applies a format spec after the colon. It replaces Go's Printf verbs, and because print already adds a newline you rarely write \n. The format mini-language (:.2f, :>10, :,) covers what Go's % verbs do.

Python uses # for comments and has no /* ... */ block form. For multi-line notes the convention is a triple-quoted string, which doubles as a docstring when placed at the top of a module, function, or class — accessible at runtime via __doc__, something Go comments cannot do.

Python has no :=, no var, and no type annotations are required — a variable exists once you assign to it and can later hold a value of any type. There is no "declared but not used" error as in Go, so an unused variable is legal. Note the capitalised True/False/None.

Go gives every declared variable a typed zero value. Python has a single None for "no value" and no concept of an uninitialised-but-typed variable — reading a name you never assigned raises NameError rather than yielding a zero. There is no implicit empty string or zero integer; you assign one explicitly if you want it.

In Go a variable has one type for its whole life. In Python a name is just a binding to an object, so the same name can refer to an int and later a str. Types live on the values, not the names — type(value) inspects the object. Optional type hints (value: int = 42) document intent but are not enforced at runtime.

Both languages support parallel assignment and the tuple swap first, second = second, first with no temporary. Python goes further with unpacking: head, *rest = [...] binds the first element and gathers the remainder into a list, and the same star works on the right-hand side to spread an iterable into arguments.

Python strings are immutable objects with many methods, and len() counts characters, not bytes (a Python str is a sequence of Unicode code points, unlike Go's byte-oriented string). The + operator concatenates and * repeats — "ab" * 3 is "ababab", which Go has no operator for.

An f-string interpolates any expression inside {...}, so f"{name}" replaces Go's positional Sprintf verbs entirely. Format specs come after a colon ({value:.2f}), and the trailing-= form f"{count * 2 = }" prints both the expression and its value — handy for debugging.

Python calls these as methods on the string itself rather than passing it to a strings package function. Membership uses the in operator — "quick" in sentence — instead of a Contains call, and in works the same way for lists, dicts, and sets, making it a general containment test.

Python slicing is far richer than Go's. Negative indices count from the end (text[-1] is the last character), and the full form text[start:stop:step] adds a step, so text[::-1] reverses a sequence. The same slice syntax works on lists and tuples, and going out of bounds yields an empty slice instead of panicking.

A Go int is a fixed 64-bit value that overflows silently, so large integers need the math/big package and its method-based arithmetic. Python's int is arbitrary precision by default — 2 ** 100 just works and stays an ordinary int, with the exponent operator ** built into the language.

A surprise for Go programmers: Python's / always produces a float, even for two integers, so 7 / 2 is 3.5. Integer (floor) division is the separate // operator. Python also has the built-in exponent operator **, where Go requires math.Pow and a float result.

Go has sized integer types (int8, uint64) that wrap on overflow. Python has a single int type with no fixed width and no overflow — it simply grows to hold any value. The cost is that Python numbers are heap-allocated objects rather than machine words, so heavy numeric code reaches for libraries like NumPy.

A Python list is the everyday growable sequence, like a Go slice, but it can hold mixed types and grows in place with append (no reassignment as Go's append needs). len() is a built-in function rather than a method, and there is no separate fixed-array vs slice distinction — one type does both.

Python's for iterates the elements directly, and enumerate() pairs each with its index — the equivalent of Go's for index, value := range. To loop a fixed number of times use for index in range(n). There is no C-style counter loop; iteration is always over an iterable.

The built-in sorted() returns a new sorted list (use list.sort() to sort in place). A custom order is given by a key function that maps each element to its sort key — key=len sorts by length — which is terser than Go's comparator and, like Go's sort.Slice, computes the key per element.

A Python tuple is an immutable, ordered group of values written with parentheses — there is no Go equivalent, which uses an anonymous struct or multiple return values instead. Tuples are commonly used for fixed records and as dict keys (lists cannot be keys because they are mutable), and they unpack just like multiple assignment.

A Python dict is the counterpart to a Go map, written with braces and colons. Since Python 3.7 a dict preserves insertion order when iterated, whereas Go deliberately randomises map order. Removal uses the del statement rather than a delete built-in, and keys may be any hashable value, not one declared type.

Indexing a missing key with inventory["bananas"] raises KeyError in Python, unlike Go's comma-ok which returns a zero value. The idiomatic way to supply a fallback is dict.get(key, default), and the in operator tests membership — replacing Go's value, ok := m[key] with two clearer, single-purpose tools.

Iterating a dict directly yields its keys, so to get key and value together you call .items() — the parallel to Go's range over a map, but explicit. .keys() and .values() return live views you can wrap in list(). The iteration order is the insertion order, which Go does not guarantee.

Python uses indentation and a colon instead of braces, and the keyword is elif (not else if). There are no parentheses around the condition. Indentation is significant: the block is defined by its level, so consistent spacing is part of the syntax rather than a style choice as in Go.

Go permits only a genuine bool in a condition. Python treats many values as "falsy" — 0, "", None, and empty containers ([], {}) all count as false — so if not names idiomatically tests for an empty list. This is concise but a trap for Go programmers used to explicit comparisons.

Python's match (added in 3.10) is the analogue of Go's switch but is a structural pattern match: "start" | "go" is an or-pattern, case _ is the wildcard, and patterns can also destructure lists, tuples, and objects by shape. For a simple value test it reads much like Go's comma-separated cases, with no fall-through.

Python keeps a distinct while (which Go folds into for) and uses for x in range(n) for counting loops — range(3) is a lazy sequence 0, 1, 2. Python loops also support an else clause that runs only if the loop finished without break, a feature Go has no equivalent for.

A Python def needs no parameter types and no return type. The body is an indented block, and a function with no return implicitly returns None. Type hints (def greet(name: str) -> str:) are optional documentation that tools check but the interpreter ignores at runtime.

Python supports default values and named keyword arguments, both of which Go omits. A parameter with a default (port=5432) is optional, and callers may pass any argument by name in any order (secure=True), which removes the long positional argument lists Go forces. Beware: a mutable default like [] is shared across calls — use None and create it inside.

Python's *numbers gathers extra positional arguments into a tuple — the analogue of Go's ...int. It also has **fields, which collects arbitrary keyword arguments into a dict, something Go has no equivalent for. Both stars also work at the call site to spread a list or dict into arguments: sum_all(*[1, 2, 3]).

Python "multiple return" is really returning a single tuple that the caller unpacks — low, high = min_max(...). It looks like Go's multiple return values but is one object under the hood, which is why you can also capture it whole (result = min_max(...)) and index it. The built-ins min and max save the manual loop entirely.

A list comprehension builds a list in a single expression: [expr for item in iterable if condition]. It replaces the explicit map-and-filter loop Go must write out, reads close to the mathematical "set of squares where…", and is the single most characteristic piece of idiomatic Python. The whole loop above collapses to one line.

The comprehension form extends to dicts ({key: value for ...}) and sets ({value for ...}). Each builds the whole collection in one expression where Go needs a loop with explicit insertion. A set is Python's built-in unordered collection of unique values — Go has no native set type and emulates one with a map[T]bool.

Writing the comprehension with parentheses instead of brackets produces a generator — a lazy iterator that yields one value at a time instead of building a whole list in memory. Passed straight to sum() (or max, any, all), it computes the result with no intermediate allocation, the Python equivalent of a streaming fold.

Python has real classes, which Go lacks entirely. State lives in instance attributes set on self inside the __init__ constructor, and self is an explicit first parameter on every method (there is no implicit receiver). Construction is just calling the class — Point(1, 2) — with no new keyword.

Python has classical inheritance — class Dog(Animal) — including method overriding and super() to call the parent's version, plus multiple inheritance. Go deliberately omits inheritance and composes behaviour by embedding one struct in another. This "is-a" hierarchy is one of the biggest conceptual additions Python brings over Go's flat composition.

Python lets a class hook into language operators through "dunder" (double-underscore) methods: __add__ makes + work, __repr__ controls how the object prints, __eq__ defines ==, __len__ enables len(). Go has no operator overloading at all, so equivalent behaviour is always a named method call like .Add(...).

The @dataclass decorator auto-generates __init__, __repr__, and __eq__ from the field annotations — the closest Python comes to a Go struct that compares field-by-field and prints cleanly. Without it, a plain class compares by identity (is), so two equal-looking objects are not == unless you define __eq__ yourself.

Go has structural interfaces: a type satisfies Speaker by having a Speak method, checked at compile time. Python drops the declaration entirely — announce just calls .speak(), and any object that happens to have that method works. "If it walks like a duck and quacks like a duck," with errors surfacing at runtime rather than compile time.

Go inspects a dynamic type with a type switch on an any value. Python uses isinstance(value, Type), which also respects inheritance (a subclass instance passes its parent's check). Idiomatic Python often prefers to skip the check entirely and simply attempt the operation, catching the exception if the object does not support it ("easier to ask forgiveness than permission").

This is the deepest difference for a Go programmer. Go returns errors as values you check after every call; Python raises exceptions that unwind the stack until a try/except catches them. The happy path stays free of if err != nil, and an unhandled exception propagates automatically with a full traceback rather than being silently ignorable.

Python's finally block plays the role of Go's defer: it runs whether the try body succeeds or raises. You can also pair multiple except clauses for different exception types and an else that runs only on success. Unlike defer, it is attached to a try block rather than scheduled per statement.

A custom Python exception is a class that inherits from Exception — often just pass for the body. except then matches it by class, and because exceptions form a hierarchy you can catch a whole family at once (catching Exception catches everything below it). Go's custom errors are any value implementing Error() string, matched by type assertion instead.

A with block uses a context manager to guarantee setup and teardown: __enter__ runs on entry and __exit__ always runs on exit, even if an exception is raised. It is Python's structured answer to Go's defer file.Close() — the canonical use is with open(path) as file:, which closes the file automatically when the block ends.

A function containing yield is a generator: calling it returns a lazy iterator that produces values one at a time, suspending and resuming at each yield. It computes on demand with no full list in memory — ideal for large or infinite sequences. Go's closest equivalent is the range-over-func iterator added in 1.23, but generators are far more concise.

zip() walks several iterables in lockstep, yielding tuples of corresponding elements — so you iterate two parallel lists without index bookkeeping. Combined with enumerate() (value plus index) and unpacking, these built-ins replace the manual index loops Go writes. zip stops at the shortest input.

Any Python object becomes iterable by implementing __iter__ (return the iterator) and __next__ (return the next value or raise StopIteration). The for loop, comprehensions, and list() all speak this protocol, so a custom class drops straight into them. Go has no such object protocol; iteration is a language built-in tied to range.

Python's threading mirrors Go's goroutines in shape — start workers, then join them — but a caution for Go programmers: the standard CPython interpreter has a Global Interpreter Lock, so threads do not run pure-Python code in parallel. They help with I/O-bound work, not CPU-bound; for true parallelism Python uses multiprocessing or releases the lock in C extensions.

Go's goroutines are scheduled by the runtime and look synchronous; Python instead has explicit async/await with an event loop you launch via asyncio.run. Functions must be declared async to be awaited, and asyncio.gather runs several concurrently. This colours functions "async" in a way Go avoids — every goroutine is just a function with go in front.

Go's channels are a language primitive for passing values between goroutines. Python's nearest equivalent is queue.Queue from the standard library, a thread-safe FIFO: producers put and consumers get (which blocks until an item is available). There is no select statement and no language-level channel — communication is a library facility, not syntax.

A decorator is syntactic sugar for wrapping a function: @logged above def double means double = logged(double). It is the same higher-order-function idea Go can express manually, but the @ syntax applies it declaratively at definition time. Built-in decorators like @staticmethod, @property, and @dataclass are everywhere in idiomatic Python.

Python's import math brings in a module accessed as math.sqrt, while from module import name pulls a single name into scope. Every .py file is a module, and packages are directories — there is no go.mod; third-party libraries come from PyPI via pip. Crucially, Python's vast standard library and package ecosystem are a major draw over Go's leaner standard set.

In Python everything is a first-class object — functions, classes, modules, and even integers all have attributes and methods and can be stored in data structures. You can put functions in a dict and call them by key, ask an int for its bit_length(), or read a function's __name__. Go has first-class functions but no uniform object model: an int has no methods and a type is not a value.