Performance and Memory

Each object in the cycle holds a reference to the other, so neither count drops to zero even after every outside name is gone. CPython runs a second, tracing collector — the gc module — to find and free such groups.

del x only unbinds the name x from its namespace and drops one reference to the object. CPython deallocates the object at the moment its reference count reaches zero, so if a list, attribute or another name still holds it, nothing is freed.

A weakref.ref points at an object without counting toward the references that keep it alive. Call the ref like a function to get the object back, or None once the object has been collected.

__slots__ fixes the attribute names up front so instances store values at known offsets and carry no per-instance dictionary. On CPython 3.14 that is roughly a 35-45% cut for a small class - real, but far less than the old folklore.

Log sys.getallocatedblocks() once per batch. A live block count that returns to baseline while RSS does not means the objects are gone and pymalloc is holding fragmented arenas; a climbing count is a real leak, localised with tracemalloc.

The first import of a module runs its whole body top to bottom, then stores the finished module object so later imports are just a cache lookup. Every top-level statement in it is startup cost.

A module-level list stays reachable from sys.modules for the whole process, so every object it holds keeps a live reference and can never be freed. Python reclaims an object only when nothing reachable still refers to it.

Wall-clock time is elapsed real time, read with time.perf_counter(). CPU time is the time the processor actually spent executing the process, read with time.process_time(). Sleeping, waiting on a socket or blocking on a lock adds wall time but no CPU time.

timeit runs the setup string once, before the clock starts, and only the stmt string inside the timed loop. Imports and test-data construction are therefore excluded, so you measure the operation itself rather than its fixtures.

tottime is the time spent inside a function's own body, excluding the calls it makes. cumtime adds everything it called. Sort by tottime to find hot code, by cumtime to find the expensive call path.

Strings are immutable, so each += builds a brand-new string and copies everything accumulated so far. str.join walks the sequence once in C, sizes the result, allocates it once, and copies each piece exactly once.

Each multiprocessing worker is a separate OS process with its own address space and its own copy of every module-level name. What the child rebinds or mutates changes only the child's memory; results must be sent back explicitly.

A list comprehension builds the whole list in memory at once. A generator expression builds nothing up front: it produces items one at a time on demand, holds only the current value, can be consumed once, and supports neither len() nor indexing.

The wrapper builds a key from the call's arguments and looks it up in a dictionary, so every argument must be hashable. A list is not, and the lookup raises TypeError: unhashable type: 'list' before the function body ever runs.

Iterate the open file object directly with a for loop: it is its own iterator and hands back one buffered line at a time. Never call read() or readlines(), and keep every downstream stage lazy so nothing collects the whole file.

A local read compiles to a LOAD_FAST-family instruction, an index into the frame's array of local slots. A global read compiles to LOAD_GLOBAL, which hashes the name and searches the module dictionary, then builtins. An array index beats a hash lookup.

The loop pays interpreter overhead on every element: bytecode dispatch, a heap-allocated object per value, reference-count updates and runtime type checks. One vectorized call pays that once, then runs a typed machine-code loop over contiguous memory.

CPython watches how each bytecode instruction is actually used and rewrites it in place into a form specialized for the types it keeps seeing, behind a cheap guard check. No machine code is produced; the interpreter simply does less work per instruction.

CPython's C API hands extensions raw pointers to objects and makes them maintain reference counts. PyPy has a moving collector and no reference counts, so it emulates that API — costly at every crossing and not always complete.

dis.dis(f) prints the CPython bytecode the compiler produced for f: one line per instruction, with the source line, the byte offset, the opcode name and its resolved argument. It shows what the interpreter executes, not how long it takes.

Slicing a bytes object allocates a new bytes and copies the requested range. A memoryview exposes the same memory through the buffer protocol, so slicing it returns another view over the original block in constant time, copying nothing.

The C code inside zlib drops the global interpreter lock before it starts deflating and takes it back when the call finishes. Other Python threads run real bytecode during that window, so threaded compression genuinely overlaps.

Without them ctypes guesses: it decodes the result as a C int, truncating any 64-bit pointer, and passes arguments by default rules that ignore the real signature. Declaring argtypes and restype makes ctypes convert and type-check every call.

ctypes.CDLL loads a shared library into the running process through the platform's dynamic loader. Attribute access on the object it returns resolves an exported C symbol by name and hands back a callable you invoke like a normal function.

read(n) allocates a fresh bytes object on every call. readinto(buf) writes into a writable buffer you already own and returns how many bytes it actually wrote, so a streaming loop reuses one allocation instead of producing garbage per chunk.