Is Python Interpreted or Compiled?

The dis module takes the compiled code object of any function, class, or code string and shows it in a readable form. That is the clearest way to show that Python really does compile before it interprets.

import dis

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

dis.dis(add)

The output is a list of instructions, grouped by the line of source code they came from. In Python 3.12 you first see the start of the function. That is RESUME, then a LOAD_FAST for each parameter. After that comes the arithmetic, which is BINARY_OP with the add opcode, then STORE_FAST into total, then LOAD_FAST once more, and then RETURN_VALUE.

What that bytecode is, and what it is not, matters for the interview answer. It is not machine code for your processor. It is an intermediate form for the virtual machine inside CPython, and it does not depend on the kind of computer, in the same way that Java's bytecode does not. CPython saves it in the __pycache__ folder as a .pyc file, so a second run skips the compilation step completely.

Two more points make the answer strong. First, the compilation happens once for each code object, so the cost is paid per module and not per line. For a program that runs for a long time, that cost is not worth thinking about. Second, the bytecode is not a stable public contract. It is an implementation detail, and it changes between CPython versions, which is why nobody writes hand-made CPython bytecode in real projects.

So the precise answer is that Python compiles your source code to bytecode and then runs that bytecode on a virtual machine. Both halves of that sentence are worth saying out loud.

Because Python really does a compilation step before anything is executed. When you run a .py file, CPython reads the source and turns it into a tree that describes the program, compiles that tree into bytecode, and only then hands the bytecode to the loop that runs it. If you write a file with a mistake in its syntax, you get a SyntaxError before a single instruction runs, and that is the proof that a compiler is involved.

You can see the result of that in the caching. After the first run, CPython saves the compiled bytecode next to the source, inside a __pycache__ folder, as a .pyc file. The file name is based on the modification time and the size of the source file. On later runs the source is not compiled again unless it has changed, so the cost of compiling is paid once and then becomes almost nothing.

There is a second layer of detail that makes the answer stronger. Since Python 3.11 the loop that runs the bytecode has been reworked in CPython to be faster, and to adapt itself to the values that it sees. That specialised interpreter technology has been one of the main performance efforts of the 3.11 and 3.12 releases. The result is that a slow loop written in plain Python can run noticeably faster on a newer interpreter, with no change to your code at all.

So a good interview answer is this. Python is an interpreted language, and its implementation compiles to bytecode first. It is not a purely interpreted language, because of that compilation step. It is not a compiled language either, because the bytecode still needs a virtual machine to run it.