Python compile() Function

Spread the love

Python, an interpreted language, internally translates its source code into a format known as bytecode—a lower-level, platform-independent representation of source code. The compile() function in Python provides an interface to this internal translation mechanism, allowing users to convert a string into a code object that can be executed or evaluated. In this article, we will unpack the intricacies of the compile() function, its use cases, and its significance in dynamic code execution.

Introduction to compile( )

At its heart, the compile() function takes a source string, converts it into a code object, which can later be executed using functions like exec() or evaluated using eval().

Basic Syntax

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

compile() Parameters

  • source: The string to be converted.
  • filename: The file from which the code was read. If it wasn’t read from a file, you can give a name yourself.
  • mode: Specifies the kind of code to be compiled. It can be exec (if source consists of a sequence of statements), eval (if it consists of a single expression), or single (if it consists of a single interactive statement).

compile() Return Value

The compile( ) function returns a python object code.


Imagine you’re building a calculator application that allows users to enter a mathematical expression as a string, and you need to evaluate it. You could use the compile() function to transform this string into executable Python code and then evaluate it.


  1. User Input: Gather a mathematical expression as a string.
  2. Compile the Expression: Convert the expression string into a code object using the compile() function.
  3. Evaluate the Code Object: Use the eval() function to evaluate the compiled code object.
def evaluate_expression(expression_str: str) -> float:
    Compiles and evaluates a mathematical expression provided as a string.

    - expression_str (str): The mathematical expression in string format.

    - float: The result of the evaluated expression.

    # Step 2: Compile the Expression
    compiled_expression = compile(expression_str, '<user_input>', 'eval')

    # Step 3: Evaluate the Code Object
    result = eval(compiled_expression)

    return result

# Usage:

expression = input("Enter a mathematical expression: ")  # Let's say the user enters 3 + 4 * 2
print(f"Result: {evaluate_expression(expression)}")  # Outputs: Result: 11.0

This function, evaluate_expression, serves as a bridge between raw mathematical expressions provided as strings and their evaluated results. By using compile(), we can efficiently and dynamically handle various expressions the user might input.

Note of Caution:

Handling user input always presents risks, especially when compiling and executing it. Always ensure you have proper validation and sanitation mechanisms in place to prevent malicious code injection.

Advantages of Using compile( )

Dynamic Code Execution

One of the most significant benefits of compile() is dynamic code execution. It’s especially handy when you need to generate and execute code during runtime. For instance, you might be building a tool that generates Python scripts based on certain inputs.


If you’re planning to execute the same dynamically-generated code multiple times, compiling it once and executing the compiled code can be more efficient than interpreting the same code repeatedly.

Modes of Compilation

As mentioned, the compile() function supports three modes:

exec Mode:

Suitable for sequences of statements like loops or function definitions. The returned code object, when executed, doesn’t return a value.

code = """
def greet(name):
    return f"Hello, {name}"

compiled_code = compile(code, '<string>', 'exec')
print(greet("Alice"))  # Outputs: Hello, Alice

eval Mode:

Used for single expressions. The resulting code object, when evaluated, returns a value.

expression = "5 + 5"
compiled_expression = compile(expression, '<string>', 'eval')
result = eval(compiled_expression)
print(result)  # Outputs: 10

single Mode:

Meant for single interactive statements. Useful in situations like a Python shell where expressions are executed, and the results are printed.

Flags and Customizations

The compile() function provides parameters beyond just the source string, filename, and mode. These additional parameters—namely, flags and dont_inherit—offer further customizations to the compilation process, enabling more fine-tuned control over how the source string is compiled.

flags Parameter

The flags parameter allows you to modify the default behavior of the compiler. It accepts a combination (bitwise OR) of various constants defined in the ast module. Some of the more notable flags include:

  • ast.PyCF_ONLY_AST: Instead of returning a code object, this flag instructs the compiler to return the Abstract Syntax Tree (AST) of the source. The AST represents the syntactic structure of the code, making it useful for code analysis or transformations.
import ast

source = "x = 5"
tree = compile(source, filename='<ast>', mode='exec', flags=ast.PyCF_ONLY_AST)
print(type(tree))  # Outputs: <class '_ast.Module'>

There are other flags related to handling future statements, like __future__.division or __future__.print_function, but their use is less common in contemporary Python versions.

dont_inherit Parameter

The dont_inherit parameter is a boolean that, when set to True, prevents the compilation from inheriting the effects of any future statements in effect. Future statements are directives that enable features which will be present in subsequent versions of Python but are not the default in the current version.

By setting dont_inherit to True, you can ensure that your compiled code doesn’t accidentally adopt behaviors from future statements that may have been activated elsewhere in your codebase.

For instance, consider using the print function in Python 2.x. By default, print was a statement in Python 2.x. However, you could activate the Python 3.x behavior (where print is a function) using a future statement:

from __future__ import print_function

# ... later in your code ...

source = "print('Hello, World!')"
compiled_code = compile(source, filename='<string>', mode='exec', dont_inherit=True)

By setting dont_inherit=True, the above compilation would raise a syntax error in Python 2.x, since it wouldn’t inherit the future print_function behavior.

Considerations and Cautions

Security Concerns

Executing dynamic code can be risky, as it opens the door to code injections. It’s crucial to ensure that the source strings passed to compile() come from trusted sources and are sanitized.


Debugging dynamically compiled code can be trickier than regular Python code. Errors might not be straightforward, given the additional layer of compilation and execution.


The compile() function in Python is a powerful tool, allowing for dynamic code generation and execution. Whether you’re building development tools, experimenting in an interactive shell, or optimizing repeated code execution, compile() offers a way to bridge between raw Python strings and executable code objects. However, with great power comes great responsibility—ensure that you’re aware of the security implications and potential pitfalls before diving in.

Leave a Reply