tag

#interpreter

13 pages tagged

Deep Reads › CPython Internals › 4. The Interpreter ›

37. Pattern Matching

37. Pattern Matching Pattern matching is Python’s structural matching system. It is implemented by the match statement and case clauses. match value: case 0: result = "zero" case [x, y]: result = x + y case {"name": name}: result = name case _: result = None Pattern matching is not a switch statement over constants only. It can inspect structure, bind names, test classes, match sequences, match mappings, apply guards,...
cpython python internals interpreter
Deep Reads › CPython Internals › 4. The Interpreter ›

38. Comprehensions

38. Comprehensions Comprehensions are compact syntax for building containers or generator-like iterators from another iterable. CPython implements them as compiled code objects with their own execution scope. Common forms: [x * 2 for x in xs] {x * 2 for x in xs} {x: x * 2 for x in xs} (x * 2 for x in xs) These correspond to: list comprehension set comprehension dict comprehension generator expression They...
cpython python internals interpreter
Deep Reads › CPython Internals › 4. The Interpreter ›

28. Frames

28. Frames A frame is the runtime record for one active execution of Python code. When CPython calls a Python function, executes a module body, runs a class body, resumes a generator, or resumes a coroutine, it uses a frame-like execution record to hold the current state. A code object says what to execute. A frame says where execution currently is and what values are currently live. code object =...
cpython python internals interpreter
Deep Reads › CPython Internals › 4. The Interpreter ›

30. Bytecode Instructions

30. Bytecode Instructions Bytecode instructions are the operations executed by the CPython evaluation loop. They are the compact, interpreter-level form of Python code after parsing, AST construction, symbol analysis, and compilation. A Python function such as: def add(a, b): return a + b does not execute as source text. CPython compiles it into a code object. That code object contains an instruction stream. You can inspect that stream with dis...
cpython python internals interpreter
Deep Reads › CPython Internals › 4. The Interpreter ›

32. Method Calls

32. Method Calls Method calls are function calls that usually begin with attribute access. They are central to Python’s object model because most object behavior is exposed through methods. A method call such as: obj.method(arg) looks like one operation, but CPython executes several conceptual steps: load obj look up attribute method bind obj if needed load arg call the resolved callable return result or raise exception At the language level,...
cpython python internals interpreter
Deep Reads › CPython Internals › 4. The Interpreter ›

33. Attribute Lookup

33. Attribute Lookup Attribute lookup is the runtime process used to evaluate expressions such as: obj.name It is one of the most important mechanisms in CPython. Method calls, properties, descriptors, inheritance, modules, classes, slots, special methods, and many object protocols depend on it. A simple attribute expression can trigger a large amount of machinery: find the object's type search the type and its base classes handle descriptors check the instance...
cpython python internals interpreter
Deep Reads › CPython Internals › 4. The Interpreter ›

34. Exception Handling

34. Exception Handling Exception handling is the control-flow system CPython uses when an operation cannot complete normally. It covers explicit raise statements, failed operations, failed imports, failed calls, generator termination, context manager cleanup, traceback construction, and propagation through frames. At source level, exceptions look like this: try: value = risky() except ValueError: value = 0 At runtime, CPython must: execute the protected bytecode range detect failure record the active exception...
cpython python internals interpreter
Deep Reads › CPython Internals › 4. The Interpreter ›

29. Stack-Based Execution

29. Stack-Based Execution CPython executes most bytecode with a stack machine. A stack machine uses an implicit operand stack instead of naming explicit source and destination registers in every instruction. In CPython, this stack belongs to the current frame. It stores references to Python objects. Bytecode instructions push objects, pop objects, inspect objects, replace objects, and use objects to compute new results. A simple expression: x = a + b...
cpython python internals interpreter
Deep Reads › CPython Internals › 4. The Interpreter ›

31. Function Calls

31. Function Calls Function calls are one of the most important execution paths in CPython. A call connects several systems at once: bytecode execution, frames, argument binding, descriptors, methods, closures, the C API, reference counting, exceptions, and return handling. A simple call: result = f(1, 2) looks small at the source level. At runtime, CPython must: load the callable load the arguments choose the correct call protocol bind arguments to...
cpython python internals interpreter
Deep Reads › CPython Internals › 4. The Interpreter ›

35. Generators

35. Generators Generators are resumable functions. A normal function starts, runs, and finishes with one return value. A generator can start, produce a value, suspend its frame, later resume from the same instruction position, produce another value, and repeat until it finishes. A generator function is any function body that contains yield . def numbers(): yield 1 yield 2 yield 3 Calling this function does not run the body immediately....
cpython python internals interpreter
Deep Reads › CPython Internals › 4. The Interpreter ›

36. Coroutines and Async

36. Coroutines and Async Coroutines are resumable computations used for asynchronous programming. They let Python code suspend at an await point, return control to an event loop, and later resume when the awaited operation has a result. A coroutine is similar to a generator because both preserve execution state across suspension. The difference is protocol and purpose. A generator yields values to an iterator consumer. A coroutine awaits other asynchronous...
cpython python internals interpreter
Deep Reads › CPython Internals › 4. The Interpreter ›

27. Evaluation Loop

27. Evaluation Loop The evaluation loop is the central execution engine of CPython. It takes a compiled code object, executes its bytecode instructions, and produces a result or an exception. At a high level, CPython execution looks like this: Python source ↓ tokens ↓ parser ↓ AST ↓ symbol table ↓ compiler ↓ code object ↓ frame ↓ evaluation loop ↓ Python result or exception This chapter focuses on the...
cpython python internals interpreter
Deep Reads › CPython Internals › 4. The Interpreter ›

39. Closures and Cells

39. Closures and Cells Closures let a nested function use variables from an enclosing function after that enclosing function has returned. def make_adder(n): def add(x): return x + n return add add10 = make_adder(10) print(add10(5)) Output: 15 The variable n belongs to make_adder , but add still uses it later. CPython supports this by moving captured variables into cell objects. The inner function keeps references to those cells. 39.1 Nested...
cpython python internals interpreter