CD Notes

Python Interpreter Architecture

Deep exploration of Python compilation, bytecode, virtual machine, and execution model

Python's implementation (CPython) provides fascinating insights into interpreter design. Understanding how Python code executes helps optimize performance.

Python Execution Model

Python Source Code (.py) ↓ ┌──────────────────────────────┐ │ Python Parser │ │ (Grammar-based parsing) │ └──────────────────────────────┘ ↓ Abstract Syntax Tree (AST) ↓ ┌──────────────────────────────┐ │ Compiler │ │ (AST to bytecode) │ └──────────────────────────────┘ ↓ Python Bytecode (.pyc, .pyo) ↓ ┌──────────────────────────────┐ │ Python Virtual Machine │ │ (Bytecode interpreter) │ └──────────────────────────────┘ ↓ Program Output

Python Bytecode Example

Python Code:

python example

def add(a, b):
    return a + b

result = add(5, 3)
print(result)

Python Bytecode (disassembled):

Example

2 0 LOAD_CONST 1 (<code object add at ...>) 2 LOAD_CONST 2 ('add') 4 MAKE_FUNCTION 0 6 STORE_NAME 0 (add) 4 8 LOAD_NAME 0 (add) 10 LOAD_CONST 3 (5) 12 LOAD_CONST 4 (3) 14 CALL_FUNCTION 2 16 STORE_NAME 1 (result) 5 18 LOAD_NAME 2 (print) 20 LOAD_NAME 1 (result) 22 CALL_FUNCTION 1 24 LOAD_CONST 0 (None) 26 RETURN_VALUE

Bytecode Instructions

Python uses stack-based bytecode with around 120 different instructions:

Instruction	Meaning
LOAD_CONST	Load constant value onto stack
LOAD_NAME	Load variable value onto stack
STORE_NAME	Store stack top to variable
BINARY_ADD	Pop two values, add, push result
CALL_FUNCTION	Call function with args
RETURN_VALUE	Return from function
JUMP_ABSOLUTE	Jump to instruction
POP_JUMP_IF_FALSE	Pop and jump if false
BUILD_LIST	Build list from stack items

CPython Compilation Process

.py File ↓ ┌──────────────────────────────────┐ │ Lexer │ │ (Tokenization) │ └──────────────┬───────────────────┘ ↓ Token Stream ↓ ┌──────────────────────────────────┐ │ Parser (PEG/LALR) │ │ (Build parse tree) │ └──────────────┬───────────────────┘ ↓ Parse Tree ↓ ┌──────────────────────────────────┐ │ AST Transformer │ │ (Validate, transform) │ └──────────────┬───────────────────┘ ↓ Abstract Syntax Tree ↓ ┌──────────────────────────────────┐ │ Compiler │ │ (AST to bytecode) │ └──────────────┬───────────────────┘ ↓ Bytecode (.pyc)

Python Virtual Machine (PVM)

The Python Virtual Machine is a stack-based interpreter:

	TOS (Top)
	TOS1
	TOS2
	...

Method Resolution Order (MRO)

Python uses C3 Linearization for MRO in multiple inheritance:

python example

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

MRO of D: D → B → C → A → object

Linear order is calculated during class definition.

Scope and Namespace Management

Global Namespace ├─ Module-level variables ├─ Function definitions ├─ Class definitions Local Namespace (Function Scope) ├─ Local variables ├─ Parameters ├─ Function-local definitions Built-in Namespace ├─ Built-in functions (len, print, etc) ├─ Built-in types (int, str, list, etc) ├─ Built-in constants (True, False, None)

Scope Resolution (LEGB Rule):

Example

Local → Enclosing → Global → Built-in (Look for variable in this order)

Python Object Model

Every Python object has:

c example

// CPython PyObject structure
typedef struct {
    Py_ssize_t ob_refcnt;        // Reference count
    PyTypeObject *ob_type;       // Type (class)
} PyObject;

Object Example:

python example

x = 42

│ ob_refcnt	2 │ (referenced twice)
│ ob_type	int │ (type is integer)
│ ob_value	42 │ (actual value)

Garbage Collection

Python uses reference counting + cycle detection:

Reference Counting

Object A ← referenced by 2 things

ob_refcnt = 2

When references drop to 0

Memory freed immediately

Cyclic References (Cycle Collection)

A ← B ← C ← A (cycle)

Reference counts never reach 0

Periodic garbage collector detects cycles

Frees circular references

Code Objects and Functions

python example

def add(a, b):
    return a + b

Compiled to Code Object:

Example

Code object 'add': co_argcount = 2 co_code = <bytecode> co_consts = (None,) # Constants used co_names = () # Names referenced co_varnames = ('a', 'b') # Local variables co_filename = 'test.py' co_name = 'add' co_firstlineno = 1

Function object wraps code object:

Example

Function 'add': func_code → Code object func_globals → Global namespace func_name = 'add' func_defaults = None

Bytecode Optimization Levels

bash example

python script.py              # No .pyc cache
python -O script.py           # Optimize, remove __doc__
python -OO script.py          # Remove __doc__ and assertions

Performance: CPython vs PyPy

CPython (standard)

Interpreted bytecode

Slower but straightforward

PyPy (alternative)

JIT compilation

3-10x faster

Warm-up time needed

Interview Q&A

Q: How does Python execute code? A: Python parses source code to an AST, compiles to bytecode, and the Python Virtual Machine interprets bytecode instructions using a stack-based model.

Q: What is bytecode in Python? A: Bytecode is a low-level instruction set that Python compiles source code into. It's stored in .pyc files and interpreted by the Python VM.

Q: How does Python manage memory? A: Python uses reference counting to track object references. When count reaches zero, memory is freed. A periodic garbage collector detects and frees cyclic references.

Q: What is the LEGB rule? A: LEGB defines the scope lookup order: Local, Enclosing, Global, Built-in. When resolving a variable name, Python searches in this order.

Q: Why is PyPy faster than CPython? A: PyPy uses JIT compilation, dynamically compiling hot bytecode to native machine code. CPython interprets every bytecode instruction, which is slower.

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for Python Interpreter Architecture.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this Compiler Design topic.

Search Terms

compiler-design, compiler design, compiler, design, modern, technologies, python, interpreter

Continue learning this concept

Modern Compiler TechnologiesGCC ArchitectureIn-depth exploration of GNU Compiler Collection structure, intermediate representations, and optimization pipeline Modern Compiler TechnologiesBytecode and Virtual MachinesComprehensive guide to bytecode design, virtual machine architecture, and performance optimization Modern Compiler TechnologiesJava Compiler and BytecodeDeep dive into Java compilation process, bytecode format, and JVM architecture Modern Compiler TechnologiesJust-In-Time CompilationComplete guide to JIT compilation, tiered compilation, adaptive optimization, and runtime code generation Modern Compiler TechnologiesLLVM: The Low-Level Virtual MachineComprehensive introduction to LLVM architecture, IR, optimizations, and how it powers modern compilers Modern Compiler TechnologiesWebAssembly BasicsComplete introduction to WebAssembly, bytecode format, execution model, and practical usage

PreviousLLVM: The Low-Level Virtual Machine NextWebAssembly Basics

CD Notes

Python Interpreter Architecture

Deep exploration of Python compilation, bytecode, virtual machine, and execution model

Python's implementation (CPython) provides fascinating insights into interpreter design. Understanding how Python code executes helps optimize performance.

Python Execution Model

Python Bytecode Example

Python Code:

python example

def add(a, b):
    return a + b

result = add(5, 3)
print(result)

Python Bytecode (disassembled):

Example

Bytecode Instructions

Python uses stack-based bytecode with around 120 different instructions:

Instruction	Meaning
LOAD_CONST	Load constant value onto stack
LOAD_NAME	Load variable value onto stack
STORE_NAME	Store stack top to variable
BINARY_ADD	Pop two values, add, push result
CALL_FUNCTION	Call function with args
RETURN_VALUE	Return from function
JUMP_ABSOLUTE	Jump to instruction
POP_JUMP_IF_FALSE	Pop and jump if false
BUILD_LIST	Build list from stack items

CPython Compilation Process

Python Virtual Machine (PVM)

The Python Virtual Machine is a stack-based interpreter:

	TOS (Top)
	TOS1
	TOS2
	...

Method Resolution Order (MRO)

Python uses C3 Linearization for MRO in multiple inheritance:

python example

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

MRO of D: D → B → C → A → object

Linear order is calculated during class definition.

Scope and Namespace Management

Scope Resolution (LEGB Rule):

Example

Local → Enclosing → Global → Built-in (Look for variable in this order)

Python Object Model

Every Python object has:

c example

// CPython PyObject structure
typedef struct {
    Py_ssize_t ob_refcnt;        // Reference count
    PyTypeObject *ob_type;       // Type (class)
} PyObject;

Object Example:

python example

x = 42

│ ob_refcnt	2 │ (referenced twice)
│ ob_type	int │ (type is integer)
│ ob_value	42 │ (actual value)

Garbage Collection

Python uses reference counting + cycle detection:

Reference Counting

Object A ← referenced by 2 things

ob_refcnt = 2

When references drop to 0

Memory freed immediately

Cyclic References (Cycle Collection)

A ← B ← C ← A (cycle)

Reference counts never reach 0

Periodic garbage collector detects cycles

Frees circular references

Code Objects and Functions

python example

def add(a, b):
    return a + b

Compiled to Code Object:

Example

Function object wraps code object:

Example

Function 'add': func_code → Code object func_globals → Global namespace func_name = 'add' func_defaults = None

Bytecode Optimization Levels

bash example

python script.py              # No .pyc cache
python -O script.py           # Optimize, remove __doc__
python -OO script.py          # Remove __doc__ and assertions

Performance: CPython vs PyPy

CPython (standard)

Interpreted bytecode

Slower but straightforward

PyPy (alternative)

JIT compilation

3-10x faster

Warm-up time needed

Interview Q&A

Q: How does Python execute code? A: Python parses source code to an AST, compiles to bytecode, and the Python Virtual Machine interprets bytecode instructions using a stack-based model.

Q: What is bytecode in Python? A: Bytecode is a low-level instruction set that Python compiles source code into. It's stored in .pyc files and interpreted by the Python VM.

Q: What is the LEGB rule? A: LEGB defines the scope lookup order: Local, Enclosing, Global, Built-in. When resolving a variable name, Python searches in this order.

Q: Why is PyPy faster than CPython? A: PyPy uses JIT compilation, dynamically compiling hot bytecode to native machine code. CPython interprets every bytecode instruction, which is slower.

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for Python Interpreter Architecture.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this Compiler Design topic.

Search Terms

compiler-design, compiler design, compiler, design, modern, technologies, python, interpreter

Continue learning this concept

PreviousLLVM: The Low-Level Virtual Machine NextWebAssembly Basics