How Does Python Programming Actually Work? Explained Simply

Python · Under the Hood

How Does Python Programming Actually Work? Explained Simply

SECTION 01Compile and run: from source code to bytecode

Python is often called interpreted, but the standard implementation, CPython, first compiles your source code into bytecode — a compact set of instructions for the Python virtual machine (PVM). The PVM then reads and executes those instructions in a loop. When you import a module, CPython saves its bytecode in a __pycache__ folder as a .pyc file, so later imports can skip recompiling if the source has not changed.

import dis

def add_tax(price, rate=0.18):
    return price * (1 + rate)

dis.dis(add_tax)
# Output shows instructions such as LOAD_FAST, BINARY_OP
# and RETURN_VALUE (exact names vary by Python version)

# Compile without running: syntax errors appear here
src = "total = 10 +"
try:
    compile(src, "<demo>", "exec")
except SyntaxError as e:
    print("Caught before running:", e.msg)

# Byte-compile a file and look for the cache
# python -m py_compile mymodule.py
# ls __pycache__/   -> mymodule.cpython-312.pyc

SECTION 02Objects and memory: names point to objects

In Python, everything is an object — numbers, strings, lists, functions, even classes. A variable is a name that refers to an object; assignment does not copy the object, it binds another name to it. This is why changing a list through one name shows up through another. CPython frees memory mainly through reference counting: when no names refer to an object, it can be released. A separate garbage collector handles reference cycles.

a = [1, 2, 3]
b = a                 # same list, two names
b.append(4)
print(a)              # [1, 2, 3, 4]
print(a is b)         # True: same object

c = a.copy()          # a new list object
c.append(5)
print(a, c)           # [1, 2, 3, 4] [1, 2, 3, 4, 5]
print(id(a) == id(c)) # False

import sys, gc

data = [0] * 1000
print(sys.getrefcount(data))   # usually 2: 'data' + the call argument

alias = data
print(sys.getrefcount(data))   # one higher

del alias
print(sys.getrefcount(data))

# Reference cycle: two lists pointing at each other
x, y = [], []
x.append(y); y.append(x)
del x, y
print("collected objects:", gc.collect())

SECTION 03Imports and modules: how Python finds code

When you write import json, Python checks whether the module is already loaded in sys.modules. If not, it searches the folders listed in sys.path — your script's folder, installed packages and the standard library — finds the module, compiles it if needed and runs its top-level code once. The result is cached, so later imports are fast. This also explains why a local file named json.py can accidentally shadow the real module.

import sys

print(sys.path[:3])            # where Python looks first
print("json" in sys.modules)   # probably False before import

import json
print("json" in sys.modules)   # True now
print(json.__file__)           # where it was loaded from

# greet.py
def hello(name):
    return f"Hello, {name}"

print("greet.py top-level code runs, __name__ =", __name__)

if __name__ == "__main__":
    print(hello("from the command line"))

# python greet.py   -> __name__ is "__main__", both prints run
# import greet      -> __name__ is "greet", only the first print runs

SECTION 04Experiments to see Python at work

Try these small experiments to make the ideas concrete. Each takes a few minutes.

1. Run dis.dis on a function with a loop; find the jump
2. Create a module, import it twice; see top-level code
   run only once
3. Make a list, give it two names, change it through one
4. Create a file named random.py; import random and
   see what breaks (then delete the file!)
5. Use timeit to compare 'x in list' vs 'x in set'

import timeit

setup = "items = list(range(100_000)); s = set(items)"
print("list:", timeit.timeit("99_999 in items", setup=setup, number=1_000))
print("set :", timeit.timeit("99_999 in s", setup=setup, number=1_000))
# The set lookup is typically far faster.

Experiment:
What I expected:
What happened:
Why (in my own words):
How this changes the code I write:

SECTION 05Why understanding Python internals helps you

You do not need to read CPython's source, but a mental model helps daily:

• Avoid shared-list bugs — knowing names point to objects prevents accidental changes.
• Choose the right data structure — understanding lookups explains why sets and dicts are fast.
• Debug import errors quickly — sys.path and shadowing explain most of them.
• Keep modules side-effect free — import-time code runs once and can surprise you.
• Answer interview questions confidently — "is Python compiled or interpreted?" has a clear answer.

SECTION 06Interview Q&A — how Python works

SECTION 07Test yourself — how Python works quiz

SECTION 08Frequently asked questions

SECTION 09Related reads