Python and Rust developer; I write about any topics you're interested in. Follow me! (#^.^#)
This article dissects CPython's _PyEval_EvalFrameDefault function, explaining how the interpreter treats itself as a CPU, uses a stack frame, switches between Python and C call stacks, and employs computed‑goto optimizations to efficiently dispatch bytecode instructions.
This article explains how the Python interpreter, after runtime initialization, creates a stack frame, invokes a series of C functions such as PyEval_EvalCode, _PyEval_Vector, and _PyEval_EvalFrameDefault to traverse and execute bytecode, and details the underlying runtime stack structures and macro APIs that support instruction evaluation.
The article explains Python's variable lookup mechanism, detailing the LEGB rule, static storage of local variables, dynamic global namespace updates, common UnboundLocalError scenarios, bytecode inspection, and how the global and nonlocal keywords modify scope resolution.
The article dissects Python's virtual machine execution flow, showing that bytecode runs inside dynamically created stack‑frame objects rather than the static PyCodeObject, and explains the internal structures, memory optimizations, and debugging interfaces that make this possible.
This article explains why and when Python creates .pyc files, shows how to compile them manually with py_compile, demonstrates importing compiled bytecode via importlib, dissects the .pyc file header and payload, and explores the CPython marshal implementation and simple bytecode obfuscation techniques.
This article explains Python's iterator protocol by showing how objects become iterable through __iter__, how the built‑in iter function creates iterator objects, the CPython internals of PyObject_GetIter, and how the __next__ method advances elements, with concrete code examples and source‑level snippets.
This article dissects Python’s built‑in set type, explaining how add, pop, remove, copy, update, union and other set operations map to low‑level C functions, how the hash table handles collisions, dummy entries, resizing, and the finger optimization that speeds up element removal.
This article explains Python's set type, covering its typical use cases, core API methods, and a deep dive into the CPython C implementation—including the PySetObject layout, hash table mechanics, field behavior, and differences from dictionaries.
The article explains the internal cache‑pool mechanism of CPython dictionaries, detailing how PyDictObject and PyDictKeysObject are allocated, deallocated, and reused via free‑lists of size 80, and demonstrates the behavior with concrete code examples and benchmarks.
The article explains Python's dict resizing mechanism, detailing when the hash table grows (when used entries reach two‑thirds of capacity), how the new size is chosen as the smallest power‑of‑two ≥ ma_used × 3, and the exact steps the interpreter takes to reallocate and rebuild the underlying key and entry arrays.
