Python exec() Function

Spread the love

The exec() function is a built-in Python function that dynamically executes Python programs which can either be a string or object code. Essentially, it allows for the execution of Python statements or expressions that are represented as strings.

exec() Syntax

The syntax of exec( ) is

exec(object, globals, locals)

exec() Parameters

The exec( ) method takes three parameters:

  • object – Either a string or a code object
  • globals (optional) – a dictionary
  • locals (optional) – a mapping object (commonly dictionary)

exec() Return Value

The exec( ) method doesn’t return any value.

Basic Usage of exec( )

The exec() function is designed to execute dynamically created Python code. This code is passed to the function as a string. The main strength of exec() lies in its ability to execute not just single Python expressions but full-fledged multi-line code, including loops, conditionals, and function definitions.

Single Line Execution

When you want to execute a single line of Python code, you simply pass it as a string to exec().


exec('a = 7')
print(a)  # Outputs: 7

In the example above, the string 'a = 7' is a Python statement that assigns the value 7 to the variable a. After calling exec(), the variable a is indeed assigned that value, and can be used like any other variable in your code.

Multi-Line Execution

The power of exec() shines when you want to execute multiple lines of code. You can pass a multi-line string (enclosed in triple quotes) to the exec() function.


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

message = greet('Bob')

print(message)  # Outputs: Hello, Bob!

In this example, we defined a function greet() inside the string and also called that function, storing its return value in the message variable. After the exec() call, we can access the message variable normally and print its value.

Blocking unnecessary methods and variable in exec()

When you’re using the exec() function in Python, especially with code that comes from untrusted sources or user inputs, there’s a risk of executing malicious code. One way to mitigate these risks is by blocking or limiting access to certain built-in methods, classes, or variables that could be used in harmful ways.

To restrict access to potentially harmful functions, classes, or variables in the exec() function, you can explicitly define the global and local contexts in which the code runs.

How to Block Access:

  1. Defining Restricted Globals Dictionary: You can create a dictionary that includes only the necessary functions or variables that should be accessible and pass this dictionary as the globals context to exec().
  2. Removing Methods from Builtins: Python’s builtins module contains a set of standard built-in functions and types. By removing or overriding specific methods from a copy of the builtins dictionary, you can block access to them.


Let’s see an example of how to restrict the exec() environment:

def safe_exec(code):
    # Define allowed built-ins:
    allowed_builtins = ["print", "range"]

    # Create a copy of the builtins dictionary and filter it:
    safe_builtins = {k: v for k, v in __builtins__.__dict__.items() if k in allowed_builtins}

    # Define safe globals and locals:
    safe_globals = {"__builtins__": safe_builtins}
    safe_locals = {}

    exec(code, safe_globals, safe_locals)

# Test the safe_exec function:
code = """
print("This should work!")
x = 5 + 5
open("some_file.txt", "w")  # This should raise an error since 'open' is not allowed


In the example above:

  • We defined a function safe_exec() that intends to safely execute a block of code.
  • We limited the allowed built-ins to just print and range.
  • We filtered the __builtins__ dictionary to contain only our allowed built-ins.
  • We then executed the code using these restricted global and local dictionaries.
  • As a result, functions like open() (which could be used for file operations and therefore might pose a security risk) are not accessible and will raise an error if the code attempts to use them.

Why This is Important:

  • Prevent File Access: By restricting functions like open(), you can prevent unauthorized file reading/writing.
  • Avoid System Commands: Restricting the os module and its functions can prevent execution of arbitrary system commands.
  • Limit Resource Consumption: Blocking or limiting certain constructs can prevent resource-exhausting operations, like creating large data structures.

While limiting the environment for exec() can reduce risks, it’s essential to be aware that completely securing exec() is challenging. Always be wary of executing untrusted code, even in a restricted environment. If possible, consider safer alternatives for your use case.


The exec() function offers a dynamic way to execute Python code. Whether you’re running a single line or multiple lines, exec() handles it seamlessly. However, as with any tool that executes dynamic code, it’s crucial to use it judiciously and be aware of its potential risks, especially when working with untrusted input.

Leave a Reply