Python Internals: How the Engine Works

1. What is "Python" Really?

"Python" is actually a specification—a document describing how the language should behave. However, the software installed on your computer that actually runs your code is an Implementation.

The reference implementation, and the one 99% of people use, is called CPython.

Other Implementations

While CPython is the standard, others exist for specialized needs:

• Jython: Python written in Java, running on the Java Virtual Machine (JVM).
• IronPython: Python for the .NET framework (C# integration).
• PyPy: A fast implementation using a JIT (Just-In-Time) compiler.
• MicroPython: Optimized for microcontrollers and embedded hardware.

Note: In this course, we always refer to CPython when we say "Python".

2. The Execution Pipeline

Python is a "Bytecode Interpreted" language. This hybrid approach gives it the portability of an interpreter with reasonable performance.

Step 1: The Compiler (Source -> Bytecode)

Your source code (.py) is not run directly. First, the CPython compiler reads your code and checks for syntax errors. If the syntax is correct, it translates it into a lower-level format called Bytecode.

Bytecode is a set of instructions for the Python Virtual Machine. It's not binary machine code (0s and 1s), but it's close. It looks like a simplified assembly language.

import dis

def complex_math(x, y):
    result = (x * 2) + (y / 5)
    return result

# Let's peek into the compiled bytecode 'cached' in memory
print("Bytecode Instructions:")
dis.dis(complex_math)

# SAMPLE OUTPUT EXPLAINED:
# 4           0 LOAD_FAST                0 (x)      <-- Push 'x' onto stack
#             2 LOAD_CONST               1 (2)      <-- Push Number 2 onto stack
#             4 BINARY_MULTIPLY                     <-- Pop top two, Multiply, Push Result
#             6 LOAD_FAST                1 (y)      <-- Push 'y' onto stack
#             8 LOAD_CONST               2 (5)      <-- Push Number 5 onto stack
#            10 BINARY_TRUE_DIVIDE                  <-- Pop top two, Divide, Push Result
#            12 BINARY_ADD                          <-- Add the two results together
#            14 STORE_FAST               2 (result) <-- Save to variable 'result'
#            16 LOAD_FAST                2 (result)
#            18 RETURN_VALUE                        <-- Return it

Step 2: The Python Virtual Machine (PVM)

The PVM is the engine of Python. It is a giant infinite loop written in C. It iterates through your bytecode instructions one by one and executes the corresponding C code system calls.

Why is this great? Portability.
The PVM isolates you from the hardware. You don't need to worry about whether the CPU is Intel (x86) or Apple Silicon (ARM). The PVM handles the translation to the specific CPU instructions.

3. Memory Management: The Automated Janitor

In languages like C or C++, you have to manually request memory (RAM) for variables and manually free it when you are done. If you forget to free it, you get a "Memory Leak" (your program eats all the RAM and crashes).

Python handles this automatically using two main strategies: Reference Counting and Garbage Collection.

Strategy A: Reference Counting (The Primary System)

Every object in Python has a counter attached to it. This counter tracks how many "references" (variables) point to that object.

• When you create a variable x = 1000, the integer object 1000 has 1 reference.
• If you say y = x, the count goes up to 2.
• If you change x = 500, the count for '1000' drops to 1 (y is still holding it).
• If you change y = 500, the count for '1000' drops to 0.

The Rule: As soon as an object's reference count hits zero, Python immediately destroys it and reclaims the memory.

import sys

# Create a string object
# Note: Small numbers/strings are 'interned' (cached) so they have higher counts.
# We use a unique list here to demonstrate.
a = []
b = a

# viewing the reference count
# It is 3 because:
# 1. Variable 'a' has it
# 2. Variable 'b' has it
# 3. getrefcount() argument itself temporarily holds it
print(f"Ref Count: {sys.getrefcount(a)}")

c = b
print(f"Ref Count: {sys.getrefcount(a)}") # Increases by 1

del c
print(f"Ref Count: {sys.getrefcount(a)}") # Decreases by 1

Strategy B: Garbage Collection (The Backup System)

Reference counting has one fatal flaw: Circular References.

Imagine Object A points to Object B, and Object B points back to Object A. Even if you delete all variables in your code, A and B still point to each other. Their counts will be 1, never 0. They will float in memory forever like space junk.

Python's Generational Garbage Collector solves this. It runs periodically in the background, specifically looking for these circular groups of isolated objects and deleting them. It uses a "Generation" system (Gen 0, Gen 1, Gen 2) to optimize performance—young objects are checked frequently, while old "survivor" objects are checked rarely.

4. The Global Interpreter Lock (GIL)

No discussion of Python internals is complete without the infamous GIL. It is both Python's safety net and its biggest bottleneck.

The "Talking Stick" Analogy

Imagine a meeting room (The Process) with multiple people (Threads) trying to write on a single whiteboard (The Memory).

• In a language like Java or C++, everyone can write on the board at the same time. This is fast, but dangerous—two people might write over each other (Race Conditions).
• In Python (CPython), there is a single "Talking Stick" (The GIL). Only the person holding the stick is allowed to write. Even if you have 8 people (threads) and 8 markers (CPU cores), only one person plays at any given millisecond.

Why allow the GIL?

It simplifies the internal memory management (Reference Counting) significantly. Making Reference Counting thread-safe without a GIL is extremely difficult and slow. The GIL made Python easy to integrate with C libraries, which was critical for its early growth.

The Workaround: For true parallelism, Python developers use the multiprocessing module (creating separate processes, each with its own GIL) or rely on libraries like NumPy which release the GIL when doing heavy C-calculations.

5. Stack vs. Heap Memory

Like many languages, Python divides memory into two primary zones. Understanding the distinction helps you grasp Scope and Mutability.

# "Assignment" in Python is actually "Binding"

x = [1, 2, 3]  
# 1. An array [1,2,3] is created in the HEAP (Address 0x123)
# 2. The name 'x' is put on the STACK
# 3. 'x' points to 0x123

y = x
# 1. 'y' is put on the STACK
# 2. 'y' ALSO points to 0x123 (Simply copies the address)

x.append(4)
# We modify the object at 0x123

print(y) 
# Output: [1, 2, 3, 4]
# Because 'y' is looking at the exact same specific object in the Heap.