DEV Community

Beatris Ilieva
Beatris Ilieva

Posted on

Is Python an interpreted or compiled language? How does Python code execution work?

#python

When learning to program, one of the fundamental concepts developers encounter is the distinction between compiled and interpreted languages. Languages like C are often described as "compiled," while Python is called "interpreted." But what does this distinction actually mean? The answer lies in understanding how code is transformed from human-readable instructions into machine code that the CPU (Central Processing Unit) can execute.

Understanding the CPU

The CPU is the brain of the computer. It does all the work—it reads instructions, does calculations, saves information, and makes decisions. The most important thing to know is that the CPU only understands machine code. The CPU cannot understand the code we write in Python or C.

This is the main reason we need compilers and interpreters. They translate our code into machine code so the CPU can understand and follow our instructions.

Another important fact: different computers have different CPUs that speak different "languages." For example, a program written for an Apple MacBook will not work on a Windows laptop without changes. Each computer needs its own special machine code.

What is Compilation?

Compilation is the process of translating an entire program from source code into machine code before execution begins.

When a developer writes code in a compiled language like C, the compiler reads all the source code and translates it completely into machine code. This machine code is specific to the target CPU. The resulting program can then run and the CPU executes it directly.

The Compilation Process in C

Imagine a developer writes a program in C. The compiler reads the entire program and translates it all into machine code before anything runs:

Source Code (original program)
    ↓ [Compiler translates everything]
Machine Code (executable program)
    ↓ [CPU executes it]
Output
Enter fullscreen mode Exit fullscreen mode

This happens only once. After the compilation is done, the program is ready to use. Every time someone runs the program, the CPU executes the machine code directly—no more translation is needed.

Key Characteristics of Compilation

  • Everything is translated first: Before the program runs, the entire code is changed into machine code
  • Errors are found before running: If there are problems with the code, the compiler finds them and stops. The program will not run until the errors are fixed
  • Machine code is made for one type of CPU: If we need the program to work on a different CPU type, the code must be compiled again for that CPU
  • Programs run very fast: Once the program is translated, the CPU runs it directly without anything slowing it down

What is Interpretation?

An interpreter is a program that reads our code and follows the instructions one line at a time. Unlike a compiler, an interpreter does not translate everything first. Instead, it reads each line, understands it, and tells the CPU what to do—all while the program is running.

The Interpretation Process in Python

A developer writes a Python program:

# hello.py
print("Hello, World!")
Enter fullscreen mode Exit fullscreen mode

Then runs it:

python hello.py
Enter fullscreen mode Exit fullscreen mode

Here is what happens:

Source Code (hello.py)
    ↓ [Python interpreter reads each line]
    ↓ [Interpreter tells CPU what to do]
Output: "Hello, World!"
Enter fullscreen mode Exit fullscreen mode

The interpreter reads the code line by line while the program is running. It translates each line and immediately tells the CPU what to do.

Key Characteristics of Interpretation

  • Line by line: The code is read and executed one line at a time while the program runs
  • Errors appear during running: If there is a problem in the code, you only find out when the program reaches that line
  • Works on any computer: The same code can run on Mac, Windows, etc. without any changes
  • Slower execution: The interpreter is working while the program runs, so it is slower than compiled programs

The Development Experience: A Practical Comparison

The differences between compiled and interpreted languages become very apparent during development:

Compiled Language Workflow (C) 

1. Write code in C
2. Translate it all to machine code using compiler
3. If errors exist → Fix code → Go back to step 2
4. If no errors → Run the program
5. Test and look at results
Enter fullscreen mode Exit fullscreen mode

The problem: Every time you change the code, you must translate it all again. For very large programs, this can take a long time.

Interpreted Language Workflow (Python) 

1. Write code in Python
2. Run interpreter: python program.py
3. Observe output immediately
4. If errors exist → Fix code → Go to step 2
5. Code runs immediately; no waiting for compilation
Enter fullscreen mode Exit fullscreen mode

Advantage: Developers see results immediately, enabling rapid iteration and experimentation.

Python's Hybrid Approach: The Best of Both Worlds

Python is neither purely compiled nor purely interpreted. Instead, it uses a hybrid approach that combines benefits of both.

Understanding Bits and Bytes

Before exploring how code is translated, it is important to understand the basic units of computer information.

A bit is the smallest unit of information a computer can understand. It is either 0 or 1 (on or off).

A byte is a group of 8 bits. It is the smallest unit of information that has its own address. This means the computer can locate and save one byte at a specific place in memory. Bytes are used to store all data—numbers, letters, colors, sounds—everything in your computer is made of bytes.

Examples:

  • The letter "A" = 1 byte = 8 bits = 01000001
  • The number "5" = 1 byte = 8 bits = 00000101

All of these bits and bytes form machine code—the special language that computers understand, made only of 0s and 1s, like 10110000.

How Python Actually Works 

Source Code (.py file)
    ↓ [Python compiler - first time only]
Bytecode (.pyc file - cached in __pycache__)
    ↓ [Python interpreter - every execution]
Machine Code (executed by CPU)
Enter fullscreen mode Exit fullscreen mode

Step 1: Compilation to Bytecode

When a Python module is imported for the first time, Python compiles the source code to bytecode—an intermediate format that is simpler than source code but not executable by the CPU.

# user.py
class User:
    def __init__(self, username: str):
        self.username = username
Enter fullscreen mode Exit fullscreen mode

When this module is imported, Python creates:

user.py → compiled to → user.cpython-313.pyc (cached bytecode)
Enter fullscreen mode Exit fullscreen mode

Step 2: Interpretation of Bytecode

Every time the Python program runs, the Python interpreter reads the cached bytecode and translates it to machine code instructions that the CPU can execute.

python program.py (first run)
    → Uses cached .pyc file
    → Interpreter translates bytecode to machine code
    → CPU executes

python program.py (second run)
    → Uses same cached .pyc file
    → Interpreter translates bytecode to machine code again
    → CPU executes
Enter fullscreen mode Exit fullscreen mode

Important note: The __pycache__ directory and .pyc files are created only for imported modules, not for the main script being executed. Python automatically updates these cached bytecode files whenever the source code changes.

Why This Hybrid Approach?

Portability: Bytecode is universal across platforms. The same .pyc file works on Mac, Windows, etc. Different Python interpreters on each platform translate that bytecode to their platform's native machine code.

user.cpython-313.pyc (universal bytecode)
    ↓
    ├─→ [Interpreter on Mac] → machine code → CPU executes
    ├─→ [Interpreter on Windows] → machine code → CPU executes
Enter fullscreen mode Exit fullscreen mode

Development speed: Developers write Python code and see results immediately.

Caching performance: By caching bytecode, Python avoids recompiling the same code repeatedly, providing a performance boost on subsequent runs.

Key Takeaways

  • Compilation translates an entire program to machine code before execution; execution is fast but development iteration is slow
  • Interpretation translates and executes code during runtime; development is fast but execution is slower
  • Machine code is CPU-specific; different computers require different machine code
  • Bytecode is a universal intermediate format that can be translated to different machine code for different computers
  • Python uses a hybrid approach: code is compiled to bytecode once (and cached), then interpreted to machine code each time it runs
  • The __pycache__ directory contains cached bytecode for imported modules, automatically updated when source code changes
  • Understanding these concepts helps explain why Python is faster to develop with but slower to execute than C

Top comments (0)