What Python is and how it runs your code

Python is a general-purpose programming language with a small, readable syntax: blocks are marked by indentation rather than braces, and you do not declare the types of variables. It comes with a large standard library, so many everyday jobs (reading files, handling dates, talking to the web) need nothing extra. People use it for scripts and automation, web back ends, data analysis, machine learning, teaching and much more.

“Python” names two things: the language (the rules for what a program means, written down in the language reference) and the implementation, the program that actually runs your code. Most of the time the implementation is CPython, and this lesson is about what it does.

What happens when you run a file

When you run python3 hello.py, three things happen in order:

1. The interpreter reads your source code, the text in hello.py.
2. It compiles the whole file to bytecode: compact instructions for Python’s own virtual machine. If the file has a syntax error, it stops here, before a single line has run.
3. The virtual machine then executes the bytecode, one instruction after another. Errors that only show up while the program runs, such as dividing by zero, happen in this step.

There is no separate “compile, then run” command as in C or Java: both steps happen each time you run the file. The standard library’s dis module (short for disassembler) shows you the bytecode of a function:

import dis


def add(a, b):
    return a + b


dis.dis(add)

  4           RESUME                   0

  5           LOAD_FAST_BORROW_LOAD_FAST_BORROW 1 (a, b)
              BINARY_OP                0 (+)
              RETURN_VALUE

Each line of the output is one instruction. RESUME is bookkeeping at the start of every function; then the virtual machine fetches the two arguments, adds them with the + operator and returns the result. You never need to read bytecode to write Python, but it explains why a syntax error anywhere in a file stops the whole file from running.

Bytecode is cached for imported modules

When a program imports a module (another .py file), CPython saves that module’s bytecode in a folder called __pycache__ next to it, so the next run can skip compiling it again. Here is a program in two files: main.py, the program you run, and greeting.py, the module it imports.

import greeting

print(greeting.greet("Asha"))

Hello, Asha!

def greet(name):
    return "Hello, " + name + "!"

After python3 main.py has run once, __pycache__ holds greeting.cpython-314.pyc. The cpython-314 part says which implementation and version wrote it, so several Python versions can share one folder without mixing up their files. The file you run directly, main.py, is compiled every time and is not cached.

You can delete __pycache__ folders at any time; Python writes them again when it needs them. Leave them out of version control (add __pycache__/ to your .gitignore).

Which Python version to use

All current Python code is Python 3. Python 2 has not received fixes for years, but its code still turns up in old answers online, and it fails on Python 3:

# Python 2 code that still turns up in old answers online
print "Hello, world"

  File "python2_print.py", line 2
    print "Hello, world"
    ^^^^^^^^^^^^^^^^^^^^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(...)?

Python 3 reports a SyntaxError and even suggests the fix: print is a function, so it needs parentheses. Other signs of Python 2 code are raw_input() (now input()) and xrange() (now range()).

Within Python 3, versions are numbered 3.minor.micro:

• A feature release (3.13, 3.14, 3.15 …) adds language features and arrives about once a year.
• Each feature release then gets bugfix releases (3.14.1, 3.14.2 …) for about two years, then security fixes only, until about five years after it first came out. The Python Developer’s Guide lists the status of every version.
• A bugfix release changes no features, so code written for 3.14.2 normally runs unchanged on 3.14.8.

This track is written for Python 3.14, and its examples are run with CPython 3.14.8.

CPython and the other implementations

The Python you download from python.org is CPython, the reference implementation, written in C. Others run the same language in different places:

• PyPy adds a just-in-time compiler, which can make long-running programs much faster.
• MicroPython is a small Python for microcontrollers.
• Pyodide is CPython compiled to WebAssembly, so it runs inside a web browser, on your own device.

A program can ask which implementation, version and platform it is running on:

import sys

print("Implementation:", sys.implementation.name)
print("Version:", sys.version.split()[0])
print("Platform:", sys.platform)

Implementation: cpython
Version: 3.14.8
Platform: darwin

Implementation: cpython
Version: 3.14.2
Platform: emscripten

Key takeaways

• Running a .py file compiles it to bytecode and then runs the bytecode on CPython’s virtual machine; a syntax error stops the file before anything runs.
• Imported modules keep their bytecode in __pycache__; the files are safe to delete and do not belong in version control.
• Feature releases arrive about once a year and are supported for about five years; bugfix releases change no features. This track uses Python 3.14.
• CPython is the reference implementation; PyPy, MicroPython and Pyodide run the same language elsewhere.