CPython is the principal implementation of Python, developed in the Python project's source repository and distributed through python.org. It parses source code and compiles it into code objects containing bytecode, which its execution machinery evaluates. The
dis module makes the bytecode instructions visible, connecting source-level functions with their compiled representation.[ref]For example, a function that returns
len(items) needs to obtain the callable and argument, perform the call and return its result. A bytecode listing reveals those operations, together with version-specific supporting instructions. CPython can specialize instructions as a program runs. Exact instruction names and layouts are implementation details that can change between releases; the meaning of the Python source expression is specified at the language level.A function object is a callable runtime object representing a function together with the context needed to execute it. In CPython, a Python-defined function object refers to a code object, its defining global namespace, default argument values and any captured bindings. The code object alone does not contain all this context.[ref]
For example, a factory
make_adder(k) can return a nested function computing x+k. Calling the factory with two and five can produce function objects sharing one code object but retaining different values of k through their programming closures. Their results on input ten are twelve and fifteen. This explains why identifying compiled instructions is insufficient to identify a callable's behavior.In CPython, a code object represents compiled executable Python code. It stores bytecode and metadata such as constants, referenced names and source positions. A function object additionally supplies the global namespace, default argument values and, when needed, a closure connecting free variables to captured values. A code object by itself does not contain that execution context.[ref]
For example, calling a function factory twice can create two functions with the same code object but different captured values. Their behavior differs because their closures differ, even though their instructions are shared. Inspecting
f.__code__ therefore describes executable structure rather than a complete snapshot of f's environment. Python documents code objects as immutable; version-specific bytecode details should not be treated as a permanent cross-version file format.