How Python is interpreted?

Python is an interpreted programming language, which means that the Python code is not compiled into machine code before execution. Instead, it is executed line by line by the Python interpreter. Here's how the interpretation process works:

Source Code

You write your Python code in a text file with a .py extension, known as the source code file. This file contains the instructions you want the computer to execute.

Lexing and Parsing

When you run the Python script, the Python interpreter first performs lexing and parsing. Lexing involves breaking down the source code into smaller units called tokens, which are the language's keywords, symbols, and identifiers. Parsing involves analyzing the structure of these tokens to build a parse tree, representing the code's syntactic structure.

Bytecode Compilation

Once the parsing is complete, the Python interpreter compiles the source code into bytecode. Bytecode is a low-level representation of the code that is closer to machine code but is still platform-independent.

Execution by Virtual Machine

The bytecode is executed by the Python Virtual Machine (PVM). The PVM is responsible for interpreting the bytecode and executing the corresponding operations. It manages memory, handles exceptions, and controls the flow of execution.

Dynamic Typing

Python is dynamically typed, meaning that variable types are determined at runtime. The interpreter performs type checking and memory management as the code runs.

Step-by-Step Execution

The interpreter executes the bytecode line by line, following the flow of control statements like loops and conditionals. It evaluates expressions, assigns values to variables, and calls functions.

Interaction and Debugging

If you're working in an interactive environment like the Python shell (REPL), you can execute code line by line, seeing immediate results. This is particularly useful for testing and debugging.

Dynamic Interpretation

Python's interpreted nature allows you to modify and run code on the fly without needing to recompile. This is advantageous for rapid development and experimentation.


Python's interpreted nature simplifies the development process as you can focus on writing and testing your code quickly. However, this interpretation process can lead to slower execution speeds compared to languages that are compiled directly into machine code. To mitigate this, Python offers tools like Just-In-Time (JIT) compilers and bytecode optimization techniques to improve performance.