C#.CodeCompared.To/Python

Python's print() is a built-in function — no using, no class, no Main. It adds a newline by default, just like Console.WriteLine. The entire program is that one line.

Python is interpreted — there is no compile step and no binary to ship. python3 file.py runs the script directly. The bare python3 command opens an interactive REPL for experimentation, which has no C# built-in equivalent (though dotnet-script offers something similar).

Python f-strings use the same {expression:format_spec} syntax as C# interpolated strings. :.2f in Python corresponds to :F2 in C#. print always adds a newline; pass end="" to suppress it, replacing Console.Write.

Python uses # for all comments. There is no block comment syntax — use a run of # lines for multi-line comments. Triple-quoted strings ("""...""") are sometimes used as multi-line comments but are technically string literals and do generate a bytecode object, so they are not true comments.

Python variables need no declaration keyword — just assign. There is no var, int, or string annotation (those come from type hints, which are optional). Boolean literals are True and False (capitalized), not true/false.

Python is dynamically typed — a variable holds any object and can be reassigned to a different type freely. type(x).__name__ is the runtime equivalent of x.GetType().Name. In C#, a variable's type is fixed at declaration; assigning a different type requires object or a cast.

Python has no const keyword. The convention is to name module-level constants in ALL_CAPS; nothing in the language enforces immutability. For truly immutable values in a class, use a property with no setter. The Final annotation from typing signals intent to type checkers but is not enforced at runtime.

Python has one null-like value: None. The idiomatic check is x is None (identity), not x == None (equality), because a class could override __eq__. There is no ?. null-conditional operator; write an explicit if ... is not None guard. Python raises AttributeError on None.something, analogous to C#'s NullReferenceException.

Python f-strings (f"...") mirror C# interpolated strings ($"..."). Format specs go after a colon inside the braces: {value:,.2f} in Python vs {value:N2} in C#. Both support arbitrary expressions in the braces, including method calls and ternary operators. Numeric literals can use underscores as digit separators in both languages.

Python string methods are mostly lower_snake_case: strip/lstrip/rstrip for Trim/TrimStart/TrimEnd, upper/lower for ToUpper/ToLower, replace for Replace. Containment is checked with the in operator ("ell" in "hello") rather than a method call.

The biggest API flip: in Python, join is a method on the separator string (sep.join(items)), while in C# it is a static method that takes the separator first (string.Join(sep, items)). Both split on a string delimiter and produce a list/array.

Both languages use triple-quoted strings for multiline literals. C# raw string literals ("""...""", C# 11+) strip the common indentation prefix automatically. Python's triple-quoted strings preserve leading whitespace exactly as written, so use .strip() or textwrap.dedent() to clean it up.

Python has two built-in numeric types: int (arbitrary precision — never overflows) and float (64-bit IEEE 754). There is no long, double, or decimal keyword. For exact decimal arithmetic import decimal.Decimal, which corresponds to C#'s decimal type.

This is a key difference: in C#, 10 / 3 is 3 (integer division) when both operands are integers. In Python, / always returns a float — 10 / 3 is 3.3333.... Use // (floor division) for integer truncation in Python.

Python's abs() and round() are built-in functions (no import). math.sqrt() and other transcendentals are in the math module. The ** operator replaces Math.Pow — 2 ** 10 is idiomatic Python where C# writes Math.Pow(2, 10).

Python lists are equivalent to List<T> in C# but untyped — they can hold mixed types. append() corresponds to Add(), and the built-in len() replaces the .Count property. Index access is identical: items[0] for first, items[-1] for last (Python bonus).

Common list operations map closely: remove(value) for Remove(value), insert(index, value) for Insert(index, value), pop() for RemoveAt(Count-1). Python also has extend(other_list) (like AddRange) and sort() which sorts in-place (while LINQ's OrderBy returns a new sequence).

Python's slice syntax [start:stop:step] is a core language feature: [:3] for first 3, [-2:] for last 2, [1:4] for a middle range. Stop index is exclusive, matching Take(count) semantics. C# achieves the same with LINQ's Skip/Take/TakeLast or the ..^ range operator.

Python tuples are immutable sequences: (1, "Alice"). Elements are accessed by index (person[0]) unless you unpack them into named variables (id, name = person). C# value tuples support named fields (person.Id) and the same destructuring syntax. Both languages treat single-element tuples specially — in Python, a trailing comma is required: (42,).

Python dicts use {"key": value} literal syntax. Access is identical (dict["key"]), and missing keys raise KeyError just as C# raises KeyNotFoundException. len(dict) replaces .Count. Python dicts preserve insertion order (guaranteed since Python 3.7), matching C#'s Dictionary behavior from .NET 5+.

dict.get(key, default) returns the default if the key is absent, mirroring GetValueOrDefault. Membership is checked with "key" in dict (the in operator), not a ContainsKey method call. Python also has dict.setdefault(key, value) which inserts and returns the default if the key is absent — handy for building nested structures.

Iterating a Python dict by default yields keys only (like C#'s foreach (var k in dict)). Use dict.items() to get key-value pairs, dict.keys() for just keys, and dict.values() for just values — mirroring C#'s .Keys and .Values properties.

Python 3.9 introduced the | merge operator for dicts — the right operand wins on key conflicts. The in-place version (defaults |= overrides) updates in place. Before Python 3.9, the idiom was {**defaults, **overrides}. C# has no single built-in dict-merge operator; the common approach concatenates with LINQ and resolves duplicates.

Python uses significant indentation to define blocks (no braces), a colon after each header line, and elif (not else if) for chained conditions. Parentheses around the condition are not needed. Boolean operators are spelled out: and, or, not instead of &&, ||, !.

Python has no C-style for (init; condition; step) loop. Use range(stop) for a count, range(start, stop) for a range, and range(start, stop, step) for a step. range objects are lazy — they do not create a list in memory. print(end="") suppresses the newline, mimicking Console.Write.

Python's for item in iterable directly mirrors C#'s foreach. enumerate(items) gives index-value pairs like items.Select((item, i) => (i, item)): for i, fruit in enumerate(fruits). Any iterable — list, string, dict, file, generator — works with for.

Python's while loop is syntactically identical to C#'s except for the colon and indentation. Python has no do-while loop — use while True: ... if condition: break to emulate one. Python also has no ++ or -- operators; use += 1 / -= 1.

Python's match statement (added in Python 3.10) matches the C# switch expression concept. Both support a wildcard (_) default arm. Python's structural pattern matching goes further than C#'s switch — it can destructure sequences, dicts, and class instances in patterns, similar to C# 11+ pattern matching but as a first-class statement.

Python functions are defined with def name(params): followed by an indented body. There is no return-type annotation unless you add type hints. Functions can be defined at module level, nested inside other functions, or as class methods. Python has no arrow-expression equivalent (=> expr) for functions — that concise single-expression form is only available as lambda.

Python default parameters work identically to C#'s optional parameters. But Python also supports keyword arguments at any call site — any parameter can be passed by name regardless of position (greet("Bob", greeting="Hi")), unlike C# where you must match position or use the named syntax explicitly. This makes Python's function calls far more self-documenting.

*args collects extra positional arguments into a tuple — the equivalent of C#'s params T[]. **kwargs collects extra keyword arguments into a dict — there is no C# equivalent (the closest pattern is an IDictionary<string, object> parameter or an anonymous type). A function can combine both: def func(*args, **kwargs).

Python's lambda x: expression mirrors C#'s x => expression for simple single-expression functions. The key difference: Python lambdas can only contain a single expression (no statements, no return). For multi-line logic, define a full def. In practice, Python prefers named def functions over lambdas for anything beyond a sort key or quick map/filter argument.

Python has map(func, iterable) and filter(func, iterable) built-ins, but the idiomatic Python style is to use list comprehensions ([expr for x in seq if cond]) instead. They are more readable than chained lambdas and execute in a single pass. LINQ's fluent chaining corresponds directly to comprehension conditions: .Where(pred) → if pred inside the comprehension.

A Python list comprehension replaces LINQ's Select(...).ToList(). The syntax is [expression for variable in iterable]. Range is range(1, 6) (stop is exclusive), matching Enumerable.Range(1, 5). Comprehensions are faster than equivalent map()/list() calls in CPython because they avoid function-call overhead per element.

Adding an if clause to a comprehension replaces LINQ's .Where(). Combined select+filter (Where(...).Select(...)) maps naturally: [expr for x in seq if condition]. Nested comprehensions replace SelectMany: [item for sub in nested for item in sub].

A generator expression looks like a list comprehension but without the outer brackets. It produces values lazily one at a time — no intermediate list is allocated. This is the Python equivalent of LINQ's deferred execution. sum(n*n for n in numbers) is more memory-efficient than sum([n*n for n in numbers]) and is the idiomatic Python for aggregation.

Python classes use __init__ as the constructor (the self parameter is the instance and must be declared explicitly on every method). There are no access modifiers: attributes are public by default, and a leading underscore (_name) signals "private by convention". Properties require a separate decorator — the next concept.

Inheritance syntax: class Dog(Animal) vs C#'s class Dog : Animal. Call the parent constructor with super().__init__(...) instead of C#'s : base(...). Python supports multiple inheritance (class C(A, B)); C# allows only single class inheritance. Method overriding requires no override keyword — just redefine the method.

Python uses the @property decorator to create read-only computed properties that look like attribute access. To add a setter, define a second method decorated with @name.setter. This corresponds directly to C#'s { get; } and { get; set; } property syntax. Store the backing value in an underscore-prefixed attribute (self._radius) by convention.

@dataclass is the closest Python analog to a C# record: it auto-generates __init__, __repr__, and __eq__ from the field annotations. Add frozen=True to make it immutable (like a record with no setters). The dataclasses.field() function provides the same control as C# property initializers.

Python's "dunder" (double-underscore) methods replace C#'s override + operator declarations. __repr__ corresponds to ToString(), __add__ to operator +, __len__ to a Count property, and so on. Unlike C#, Python does not require a companion __radd__ if the left type handles addition.

Python uses except instead of catch, and the exception variable is bound with as: except ValueError as error. Python's exception hierarchy uses ValueError for parse failures (C#'s FormatException), TypeError for wrong types (C#'s InvalidCastException), and AttributeError for missing members (C#'s NullReferenceException).

Multiple except clauses work like multiple catch blocks — first match wins. To catch several exceptions in one clause: except (ValueError, TypeError) as error. Python's base class for all user-catchable exceptions is Exception; BaseException also catches KeyboardInterrupt and SystemExit, which is rarely desired.

Custom exceptions inherit from Exception (or a more specific subclass). A bare pass body is all that is needed if you add no new behavior — the message is set by the base Exception.__init__. The keyword is raise (not throw). Re-raising the current exception uses bare raise with no argument, just like C#'s bare throw.

Python's with statement is the direct equivalent of C#'s using declaration or using (...) {} block. Any object that implements __enter__ and __exit__ (a "context manager") can be used with with. This covers file handles, locks, database connections, and network sockets — exactly the same resources that C#'s IDisposable covers.

Python type hints (name: type) look like C# explicit declarations but have no runtime effect — the interpreter ignores them. They are checked by external tools (mypy, pyright) or IDEs. Omitting them is perfectly valid Python. Think of them as structured comments that enable IDE autocomplete and static analysis, rather than compile-time enforcement.

Function type hints use param: type for parameters and -> type for the return type — the arrow mirrors C#'s method signature layout. A function with no return statement returns None, and its hint should be -> None (equivalent to C#'s void). Passing the wrong type raises no runtime error unless you run a type checker separately.

Python 3.9+ accepts built-in types as generic hints: list[str] instead of the older List[str] from typing. The | union syntax (str | None) was added in Python 3.10; before that you'd write Optional[str] from typing. All of this is still advisory — no runtime enforcement.

Python uses the same async def / await keywords as C#. The key difference is the runtime: C# uses a multi-threaded thread pool; Python uses a single-threaded event loop (asyncio) with the GIL. Start the event loop with asyncio.run(coroutine) — the equivalent of C#'s top-level await in a console program. Async functions return a coroutine, not a Task.

asyncio.gather() is the Python equivalent of Task.WhenAll() — it runs multiple coroutines concurrently and collects their results in order. Results come back as a list. For cancellation or first-completed semantics, see asyncio.wait() (like Task.WhenAny). Note that asyncio concurrency is cooperative, not parallel — it does not bypass the GIL for CPU-bound work.

A Python function containing yield becomes a generator function — exactly like C#'s IEnumerable<T> method with yield return. Both are lazy: values are produced on demand as the caller iterates. Python also has yield from sub_generator to delegate to another generator, and generator expressions ((expr for x in seq)) for inline lazy sequences.

Python treats empty containers ([], {}, ""), zero (0, 0.0), and None as falsy in a boolean context. This is convenient — if items: means "if the list is non-empty" — but can surprise C# developers who expect only an explicit bool. Objects can define their own truthiness via __bool__ or __len__.

In Python, is checks object identity (like Object.ReferenceEquals), while == checks value equality (like a normal == in C#). The critical exception: always use is None / is not None for null checks, not == None, because a class can override __eq__ to return True when compared to None. Never use is to compare strings or numbers.

One of the most notorious Python gotchas: default argument values are evaluated once when the function is defined, not on each call. A mutable default (list, dict, set) is shared across all calls. The standard fix: default to None and create a fresh object inside the function body when None is received. C# always evaluates defaults at the call site, so this problem does not arise.

Python has no method overloading. Defining two functions with the same name in the same scope silently replaces the first — no error, no warning. Instead, use default arguments, *args/**kwargs, or check the type with isinstance() inside a single function. The functools.singledispatch decorator provides type-based dispatch as a library feature.