“
When running a Python program, the interpreter spends most of its time figuring out what low-level operation to perform, and extracting the data to give to this low-level operation. Given Python’s design and flexibility, the Python interpreter always has to determine the low-level operation in a completely general way, because a variable can have any type at any time. This is known as dynamic dispatch, and for many reasons, fully general dynamic dispatch is slow.[5] For example, consider what happens when the Python runtime evaluates a + b: The interpreter inspects the Python object referred to by a for its type, which requires at least one pointer lookup at the C level. The interpreter asks the type for an implementation of the addition method, which may require one or more additional pointer lookups and internal function calls. If the method in question is found, the interpreter then has an actual function it can call, implemented either in Python or in C. The interpreter calls the addition function and passes in a and b as arguments. The addition function extracts the necessary internal data from a and b, which may require several more pointer lookups and conversions from Python types to C types. If successful, only then can it perform the actual operation that adds a and b together. The result then must be placed inside a (perhaps new) Python object and returned. Only then is the operation complete. The situation for C is very different. Because C is compiled and statically typed, the C compiler can determine at compile time what low-level operations to perform and what low-level data to pass as arguments. At runtime, a compiled C program skips nearly all steps that the Python interpreter must perform. For something like a + b with a and b both being fundamental numeric types, the compiler generates a handful of machine code instructions to load the data into registers, add them, and store the result.
”
”