Python compile()

Python compile() function allows you to transform source code into a code object that can be executed later. Instead of directly running code from a string or a file, compile() converts it into an intermediate form that Python can work with more efficiently.
Table of Contents

Understanding Python compile() Function

Python compile() function is a built-in function that transforms a string of Python code, a file path, or an AST object into a code object that can be executed later using exec() or eval(). This allows you to generate and run Python code at runtime dynamically. It’s a powerful function for advanced programming scenarios where you might not know the exact code to execute until the program runs. This function accepts string, file, or AST as input and generates code object as an output, which can be used later.

Syntax of Python compile()

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

Explanation

  • code_object: Variable will hold the compiled code object returned by the function.
  • compile(): Built-in function that compiles the source into a code object.
  • source: Source code you want to compile (a string, a file object or AST object). It is the input for the compile() function.
  • filename: String giving the name of the file the code was read from.
  • mode: String specifying the type of code to compile (‘exec’, ‘eval’, or ‘single’).
  • flags (optional): Parameter controls which future statements affect the semantics of the compilation.
  • dont_inherit (optional): If true, stops the compilation from inheriting the effects of any future statements in effect.
  • optimize (optional): Specifies the optimization level of the compiler.

Example of Python compile()

code_string = "x = 5\ny = 10\nprint(x + y)"
code_object = compile(code_string, "<string>", "exec")
exec(code_object)

Explanation

  • code_string = "x = 5\ny = 10\nprint(x + y)": Creates a string containing Python code.
  • code_object = compile(code_string, "<string>", "exec"): Compiles the string into a code object using compile().
  • exec(code_object): Executes the compiled code object.

Output

15


compile() Parameters

Python compile() function accepts several parameters that control how the source code is compiled. The source parameter is the code you want to compile: a string, a file object, or an AST object. The filename parameter represents the file name from which the code was read (used in error messages). The mode parameter specifies what kind of code you’re compiling: ‘exec’ for a sequence of statements, ‘eval’ for a single expression, or ‘single’ for a single interactive statement. The optional flags and dont_inherit parameters control how future statements affect compilation, and optimize specifies the optimization level for the compiler.

Syntax

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

Example

code_str = "print('Hello, world!')"
code_object = compile(code_str, 'my_code', 'exec')
exec(code_object)

Explanation

  • code_str = "print('Hello, world!')": Defines a string containing a simple print statement.
  • code_object = compile(code_str, 'my_code', 'exec'): Compiles code_str into a code object. Here ‘my_code’ is used as filename parameter.
  • exec(code_object): Executes the compiled code object, printing “Hello, world!”.

Output

Hello, world!


compile() Return Value

Python compile() function returns a code object, an internal Python representation of executable code. This code object can be executed later using the exec() or eval() functions. It’s important to note that compile() itself doesn’t execute the code; it merely transforms it into a form that can be executed later. The type of code object returned depends on the mode parameter used during compilation: ‘exec’ returns a code object for a sequence of statements, ‘eval’ returns a code object for a single expression, and ‘single’ returns a code object for a single interactive statement.

Example

code_string = "a = 10; b = 20; print(a * b)"
code_object = compile(code_string, "<string>", "exec")
exec(code_object)

Explanation

  • code_string = "a = 10; b = 20; print(a * b)": Creates a string containing multiple Python statements.
  • code_object = compile(code_string, "<string>", "exec"): Compiles code_string into a code object.
  • exec(code_object): Executes the compiled code object.

Output

200


Dynamic Code Generation with Python compile()

One of the powerful applications of Python compile() is dynamic code generation. This means you can create strings of Python code at runtime based on user input, data from a file, or any other logic in your program and then compile these strings into code objects that can be executed. This allows you to create highly flexible and adaptable programs that can change their behavior based on dynamic conditions.

Syntax

code_object = compile(dynamically_generated_code_string, filename, mode)

Example

user_input = input("Enter a number: ")
code_string = f"result = int('{user_input}') * 2\nprint(result)"
code_object = compile(code_string, "<user_input>", "exec")
exec(code_object)

Explanation

  • user_input = input("Enter a number: "): Prompts the user to enter a number and stores the input as a string.
  • code_string = f"result = int('{user_input}') * 2\nprint(result)": Creates a string of Python code that uses the user’s input.
  • code_object = compile(code_string, "<user_input>", "exec"): Compiles the code_string into a code object.
  • exec(code_object): Executes the compiled code.

Output

Enter a number: 5
10


Converting String to Python Code Object

You can use Python compile() to convert a string containing Python code into a code object. You pass the string as the source argument to the compile() function, along with a filename (which can be a descriptive string like “<string>”) and the appropriate mode. This is the most common way to use compile(), as it allows you to treat a piece of text as executable Python code.

Example

code_str = "result = 5 + 5\nprint('Result is:', result)"
code_object = compile(code_str, '<string>', 'exec')
exec(code_object)

Explanation

  • code_str = "result = 5 + 5\nprint('Result is:', result)": Creates a string code_str containing Python code.
  • code_object = compile(code_str, '<string>', 'exec'): Compiles code_str into a code object using ‘exec’ mode.
  • exec(code_object): Executes the compiled code object, which calculates 5 + 5 and prints the result.

Output

Result is: 10


Python Compile function from File

Python compile() function can also compile code read from a file. To do this, you first open the file in read mode using open(), read its contents using .read(), and then pass the resulting string to compile(). You should provide the actual filename as the filename argument to compile() so that any errors can be traced back to the correct file. This approach helps execute code stored externally rather than embedded directly in your script.

Syntax

with open(filename, 'r') as file:
    code_string = file.read()
code_object = compile(code_string, filename, mode)

Explanation

  • with open(filename, 'r') as file:: Opens the file in read mode.
  • code_string = file.read(): Reads the entire file content into code_string.
  • code_object = compile(code_string, filename, mode): Compiles the code string, using filename for error reporting, and mode to specify the type of compilation. It is the input for compile().

Example

# Create a file named "my_script.py" with the following content:
# print("Hello from file!")

with open("my_script.py", "r") as file:
    code_str = file.read()

code_object = compile(code_str, "my_script.py", "exec")
exec(code_object)

Explanation

  • with open("my_script.py", "r") as file:: Opens “my_script.py” in read mode and assigns the file object to file.
  • code_str = file.read(): Reads the entire content of file into code_str.
  • code_object = compile(code_str, "my_script.py", "exec"): Compiles code_str into a code object, associating it with “my_script.py”.
  • exec(code_object): Executes the compiled code object.

Output

Hello from file!


Compile() with eval()

When you use Python compile() with the mode set to ‘eval,’ it compiles the source into a code object that can be evaluated as a single expression using the eval() function. The eval() function executes the compiled code object and returns the expression’s result. This combination is useful when you need to evaluate expressions dynamically. Still, it’s important to use it cautiously, especially with user-supplied input, as eval() can pose security risks if not handled carefully.

Syntax

code_object = compile(expression_string, filename, 'eval')
result = eval(code_object)

Explanation

  • code_object: Variable will hold the compiled code object for the expression.
  • compile(): Function compiles the expression string into a code object.
  • expression_string: String containing a single Python expression. It is used as input for compile().
  • filename: String representing the filename (often “<string>” for strings).
  • 'eval': Sets the mode to ‘eval’, indicating that the source is a single expression.
  • result: Variable will store the result of evaluating the expression.
  • eval(): Function evaluates the compiled code object and returns the result.

Example

expression = "5 * 10 + 2"
code_object = compile(expression, "<string>", "eval")
result = eval(code_object)
print(result)

Explanation

  • expression = "5 * 10 + 2": Creates a string containing a Python expression.
  • code_object = compile(expression, "<string>", "eval"): Compiles the expression into a code object using ‘eval’ mode.
  • result = eval(code_object): Evaluates the compiled code object and stores the result in result.
  • print(result): Prints the result, which is the evaluated value of the expression.

Output

52


Conclusion

Python compile() is a powerful function for dynamically generating and compiling Python code at runtime. It can handle code from strings, files, or AST objects, offering fine-grained control over the compilation process through its various parameters. Understanding how to use Python compile effectively, along with exec() and eval(), opens up possibilities for advanced programming techniques like metaprogramming, dynamic code evaluation, and creating flexible, adaptable applications. However, using these features responsibly, particularly when dealing with dynamically generated code, is crucial to avoid potential security risks. Remember that compile() always returns a code object as output, which can be executed using exec() or eval().


Also Read

Python chr()

Python classmethod()


Python Reference

python compile()

Table of Contents