Python.CodeCompared.To/Go

Both print() and fmt.Println() append a trailing newline. Every standalone Go program requires a package main declaration and a func main() entry point — the runner adds this boilerplate automatically. There is no Go script mode.

fmt.Println is the direct counterpart to Python's print() — it adds spaces between arguments and appends a newline. fmt.Print omits the trailing newline, like print(..., end=""). Unlike Python, Go's fmt.Print only adds spaces between adjacent non-string arguments.

Python's f-strings embed expressions directly: f"{value:.2f}". Go uses C-style format verbs: %s for strings, %d for integers, %f for floats. The \n must be written explicitly — fmt.Printf does not add a trailing newline automatically.

fmt.Sprintf is the Go equivalent of Python's f-string when you need to store a formatted string rather than print it immediately. It returns a string instead of writing to stdout. The format verbs are the same as fmt.Printf.

Go uses C-style // for line comments and /* */ for block comments. The go doc tool extracts documentation from // comments immediately preceding a declaration; by convention, every exported identifier begins its doc comment with the identifier's name.

Go's := declares a new variable and infers its type from the right-hand side — the rough equivalent of Python's assignment. The key difference: the type is fixed at declaration and cannot change. Python's True/False become true/false (lowercase) in Go.

Python type hints are documentation only — the interpreter ignores them at runtime. Go's var declarations are enforced by the compiler: a type mismatch is a compile error. The := shorthand is preferred inside functions; var is used at package level or when the zero value is the intended starting value.

Every Go variable has a zero value — the natural empty state for its type. There is no None for value types (integers, structs, booleans). A zero-value struct is fully usable with no constructor call. A nil slice behaves identically to an empty slice for all built-in operations.

Go's const is enforced by the compiler — reassigning a constant is a compile error. Go uses UpperCamelCase for exported constants and lowerCamelCase for package-private ones; the Python ALL_CAPS convention is not used in idiomatic Go.

Go supports multiple assignment with the same a, b = b, a swap idiom as Python. Use := when declaring new variables and = when reassigning existing ones. If at least one variable on the left is new, := is allowed even when others already exist.

Go requires explicit conversion between all numeric types — there is no implicit widening or narrowing. The target type name is used as a function: float64(x), int(y). For string-to-number and number-to-string conversions, use the strconv package (strconv.Atoi, strconv.ParseFloat, strconv.Itoa).

Go strings are sequences of bytes, not characters. For pure ASCII text, len() and indexing behave identically to Python. For Unicode text, len() returns the byte count and indexing returns a byte — use []rune(greeting) or range iteration for character-level access.

Go's fmt.Sprintf covers the same ground as Python's f-strings but uses positional format verbs rather than embedded expressions. The literal percent sign must be escaped as %% in Go format strings. Common verbs: %s (string), %d (integer), %f/%.2f (float), %v (any value), %T (type name).

Go uses backtick-delimited raw string literals for multi-line strings. They behave exactly like Python's triple-quoted strings: no escape sequences are processed, and all whitespace including newlines is preserved literally. Backtick strings cannot contain a backtick character; use "..." strings with \n in that case.

Python string methods are called on the string object itself (text.upper()). Go's string manipulation lives in the strings package as standalone functions (strings.ToUpper(text)). The behavior is equivalent, but you must import "strings" explicitly. The runner handles this import automatically.

Python's in operator has no direct Go counterpart — use strings.Contains. Python's startswith/endswith become strings.HasPrefix/strings.HasSuffix. strings.Index returns the byte offset of the first occurrence, or -1 if not found.

Go's len() on a string returns the byte count; utf8.RuneCountInString returns the Unicode character count. Iterating a string with range correctly decodes UTF-8 and yields Unicode code points (type rune, an alias for int32) — not raw bytes. Python strings are always character sequences, so this distinction does not arise.

Python requires // for integer division and / for float division. Go uses / for both — when both operands are integers, the result is an integer (truncated toward zero). To get a float result from integer operands, convert first: float64(x) / float64(y).

Python has one floating-point type (float, IEEE 754 double precision). Go has float32 and float64; untyped float literals default to float64. Use math.Round() for rounding to a specific precision, or fmt.Sprintf("%.1f") to produce a rounded string representation.

Go requires an explicit conversion expression for every numeric type change — there is no implicit narrowing or widening even between int and int64. The target type is written as a function call: float64(value), int(value). Python applies many of these conversions automatically in arithmetic contexts.

Python integers grow arbitrarily large with no overflow. Go's integer types are fixed-width (int is 32 or 64 bits depending on the platform); overflow wraps around silently. For numbers larger than 64 bits, use the math/big package, which provides arbitrary-precision integer arithmetic similar to Python's built-in behavior.

Go slice literals look like Python list literals but require an explicit element type prefix: []int{...}, []string{...}. The type is not inferred from the values — it must be stated. A slice is a view over an underlying array; unlike Python lists, slices are not self-contained dynamic arrays.

Python's list.append() mutates the list in place. Go's append() is a built-in function that returns a new (possibly reallocated) slice — you must assign the result back: items = append(items, value). Forgetting to reassign is a common mistake; the original slice header is not modified.

Go slice syntax is identical to Python's [start:stop], but Go has no negative indexing. To access the last element, use slice[len(slice)-1]. A Go slice expression creates a view into the underlying array — modifying a sub-slice modifies the original data, unlike Python's list slicing which copies.

Go's range always yields both index and element. Use _ to discard the index when only the value is needed. Python requires a separate enumerate() call to get the index; in Go, range always provides it — discarding is opt-in.

make([]T, length) allocates a slice pre-filled with zero values, equivalent to Python's [0] * n. An optional third argument specifies capacity: make([]T, 0, 100) creates an empty slice that can hold 100 elements before reallocation. Use make when the final length is known up front to avoid repeated copies during growth.

Go slices expose both length (elements currently in use) and capacity (total allocated space before a reallocation is needed). Python lists expose only len(); capacity management is entirely internal. In Go, knowing the capacity lets you pre-allocate with make([]T, 0, expectedSize) to avoid repeated allocations during growth.

Go map literals require explicit key and value types: map[KeyType]ValueType{...}. All keys must be the same type and all values must be the same type. For mixed-value maps (like Python dicts), use map[string]any where any is an alias for interface{} — this trades compile-time type safety for flexibility.

Accessing a missing key in a Go map returns the zero value for the value type (empty string, 0, false) rather than panicking. Use the two-value assignment value, ok := map[key] to check whether the key was actually present. This "comma-ok" idiom is the idiomatic Go equivalent of Python's dict.get(key, default).

delete(map, key) is a built-in function that removes a key. Python's del dict[key] does the same thing. Both operations are safe on a missing key — no error is raised. There is no pop() method in Go; use delete after reading the value if you need it.

Go map iteration order is deliberately randomized on each run — the language specification guarantees instability. Python dicts maintain insertion order since Python 3.7. If you need sorted output in Go, collect the keys into a slice, sort it with sort.Strings(), then iterate the sorted keys.

Go's else if corresponds to Python's elif. Parentheses around the condition are optional and conventionally omitted. The curly braces are mandatory even for single-line bodies — there is no one-liner if. Go also has no ternary operator (x if cond else y); use a full if/else block.

Go's switch does not fall through by default (unlike C/Java), which makes it safer than C. Multiple match values in one case are comma-separated. The default clause corresponds to Python's case _. Go's switch predates Python's match statement and is the idiomatic way to replace long if/else if chains.

A switch with no expression evaluates each case as an independent boolean condition and runs the first true one. This is often cleaner than a long if/else if chain when the cases share no common base expression.

Go's if supports an optional initialization expression before the condition, separated by a semicolon. Variables declared there are scoped to the entire if/else block and unavailable afterward. This is the idiomatic Go pattern for error-returning functions whose result is only needed inside the block.

Go's range clause on a slice always yields both index and element. When only the element is needed, discard the index with _. Go has only one loop keyword — for — which covers Python's for, while, and the C-style three-part counting loop.

Python requires a separate enumerate() call to get the index alongside the value. In Go, range always provides the index; discarding it with _ is opt-in. This means Go's range naturally replaces both for item in collection and for index, item in enumerate(collection).

Go has no while keyword. A for loop with only a condition behaves exactly like Python's while. The ++ increment is a statement in Go (not an expression), so x = count++ is invalid — use count++ alone on its own line.

Python's range(n) produces 0..n-1. Go uses the classic three-part C-style loop: initialization, condition, post-statement. There is no range(n) shorthand for integers in Go. For a counting loop over a slice, prefer for index := range slice which is slightly shorter.

Python's range(start, stop, step) has no direct Go equivalent. Use the three-part for loop with a custom increment in the post-statement. Negative steps (counting down) also use this form: for i := 10; i >= 0; i-- {}.

break and continue work identically in Go and Python. Go also supports labeled break and continue to target an outer loop — useful for breaking out of nested loops without a sentinel variable.

A bare for {} is Go's infinite loop — the equivalent of Python's while True:. Use break to exit. This pattern is common in Go servers and background workers where the loop is intentionally endless.

Go lists parameter types after the parameter name, and return types appear after the closing parenthesis. Unlike Python, all parameter types must be explicitly declared — type inference does not apply to function signatures. Adjacent parameters of the same type can share a type annotation: func add(a, b int) int.

Go does not support default argument values. The idiomatic workarounds are: providing multiple functions for simple overloads (as shown here), using an options struct for complex APIs, or accepting variadic functional options. This is a deliberate design choice — Go favors explicit call sites over implicit defaults.

Go has native multiple return values as a language feature — no tuple packing or unpacking needed. Python achieves the same effect by returning a tuple. Multiple returns are the standard Go idiom for returning both a result and an error: return value, nil on success, return zero, err on failure.

Go's variadic parameter (...T) is equivalent to Python's *args. Inside the function, the parameter is a []T slice. To pass an existing slice where a variadic argument is expected, spread it with the ... suffix: total(mySlice...).

defer schedules a function call to execute when the surrounding function returns, regardless of how it returns (normal return or panic). Multiple deferred calls execute in last-in, first-out order. The canonical use is resource cleanup: defer file.Close() immediately after opening — similar to Python's with statement but scoped to the function rather than a block.

Go closures capture variables by reference, just like Python's closures. Python requires the nonlocal keyword to modify a captured variable from an enclosing scope; Go has no such requirement — any captured variable can be read or written directly. The captured count is shared between all closures returned by makeCounter.

Go has no built-in map(), filter(), or list comprehensions. The idiomatic Go approach uses explicit for loops — more verbose but transparent. The slices package (Go 1.21+) provides some generic helpers. Writing custom higher-order functions using generics is straightforward when needed.

Functions are first-class values in Go, as in Python. A function type is written as func(ParameterTypes) ReturnType. Go's anonymous functions (written func(...) { ... }) can contain any statements, not just a single expression — they are more powerful than Python's lambda, which is limited to one expression.

Go structs serve the role of Python dataclasses for simple data holders. Fields beginning with an uppercase letter are exported (accessible outside the package). There is no __init__ — struct literal syntax initializes fields by name. Methods are declared separately outside the struct body.

Go methods are declared outside the struct body using a receiver parameter: func (rect Rectangle) Area(). The receiver (rect) plays the same role as Python's self. Implementing String() string is the Go equivalent of Python's __str__ — fmt.Println calls it automatically.

Python's self is always a reference — mutating self.value changes the original object. In Go, a value receiver (rect Rectangle) receives a copy. To mutate the original struct, use a pointer receiver (counter *Counter). &Counter{} creates a pointer to a new zero-value Counter.

Go has no constructor syntax. The idiomatic pattern is a New() function that returns a pointer to a new, initialized value. Callers may also use struct literal syntax directly when no special initialization logic is needed. The New prefix is a Go convention, not a language feature.

Go uses embedding rather than classical inheritance. Embedding a type by name (without a field label) promotes the embedded type's fields and methods to the outer struct. Go deliberately lacks a class hierarchy — composition is the primary code reuse mechanism. There is no super() call; you access the embedded type directly: dog.Animal.Describe().

Go interfaces are satisfied implicitly — there is no implements keyword and no ABC registration. Any type providing the required methods satisfies the interface. Python's abstract base classes require explicit class Foo(ABC) registration and decorator syntax; Go's approach is enforced at compile time with no boilerplate.

A []Shape slice can hold any value whose type satisfies the Shape interface. This is equivalent to Python's duck typing — if it has the methods, it qualifies — but checked at compile time. A missing method on any type in the slice is a compile error, not a runtime AttributeError.

any (an alias for interface{}) is Go's escape hatch from the static type system. Values stored as any lose their specific compile-time type. Python's dynamic typing makes every variable implicitly any; in Go, any should be used sparingly — only when the type is genuinely unknown at compile time. The %T verb prints the runtime type.

Go uses error return values instead of exceptions. Functions that can fail return (result, error); the caller checks err != nil. This makes error paths explicit and visible at every call site — there is no hidden exception propagation. Python's raise/except allows errors to propagate silently; Go's approach requires explicit handling at each level.

fmt.Errorf("context: %w", err) wraps an error with additional context. The %w verb preserves the original error so callers can use errors.Is() to match specific errors and errors.As() to extract specific error types from the chain. Python uses raise ... from for the same chaining purpose.

A Go type implements the error interface by providing an Error() string method — there is no base class to extend. Use errors.As(err, &target) to type-assert an error to a specific custom type. This corresponds to Python's except CustomError as error, but without the exception hierarchy.

Goroutines start at ~2 KB of stack and are multiplexed across OS threads by the Go runtime. Python threads map 1:1 to OS threads and are limited by the GIL for CPU-bound work. sync.WaitGroup waits for all goroutines to finish, like thread.join(). Pass the loop variable as an argument to the goroutine to avoid capturing it by reference.

Go channels are typed, first-class values for communication between goroutines — similar in purpose to Python's queue.Queue but built into the language. The <- operator sends to a channel (left of chan) and receives from one (right of chan). An unbuffered channel synchronizes sender and receiver — the sender blocks until the receiver is ready.

Python's threading.Lock is typically used as a context manager (with lock:). Go's sync.Mutex requires explicit Lock()/Unlock() calls; pairing Unlock() with defer ensures the lock is released even if the method panics. Note that Python's GIL already prevents concurrent bytecode execution — a Lock in Python is needed for atomicity of compound operations, not raw memory safety.

Go imports entire packages by their import path; the package name (last component of the path) becomes the qualifier. All imports are declared at the top of the file and are enforced by the compiler — an unused import is a compile error (unlike Python where it is only a style warning). The runner adds import declarations automatically based on the packages you use.

Go's visibility rule is simple and compiler-enforced: any identifier starting with an uppercase letter is exported; lowercase means package-private. Python's _ prefix convention is respected by tools like linters and IDEs but not enforced by the interpreter — any code can still access module._private_thing. In Go, external packages cannot even refer to an unexported name at compile time.

Go package-level variables are initialized in declaration order; init() runs after all variables are initialized, before main(). A package may have multiple init() functions — they run in source order. Unlike Python module-level code, init() cannot be called directly. The _ import (import _ "pkg") triggers a package's init() for side effects only.