Interpreter Execution Model

eval() evaluates one expression and returns its value. exec() runs statements - assignments, loops, imports, definitions - and always returns None. Hand eval() a statement and it raises SyntaxError.

CPython caches each module's compiled bytecode in a pycache directory next to the source. It reuses that .pyc only when the magic number matches the interpreter and the recorded source timestamp and size still match.

ast.NodeVisitor reads a tree: its visit_<NodeType> methods return whatever they like and the tree is untouched. ast.NodeTransformer rewrites it: whatever a visit method returns replaces the node, and returning None deletes it.

The code object is compiled once and is immutable, so it can be shared. Default values are ordinary expressions evaluated each time the def statement executes, so they belong to the function object created then, in defaults and kwdefaults.

ast.parse() turns source text into a tree that mirrors Python's own grammar, so a tool matches real structure - a call, an assignment, a function - instead of characters. Regexes cannot see nesting, strings or comments.

CPython counts how many Python frames are stacked on the current thread and raises RecursionError once that count passes the interpreter's recursion limit, which is 1000 by default. sys.getrecursionlimit() reads it; sys.setrecursionlimit() changes it.

Get a frame object with inspect.currentframe() or sys._getframe(), follow its f_back attribute to the caller's frame, then read f_code.co_name for the caller's name and f_lineno for the call site.

Function locals live in numbered slots on the frame, not in a dictionary. locals() manufactures a snapshot dict of those slots, so writing into it changes only the copy. Since 3.13, a frame's f_locals is a write-through proxy and does update the real variable.

sys.setrecursionlimit only moves CPython's frame counter. The real constraint is the fixed stack the operating system gave the thread, so lifting the counter past what that stack supports turns a catchable RecursionError into a hard crash with no traceback.

inspect.stack() walks every frame to the top of the stack, builds a record for each, and by default reads a source line per frame through the line cache. Cost scales with stack depth and touches the filesystem, so it is thousands of times slower than sys._getframe(1).

getattr takes the attribute name as a runtime string, and its optional third argument is returned instead of raising AttributeError when the name is absent. Dotted syntax needs the name written in the source and always raises.

Decoration rebinds the name to the wrapper, a different function object with its own metadata, so name, qualname and doc are the wrapper's. Applying functools.wraps to the wrapper copies that metadata from the wrapped function and sets wrapped.

defaults is a tuple of default values for the trailing positional-or-keyword parameters, or None when there are none. kwdefaults is a dict of defaults for keyword-only parameters. Both are evaluated once when the def executes and stored on the function object.

inspect.Parameter has five kinds: POSITIONAL_ONLY, POSITIONAL_OR_KEYWORD, VAR_POSITIONAL, KEYWORD_ONLY and VAR_KEYWORD. The kind says how an argument may be supplied — by position, by either, by name only, or swept into a catch-all — and .parameters lists them in that order.

name is the bare name from the def statement. qualname is the dotted path to the definition inside its module, including enclosing classes and functions, with <locals> marking a function-local definition. module names the defining module.

CPython salts str and bytes hashes with a seed picked at interpreter start-up, so the same strings land in different slots of the set's hash table each run. Set iteration follows slot order, so the order changes.

The interpreter prepends the running script's own directory to sys.path, so import searches it before the standard library and takes the first match. Run with -P, or set PYTHONSAFEPATH=1, to drop that prepended entry.

Running the interpreter with -O compiles away every assert statement and sets the built-in constant debug to False, so if debug blocks vanish too. It performs no other optimization and does not make code faster.

sys.version_info is a five-field named tuple, so comparing it against a tuple such as (3, 11) is an element-wise numeric comparison. sys.version is a free-form display string, and text comparison wrongly orders 3.9 after 3.14.

Running python -X dev (or setting PYTHONDEVMODE=1) enables the default warning filter so DeprecationWarning and ResourceWarning appear, debug hooks in the memory allocator, faulthandler, asyncio debug mode, and stricter encoding-argument checks.

sys.exit() raises SystemExit rather than killing the process outright; if nothing catches it, the interpreter shuts down. No argument or None gives exit status 0, an integer gives that value, and any other object is printed to stderr with status 1.

sys.argv[0] is the program name: the script path exactly as typed, or, under -m, the full path of the resolved module file. The program's own options always start at sys.argv[1]; interpreter switches never appear.

SystemExit inherits directly from BaseException, not from Exception, so except Exception deliberately lets it pass. That keeps a broad error handler from swallowing a requested shutdown. A bare except: means except BaseException and does swallow it.

To keep its cost off the startup path. A module-level import runs while the module body runs, so every process pays it; an import inside a function runs only when that function is called, and never if it is not. It also breaks import cycles.

Python's -m switch resolves a dotted module name through the import system, imports the parent package, and puts the working directory first on sys.path. A file path runs that file with its own directory first and no package context, so relative imports fail.