Python Technical Cheat Sheet

Python 3 is the modern, actively maintained version; Python 2 reached end-of-life in January 2020. Key differences:

• print: print x (statement, Py2) vs print(x) (function, Py3).
• Division: 5/2 returns 2 in Py2 (integer div) and 2.5 in Py3 (true div); use // for floor division in Py3.
• Strings: Py3 strings are Unicode by default (str is text, bytes is binary). Py2 had str as bytes and unicode as text.
• xrange/range: Py3's range is a lazy iterator (like Py2's xrange); xrange is gone.
• Exception syntax: except Exception as e (Py3); Py2 also allowed except Exception, e.
• Type hints, f-strings, async/await, walrus operator, dataclasses: Py3-only features.

Immutable objects cannot change after creation — any "modification" creates a new object. Examples: int, float, bool, str, tuple, frozenset, bytes.

Mutable objects can be modified in place. Examples: list, dict, set, bytearray, and most custom classes.

Why it matters:

• Only immutable (hashable) types can be dictionary keys or set elements.
• Mutable default arguments cause a classic bug: the default is shared across all calls.
• Passing a mutable object to a function lets the function modify your original data.

# Mutable default argument pitfall
def append_to(item, target=[]):   # BAD — list is shared
    target.append(item)
    return target

append_to(1)   # [1]
append_to(2)   # [1, 2] — surprise!

# Correct pattern
def append_to(item, target=None):
    if target is None:
        target = []
    target.append(item)
    return target

== compares values (calls __eq__). is compares identity — whether two names refer to the exact same object in memory (same id()).

a = [1, 2, 3]
b = [1, 2, 3]
a == b   # True  — same values
a is b   # False — different objects

x = None
x is None   # Correct idiom for None checks

Always use is for comparing to None, True, and False (these are singletons). Use == for value equality.

List: mutable, variable length, used when contents will change. Slight memory overhead and slower than tuples.

Tuple: immutable, fixed length, slightly faster, hashable (if elements are hashable), can be a dict key.

• Use a list for homogeneous, changing collections: scores = [90, 85, 70].
• Use a tuple for fixed records / heterogeneous data: point = (x, y), rgb = (255, 0, 0).
• Tuples are often returned when a function needs to return multiple values: return name, age.

Python dicts are implemented as open-addressed hash tables. Since Python 3.7 they also preserve insertion order (an implementation guarantee, not just a side effect).

Time complexity (average / amortized):

• d[k], k in d, d[k] = v, del d[k] — all O(1) average.
• Worst case is O(n) if all keys hash to the same bucket (rare; Python randomizes hash seeds).

Keys must be hashable (implement __hash__ and __eq__ consistently). That's why lists and dicts can't be keys — they're mutable and unhashable.

Since Python 3.6, CPython uses a compact dict layout that reduces memory by ~20–25% and preserves order.

*args collects extra positional arguments into a tuple. **kwargs collects extra keyword arguments into a dict.

def demo(a, *args, **kwargs):
    print(a, args, kwargs)

demo(1, 2, 3, x=10, y=20)
# 1 (2, 3) {'x': 10, 'y': 20}

# Unpacking on the call side
nums = [1, 2, 3]
opts = {"x": 10}
demo(*nums, **opts)

The names args / kwargs are convention — the * and ** are what matters. Common uses: writing decorators that forward arguments, and building flexible APIs.

LEGB is the order Python searches for a name: Local → Enclosing → Global → Built-in.

• Local: names defined inside the current function.
• Enclosing: names in any outer enclosing function (for nested functions / closures).
• Global: names at the top level of the module.
• Built-in: names pre-loaded by Python (len, print, range...).

To modify a name in an outer scope, use global x or nonlocal x.

x = "global"

def outer():
    x = "enclosing"
    def inner():
        nonlocal x
        x = "modified"
    inner()
    print(x)   # modified

• Encapsulation: bundling data and methods, with name mangling (_protected, __private) for weak access control. Python relies on convention, not enforcement.
• Inheritance: class Dog(Animal) lets Dog reuse and extend Animal. Python supports multiple inheritance, resolved via MRO (C3 linearization).
• Polymorphism: same method name behaves differently across classes. Python embraces duck typing: "if it walks like a duck..." — you don't need a common base class, just a common interface.
• Abstraction: hiding implementation details behind a clean interface, often using abc.ABC and @abstractmethod to define contracts.

• Instance method — first arg is self. Accesses and modifies instance state.
• @classmethod — first arg is cls. Operates on the class itself. Common use: alternative constructors.
• @staticmethod — no automatic first argument. Just a regular function namespaced inside the class. Use when logic is conceptually related but doesn't need self or cls.

class Pizza:
    def __init__(self, toppings):
        self.toppings = toppings

    @classmethod
    def margherita(cls):         # alternative constructor
        return cls(["tomato", "mozzarella"])

    @staticmethod
    def is_valid_topping(t):       # utility, no state needed
        return t in {"cheese", "tomato", "basil"}

MRO (Method Resolution Order) is the order Python searches base classes when looking up an attribute or method. Python uses the C3 linearization algorithm, which guarantees:

• A class appears before its parents.
• Parents appear in the order they're listed.
• Monotonicity — the order is consistent throughout the hierarchy.

class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass

print(D.__mro__)
# (D, B, C, A, object) — the classic "diamond" resolved cleanly

super() follows the MRO, not just the direct parent — which is why cooperative multiple inheritance works in Python.

Dunder methods (double underscore, e.g. __init__) let you integrate your class with Python's built-in syntax and protocols. The important ones:

• __init__, __new__ — construction.
• __repr__, __str__ — debug and user-facing representations.
• __eq__, __hash__, __lt__, __gt__ — equality and ordering.
• __len__, __iter__, __next__, __contains__, __getitem__ — container / iteration protocols.
• __enter__, __exit__ — context manager protocol.
• __call__ — make instances callable like functions.
• __add__, __mul__, __sub__, ... — operator overloading.

@property turns a method into a read-only attribute, letting you add validation or computed values without changing the attribute interface callers use.

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError("radius must be non-negative")
        self._radius = value

    @property
    def area(self):
        return 3.14159 * self._radius ** 2

c = Circle(5)
print(c.area)   # accessed like an attribute, computed lazily

__new__ is a static method that creates and returns a new instance. __init__ initializes the instance after it's been created.

• __new__(cls, ...) runs first. It must return an instance (usually by calling super().__new__(cls)).
• __init__(self, ...) runs next, only if __new__ returned an instance of cls.

You rarely override __new__. Real use cases: implementing singletons, subclassing immutable types (int, str, tuple), or metaclasses.

A decorator is a callable that takes a function (or class) and returns a new callable, typically wrapping the original. @decorator is just syntactic sugar for func = decorator(func).

import functools, time

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

@timer
def slow():
    time.sleep(0.5)

slow()   # slow took 0.5012s

functools.wraps is essential — it copies __name__, __doc__, and signature from the original, so introspection and debugging still work.

A generator is a function that uses yield instead of (or in addition to) return. It produces values lazily, one at a time, maintaining state between calls. Memory-efficient for large or infinite sequences.

def fib(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

list(fib(6))   # [0, 1, 1, 2, 3, 5]

# Generator expression — like a list comp, but lazy
squared_sum = sum(x*x for x in range(10**6))

Use generators when: the sequence is huge, infinite, streaming from I/O, or when you only need to iterate once. They trade random-access for O(1) memory.

A context manager is an object usable with with that guarantees setup and cleanup. The protocol is __enter__ and __exit__. Common use: managing resources like files, locks, DB connections.

# Class-based
class Timer:
    def __enter__(self):
        self.start = time.perf_counter()
        return self
    def __exit__(self, exc_type, exc_val, tb):
        print(f"Elapsed: {time.perf_counter() - self.start:.3f}s")

with Timer():
    expensive_work()

# Decorator-based — simpler for one-off managers
from contextlib import contextmanager

@contextmanager
def timer():
    start = time.perf_counter()
    yield
    print(f"Elapsed: {time.perf_counter()-start:.3f}s")

__exit__ receives the exception info; return True to suppress it, anything else (or None) to let it propagate.

A metaclass is "the class of a class." In Python, classes are themselves objects, and their type is a metaclass — by default, type. Metaclasses let you customize class creation (add methods, validate, register subclasses).

class UpperMeta(type):
    def __new__(mcs, name, bases, ns):
        ns = {k.upper() if not k.startswith("__") else k: v
              for k, v in ns.items()}
        return super().__new__(mcs, name, bases, ns)

class Foo(metaclass=UpperMeta):
    def bar(self): return 42

Foo().BAR()   # 42 — 'bar' was uppercased at class creation

An iterable is any object that implements __iter__ and returns an iterator. An iterator implements __iter__ (returning self) and __next__, which returns the next value or raises StopIteration.

class CountDown:
    def __init__(self, start):
        self.current = start
    def __iter__(self):
        return self
    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        self.current -= 1
        return self.current + 1

list(CountDown(3))   # [3, 2, 1]

A for loop calls iter() on the iterable and then next() until StopIteration.

@dataclass auto-generates __init__, __repr__, and __eq__ from type-annotated class attributes. Added in Python 3.7. Reduces boilerplate for simple data containers.

from dataclasses import dataclass, field

@dataclass
class User:
    name: str
    age: int = 0
    tags: list = field(default_factory=list)

u = User("Ada", 36)
print(u)   # User(name='Ada', age=36, tags=[])

Useful options: @dataclass(frozen=True) makes instances immutable and hashable; @dataclass(slots=True) (3.10+) adds __slots__ for memory savings.

The Global Interpreter Lock (GIL) is a mutex in CPython that ensures only one thread executes Python bytecode at a time. It simplifies memory management and C extensions but prevents true parallelism of CPU-bound Python code across threads.

Implications:

• I/O-bound workloads (network, disk) benefit from threads — the GIL is released during blocking I/O.
• CPU-bound workloads don't scale with threads. Use multiprocessing, concurrent.futures.ProcessPoolExecutor, or C extensions (NumPy, PyTorch) that release the GIL.
• asyncio is an alternative for high-concurrency I/O with a single thread.

Quick rule: CPU-heavy → processes. Blocking I/O and small scale → threads. High-scale network I/O with async libraries → asyncio.

CPython uses two mechanisms:

• Reference counting: every object tracks how many references point to it. When the count hits zero, the object is freed immediately. Fast and deterministic.
• Generational garbage collector (gc module): detects and collects reference cycles (e.g., two objects referring to each other) that ref counting can't. Objects are grouped into 3 generations; newer generations are collected more frequently.

You can inspect and control it with gc.collect(), gc.disable(), sys.getrefcount(obj). Use weakref to avoid creating cycles in caches and observers.

By default, Python stores instance attributes in a per-instance __dict__. Defining __slots__ tells Python to use a fixed-size array instead, which:

• Reduces memory (~40–50%) — important when creating millions of instances.
• Speeds up attribute access slightly.
• Prevents adding attributes not listed in __slots__.

class Point:
    __slots__ = ("x", "y")
    def __init__(self, x, y):
        self.x, self.y = x, y

p = Point(1, 2)
p.z = 3   # AttributeError — slot 'z' not defined

Trade-offs: no dynamic attributes, and multiple inheritance with slots is tricky. Use only when profiling shows memory pressure from many instances.

A shallow copy creates a new outer container but shares references to the inner objects. A deep copy recursively copies everything.

import copy

original = [[1, 2], [3, 4]]
shallow  = copy.copy(original)
deep     = copy.deepcopy(original)

shallow[0].append(99)
print(original)   # [[1, 2, 99], [3, 4]] — shared inner list!
print(deep)       # [[1, 2], [3, 4]]       — fully independent

Shortcuts for shallow copies: list(x), x[:], x.copy(), {**d}.

Default argument values are evaluated once when the function is defined, not every call. If the default is a mutable object, all calls share it.

def bad(x, acc=[]):
    acc.append(x)
    return acc

bad(1)   # [1]
bad(2)   # [1, 2]   ← leaked state

def good(x, acc=None):
    if acc is None:
        acc = []
    acc.append(x)
    return acc

Always use None as the sentinel and create a fresh object inside the function.

Closures capture variables by reference, not by value. When the closure runs, it looks up the current value of the variable — often leading to surprises in loops.

funcs = [lambda: i for i in range(3)]
[f() for f in funcs]   # [2, 2, 2] — all see final i

# Fix: bind via a default argument
funcs = [lambda i=i: i for i in range(3)]
[f() for f in funcs]   # [0, 1, 2]

When Python runs a file directly, it sets __name__ to "__main__". When the file is imported as a module, __name__ is set to the module's name. The if guard lets the same file behave as both a script and an importable module:

def main():
    print("Running as a script")

if __name__ == "__main__":
    main()

Essential when using multiprocessing on Windows/macOS — without it, spawned subprocesses re-execute the entire module and hit an infinite recursion.

a = [1, 2]
a.append([3, 4])   # [1, 2, [3, 4]]  — adds ONE element (the list)

a = [1, 2]
a.extend([3, 4])   # [1, 2, 3, 4]    — adds each element

a = [1, 2]
a += [3, 4]        # [1, 2, 3, 4]    — same as extend for lists

+= on a list mutates in place (like extend); += on a tuple rebinds to a new tuple.

Iterate directly over the file object — it yields one line at a time, O(1) memory regardless of file size.

with open("huge.log") as f:
    for line in f:
        process(line.rstrip())

# Count matching lines — also streaming
with open("huge.log") as f:
    errors = sum(1 for line in f if "ERROR" in line)

Avoid f.readlines() or f.read() on large files — they load everything at once.

# enumerate — index + value
for i, name in enumerate(["a", "b", "c"], start=1):
    print(i, name)

# zip — pair parallel iterables (stops at shortest)
names = ["Alice", "Bob"]
ages  = [30, 25]
for n, a in zip(names, ages):
    print(n, a)

# map — apply function to each element (lazy iterator)
squares = list(map(lambda x: x*x, [1, 2, 3]))   # [1, 4, 9]

All three return iterators in Python 3. Wrap in list() to materialize. For map, a list comprehension is usually clearer: [x*x for x in xs].

Python's float is IEEE 754 double-precision binary. Decimals like 0.1 can't be represented exactly in binary, so tiny rounding errors accumulate.

0.1 + 0.2                 # 0.30000000000000004

# Safe equality for floats
import math
math.isclose(0.1 + 0.2, 0.3)   # True

# Need exact decimals? Use Decimal
from decimal import Decimal
Decimal("0.1") + Decimal("0.2")   # Decimal('0.3')

Use decimal.Decimal for money and math.isclose for approximate float comparisons.

a = {"x": 1, "y": 2}
b = {"y": 20, "z": 3}

# Python 3.9+ — merge operator
merged = a | b          # {'x': 1, 'y': 20, 'z': 3}

# Any Python 3.5+
merged = {**a, **b}

# In-place update
a.update(b)

On conflicting keys, the right-hand dict wins. Use collections.ChainMap if you want a view that layers dicts without copying.

try:
    data = fetch()
except ConnectionError as e:
    log("retrying", e)
    data = fetch_from_cache()
except ValueError:
    raise                       # bubble up
else:
    log("success")              # runs only if no exception
finally:
    cleanup()                  # always runs

Best practices:

• Catch specific exceptions — never bare except: (it hides KeyboardInterrupt, SystemExit).
• Use raise (no argument) to re-raise while preserving traceback.
• Chain with raise NewError("context") from err.
• Prefer EAFP ("easier to ask forgiveness than permission") — try the operation and catch, rather than checking conditions up front.

• Bare except: — catches everything, including SystemExit. Use specific exceptions.
• Mutable default arguments (see Q26).
• for i in range(len(xs)): xs[i] — use for x in xs or enumerate.
• String concatenation in a loop (s += x) — use "".join(parts).
• if x == True: — use if x:.
• type(x) == MyClass — use isinstance(x, MyClass) to respect inheritance.
• Using == to compare with None — use is None.
• Catching and silently ignoring exceptions (except: pass) — at least log them.
• Overusing classes for what a function would do — not everything needs to be OOP.