How Python Really Runs Your Code

New words in this topic, in plain English. Come back here whenever one feels fuzzy.

Source code

The text you write, in a .py file.

Compile

To translate code from one form to another. Python compiles source code to bytecode.

Bytecode

Simple, compact instructions that the Python virtual machine carries out. You don't write it; Python produces it.

Virtual machine (VM)

A program that acts like a computer and runs bytecode instructions one at a time.

Interpreter

The whole python program: it compiles your source to bytecode and runs it on the virtual machine.

CPython

The standard implementation of Python, written in C. What you download from python.org.

Implementation

A particular program that runs the Python language. CPython, PyPy and MicroPython are implementations.

__pycache__

A folder where Python saves compiled bytecode of imported files, in .pyc files, to start faster next time.

JIT

Just-in-time compiler: it translates frequently run code into the processor's own instructions while the program runs.

Machine code

The instructions a processor understands directly.

1. 1

   Watch the compiler do arithmetic

   In the first example, change the source to "print(10 * 10 + 1)". Predict what co_consts will contain before running. The compiler folds the whole constant calculation into one number.

2. 2

   Change the bytecode

   In the second example, change the function body to return price * 2. Run it and compare: fewer instructions, and a different LOAD_ line. Then try return price + 1.

3. 3

   Find a __pycache__ folder

   On your computer, create helper.py containing GREETING = "Hello" and main.py containing import helper and print(helper.GREETING). Run python main.py, then list the folder. Delete __pycache__ and run again: it comes back.

   terminalcopy cmd

   $ python main.py

   ls

   ── expected output ──

   Hello

   __pycache__ helper.py main.py

Errors are the best teachers. Make each change, read the error, guess what went wrong, then reveal the answer.

print("This line is fine")
print("This one is not"

if 1 > 2:
    print(this_name_does_not_exist)
print("Finished without any error")

1. 1

   Step 1: compile. Python reads your whole file and translates it into bytecode: a list of small, simple instructions for an imaginary computer. This is when grammar is checked, which is why a SyntaxError anywhere stops the whole file before any line runs (Topic 0.7).

2. 2

   Step 2: run. The Python virtual machine (the heart of the interpreter) goes through the bytecode one instruction at a time and carries each out: load this value, add these two, call that function. Exceptions such as NameError happen here, at the moment the failing instruction is reached.

3. 3

   Both steps happen every time you type python hello.py, automatically and in a fraction of a second. You never run a separate compiler as you would in C or Java. That is why Python is called an interpreted language, even though it does compile to bytecode internally.

4. 4

   To save time, Python stores the bytecode of imported files in a folder named **__pycache__**, in files ending in .pyc. Next time, if the source hasn't changed, it loads the .pyc and skips step 1. You can delete __pycache__ folders at any time; Python recreates them. Keep them out of version control.

5. 5

   The Python from python.org is called CPython, because the interpreter is written in the C language. It is the reference: when people say "Python" they mean CPython. Other implementations run the same language in other ways: PyPy is built for speed with a just-in-time compiler, MicroPython fits tiny devices, and Pyodide, which powers this page's Run button, is CPython itself compiled to run inside a web browser.

6. 6

   Why Python is slower than C. The virtual machine does a lot of work for each small instruction: it checks what kind of values it has, finds the right operation, and creates a new object for the result (an object is a value stored in memory; Topic 1.1). Compiled C turns a + b into roughly one processor instruction. The designers have been closing the gap. Python 3.11 made the virtual machine specialise itself for the types it actually sees. Python 3.13 added an experimental JIT (just-in-time compiler) that turns hot bytecode into machine code.

• ↔

  Compile-at-run vs compile-ahead. Python needs no build step, so you edit and rerun in a second, and the same file runs on any system with an interpreter. The price is slower execution and errors that surface only when a line runs.

• ↔

  CPython vs PyPy. PyPy can run long, loop-heavy pure-Python code several times faster, but the AI and data libraries are built around CPython's C interface and work best, or only, there. That is why almost everyone uses CPython.

• ↔

  Dynamic checks vs speed. Looking everything up at run time makes Python flexible (you can change almost anything while the program runs) and makes each operation cost more.

• Done when you can describe the path from source code to bytecode to the virtual machine.

• Done when you can explain which errors come from the compile stage and which from the run stage.

• Done when you can say what CPython is and name two other ways the language is run.

• Done when you can explain what __pycache__ is for and why deleting it is safe.

• Done when you can give two reasons Python is slower than C and two ways around it.