{"id":85,"date":"2023-04-02T01:29:25","date_gmt":"2023-04-02T01:29:25","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=85"},"modified":"2023-08-23T16:22:34","modified_gmt":"2023-08-23T16:22:34","slug":"dynamic-code-generation-execution-pythons-exec-eval","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/dynamic-code-generation-execution-pythons-exec-eval\/","title":{"rendered":"Dynamic Code Generation & Execution with Python’s exec and eval"},"content":{"rendered":"\n

In the field of programming, the power of flexibility and adaptability cannot be overstated. One such powerful concept is dynamic code generation and execution, a process that provides programs with the ability to create and execute code on-the-fly, thereby enabling unparalleled flexibility in how they operate. This technique, a prominent feature in many programming languages, allows the code to write and execute other pieces of code, bringing an additional layer of dynamism and functionality to the system.<\/p>\n\n\n\n

Python, renowned for its simplicity and efficiency, is not left out of this concept. The language offers two native functions – exec<\/code> and eval<\/code>, which allow for dynamic code execution and evaluation, respectively. The exec<\/code> function is used to dynamically run Python program which can be a string or object code. On the other hand, eval<\/code> parses the expression passed to it and executes python code within the program. These two powerful tools can significantly enhance the efficiency of Python programs, allowing them to adapt and evolve based on their input and environment.<\/p>\n\n\n\n

This article is tailored for intermediate to advanced Python developers, who already possess a firm understanding of Python syntax and are comfortable with concepts such as functions, loops, and classes. It is not recommended for absolute beginners, as a solid grasp of Python’s basics is essential to comprehend and utilize exec<\/code> and eval<\/code> effectively. As we delve deeper, we will provide practical code examples and real-life scenarios to better illustrate the usage and application of these functions, and ensure a robust, hands-on understanding. Let’s dive into the power of dynamic code generation and execution with Python’s exec<\/code> and eval<\/code>.<\/p>\n\n\n\n

Overview of exec<\/code> and eval<\/code> functions<\/h2>\n\n\n\n

Python, in its vast expanse of built-in functions and capabilities, provides two unique functions\u2014exec<\/code> and eval<\/code>. These functions bring dynamic code execution and evaluation into the Python programming world, offering a multitude of capabilities that otherwise would be challenging to achieve.<\/p>\n\n\n\n

Definition of exec<\/code> and eval<\/code> functions in Python<\/h3>\n\n\n\n

exec<\/code>:<\/strong> The exec<\/code> function is a built-in Python function used to execute dynamically created programmable strings. exec<\/code> takes in a single argument, which can be a string, an object code, or a callable Python object. The string or code is then executed as a Python program, allowing Python scripts to generate and run other Python scripts during execution.<\/p>\n\n\n\n

eval<\/code>:<\/strong> The eval<\/code> function, on the other hand, evaluates a Python expression that’s been passed to it as a string. The expression can be a Python statement, or a code object. The function then parses the expression, executes it, and returns the result.<\/p>\n\n\n\n

Difference between exec<\/code> and eval<\/code><\/h3>\n\n\n\n

The key difference between exec<\/code> and eval<\/code> lies in their purpose and their return values.<\/p>\n\n\n\n

While both functions execute Python code dynamically, eval<\/code> is used for simple expressions and returns the result of the evaluated expression. On the other hand, exec<\/code> can handle complex code blocks with multiple lines of code, but it does not return any result. In simple terms, eval<\/code> evaluates a single dynamically provided expression and returns its value, while exec<\/code> executes dynamically provided code but does not return anything.<\/p>\n\n\n\n

Additionally, exec<\/code> can alter the state of the program by changing the values of variables or even defining new ones, whereas eval<\/code> is purely for evaluating an expression and getting a result, without any side effects on the program state.<\/p>\n\n\n\n

Example of simple usage of exec<\/code> and eval<\/code><\/h3>\n\n\n\n

Let’s look at basic examples of exec<\/code> and eval<\/code> in action:<\/p>\n\n\n\n

exec<\/code>:<\/h4>\n\n\n
code = \"\"\"\ndef say_hello(name):\n    return f'Hello, {name}!'\n\"\"\"<\/span>\n\nexec(code)\nprint(say_hello('World'<\/span>))  # Prints: Hello, World!<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In the above snippet, a multi-line Python code is defined as a string and passed to the exec<\/code> function, which then executes the code, defining a new function say_hello<\/code>. This function is later invoked to print a greeting.<\/p>\n\n\n\n
eval<\/code>:<\/h4>\n\n\n
expression = \"2 * 3 + 5\"<\/span>\nresult = eval(expression)\nprint(result)  # Prints: 11<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In this eval<\/code> example, a string containing a simple arithmetic expression is evaluated, and the result (11) is printed out.<\/p>\n\n\n\n
Both exec<\/code> and eval<\/code> serve as powerful tools for enhancing the dynamism and functionality of Python programs. However, their usage requires careful consideration and good understanding of their implications, which we will further explore in the subsequent sections.<\/p>\n\n\n\n
Deep Dive into exec<\/code> function<\/h2>\n\n\n\n
The exec<\/code> function is an integral part of Python’s capabilities, enabling the dynamic execution of Python programs. With exec<\/code>, you can create and run code that didn’t exist when your script started, or that’s not known until runtime. Let’s delve deeper into the function’s syntax, practical examples, and advanced use cases.<\/p>\n\n\n\n
Syntax and Parameters of exec<\/code><\/h3>\n\n\n\n
The syntax for the exec<\/code> function is as follows:<\/p>\n\n\n
exec(object[, globals[, locals]])<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    \n
  • object<\/strong>: This is a mandatory parameter that can be a string, an object code, or a callable Python object. It contains the code to be executed.<\/li>\n\n\n\n
  • globals<\/strong>: This is an optional parameter representing a dictionary containing global parameters. If provided, it must be a dictionary.<\/li>\n\n\n\n
  • locals<\/strong>: This is another optional parameter, a dictionary that contains local parameters for the code. If provided, it must be a dictionary.<\/li>\n<\/ul>\n\n\n\n
    If both globals<\/code> and locals<\/code> are omitted, the code executes in the current scope. If globals<\/code> is provided but locals<\/code> is omitted, locals<\/code> defaults to globals<\/code>.<\/p>\n\n\n\n
    Practical Examples of exec<\/code> with Code Samples<\/h3>\n\n\n\n
    Here’s an example that demonstrates the basic usage of the exec<\/code> function:<\/p>\n\n\n
    # Define a string with Python code<\/span>\ncode_string = \"\"\"\ndef greet(name):\n    print(f'Hello, {name}!')\n\"\"\"<\/span>\n\n# Execute the code string<\/span>\nexec(code_string)\n\n# Call the newly defined function<\/span>\ngreet('Alice'<\/span>)  # Outputs: Hello, Alice!<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this example, exec<\/code> is used to dynamically define a new function greet<\/code>, which is then called with the argument ‘Alice’.<\/p>\n\n\n\n
    The exec<\/code> function can also be used with the globals<\/code> and locals<\/code> parameters. Let’s see how:<\/p>\n\n\n
    # Define a string with Python code<\/span>\ncode_string = \"\"\"\nresult = a + b\n\"\"\"<\/span>\n\n# Define global and local parameters<\/span>\nglobal_parameters = {'a'<\/span>: 5<\/span>, 'b'<\/span>: 10<\/span>}\nlocal_parameters = {}\n\n# Execute the code string<\/span>\nexec(code_string, global_parameters, local_parameters)\n\n# Print the result<\/span>\nprint(local_parameters['result'<\/span>])  # Outputs: 15<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this example, exec<\/code> is used to execute a code string that performs an addition operation. The variables a<\/code> and b<\/code> are provided through the globals<\/code> dictionary, and the result of the operation is stored in the locals<\/code> dictionary.<\/p>\n\n\n\n
    Advanced Use-Cases and Caveats<\/h3>\n\n\n\n
    The exec<\/code> function is extremely powerful and offers a wide range of possibilities for dynamically creating and executing code. For instance, you could use exec<\/code> to build a flexible system that executes user-defined code (with proper precautions), or to dynamically import modules and utilize their functions based on runtime conditions.<\/p>\n\n\n\n
    However, it’s important to remember that with great power comes great responsibility. The exec<\/code> function should be used sparingly and with great caution. Executing dynamically generated code can introduce a number of potential issues, including security vulnerabilities if the input isn’t properly sanitized, and increased debugging complexity due to the dynamic nature of the code. It’s also generally considered poor style to rely heavily on exec<\/code> for things that could be accomplished with Python’s standard static syntax.<\/p>\n\n\n\n
    Deep Dive into eval<\/code> function<\/h2>\n\n\n\n
    The eval<\/code> function is another dynamic execution function provided by Python, primarily used to evaluate simple Python expressions. Despite its simplicity, eval<\/code> is a flexible tool that can significantly enhance the interactivity and adaptability of Python applications.<\/p>\n\n\n\n
    Syntax and Parameters of eval<\/h3>\n\n\n\n
    The syntax of the eval<\/code> function in Python is:<\/p>\n\n\n
    eval(expression[, globals[, locals]])<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
      \n
    • expression<\/strong>: This is a mandatory parameter, which should be a string parsed as a Python expression.<\/li>\n\n\n\n
    • globals<\/strong>: This optional parameter is a dictionary containing global variables. If provided, it must be a dictionary.<\/li>\n\n\n\n
    • locals<\/strong>: This optional parameter is a dictionary containing local variables. If provided, it must be a dictionary.<\/li>\n<\/ul>\n\n\n\n
      Similar to exec<\/code>, when both globals<\/code> and locals<\/code> are omitted, the expression is executed in the current scope. If globals<\/code> is provided but locals<\/code> is omitted, locals<\/code> defaults to globals<\/code>.<\/p>\n\n\n\n
      Practical Examples of eval<\/code> with Code Samples<\/strong><\/p>\n\n\n\n
      Here’s an example illustrating the basic usage of the eval<\/code> function:<\/p>\n\n\n
      # Define a string with a Python expression<\/span>\nexpression = \"2 + 3 * 4\"<\/span>\n\n# Evaluate the expression<\/span>\nresult = eval(expression)\n\n# Print the result<\/span>\nprint(result)  # Outputs: 14<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
      In this example, eval<\/code> is used to evaluate a string that contains a simple arithmetic expression.<\/p>\n\n\n\n
      The eval<\/code> function can also be used with the globals<\/code> and locals<\/code> parameters. Let’s see an example:<\/p>\n\n\n
      # Define a string with a Python expression<\/span>\nexpression = \"a + b\"<\/span>\n\n# Define global and local parameters<\/span>\nglobal_parameters = {'a'<\/span>: 5<\/span>}\nlocal_parameters = {'b'<\/span>: 10<\/span>}\n\n# Evaluate the expression<\/span>\nresult = eval(expression, global_parameters, local_parameters)\n\n# Print the result<\/span>\nprint(result)  # Outputs: 15<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
      In this example, eval<\/code> is used to evaluate an expression that includes the variables a<\/code> and b<\/code>, which are provided through the globals<\/code> and locals<\/code> dictionaries.<\/p>\n\n\n\n
      Advanced Use-Cases and Caveats<\/h3>\n\n\n\n
      The eval<\/code> function can be used in various advanced scenarios, such as evaluating mathematical expressions entered by users, or parsing and evaluating data received in string format.<\/p>\n\n\n\n
      However, as with exec<\/code>, caution must be exercised when using eval<\/code>. Given that it evaluates Python expressions from strings, it can pose a serious security risk if the input isn’t thoroughly validated. Malicious code can be executed if eval<\/code> is used on unsanitized user inputs.<\/p>\n\n\n\n
      Additionally, the eval<\/code> function can make debugging more difficult due to its dynamic nature, and it can also lead to poor programming practices if overused.<\/p>\n\n\n\n
      Security Considerations with exec<\/code> and eval<\/code><\/h2>\n\n\n\n
      While exec<\/code> and eval<\/code> offer significant flexibility in Python programming, they also come with potential security risks if misused. This section delves into these risks and provides best practices and alternatives for safely utilizing these functions.<\/p>\n\n\n\n
      Potential Security Risks of Using exec<\/code> and eval<\/code><\/h3>\n\n\n\n
      The most significant security risk with exec<\/code> and eval<\/code> arises when these functions are used to execute or evaluate code or expressions derived from untrusted or unsanitized sources, such as user inputs or data received over the network. These functions can execute arbitrary Python code, which means that an attacker could potentially execute malicious code, leading to data leaks, unauthorized data modification, or even complete system takeover.<\/p>\n\n\n\n
      For instance, an expression like eval(input())<\/code> or exec(input())<\/code> can be exploited by an attacker to perform arbitrary operations, like file deletion (eval(\"__import__('os').system('rm -rf \/')\")<\/code>), which would delete all files in the system if the Python script has sufficient permissions.<\/p>\n\n\n\n
      Best Practices for Safely Using exec<\/code> and eval<\/code><\/h3>\n\n\n\n
      Given the potential security risks, here are some best practices for safely using exec<\/code> and eval<\/code>:<\/p>\n\n\n\n
        \n
      1. Avoid Unnecessary Usage<\/strong>: Avoid using exec<\/code> and eval<\/code> whenever possible, especially when there are safer alternatives that achieve the same result.<\/li>\n\n\n\n
      2. Never Use with Untrusted Input<\/strong>: Never use exec<\/code> or eval<\/code> with unsanitized or untrusted inputs. This can open the door for code injection attacks.<\/li>\n\n\n\n
      3. Limit Scope<\/strong>: If you must use these functions, limit their scope by passing empty dictionaries to the globals<\/code> and locals<\/code> parameters. This will prevent the executed code from accessing or modifying the actual global and local namespaces.<\/li>\n<\/ol>\n\n\n\n
        Alternatives and Safe Usage Scenarios<\/h3>\n\n\n\n
        There are safer alternatives for certain use cases of exec<\/code> and eval<\/code>. For example, if you’re evaluating mathematical expressions, consider using ast.literal_eval()<\/code>, which only evaluates literals and is therefore much safer:<\/p>\n\n\n
        import<\/span> ast\n\nexpression = \"[1, 2, 3] + [4, 5, 6]\"<\/span>\nresult = ast.literal_eval(expression)\nprint(result)  # Outputs: [1, 2, 3, 4, 5, 6]<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
        For more complex use cases, you might want to consider creating custom parsers or utilizing libraries designed for that purpose.<\/p>\n\n\n\n
        In scenarios where exec<\/code> and eval<\/code> are necessary, you can use them more safely by minimizing their scope:<\/p>\n\n\n
        # Safer usage of exec<\/span>\ncode = \"a = 5\"<\/span>\nglobals_ = {}\nlocals_ = {}\nexec(code, globals_, locals_)\nprint(locals_)  # Outputs: {'a': 5}<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
        In this example, an empty dictionary is passed as globals<\/code> and locals<\/code> to exec<\/code>, limiting the scope of the executed code. This prevents the code from accessing or modifying the actual global and local namespaces, mitigating potential risks.<\/p>\n\n\n\n
        Practical Application: Dynamic Code Generation<\/h2>\n\n\n\n
        Dynamic code generation, which involves creating and executing code on the fly during program execution, is a powerful technique that can greatly enhance the flexibility and adaptability of software. Python’s exec<\/code> and eval<\/code> functions enable this capability, providing an interface to execute or evaluate Python code dynamically.<\/p>\n\n\n\n
        Explanation of Dynamic Code Generation and Its Benefits<\/h3>\n\n\n\n
        Dynamic code generation refers to the creation and execution of code during runtime, as opposed to the static code which is written before a program is run. This approach can enable a software system to adapt to changes in requirements or conditions during its execution.<\/p>\n\n\n\n
        The benefits of dynamic code generation include:<\/p>\n\n\n\n
          \n
        • Flexibility<\/strong>: Dynamic code generation can enable a program to adapt its behavior based on runtime conditions, user input, or other factors.<\/li>\n\n\n\n
        • Efficiency<\/strong>: In some cases, dynamic code generation can be used to optimize performance by generating specialized versions of functions or algorithms based on the specific data they are processing.<\/li>\n\n\n\n
        • Interactivity<\/strong>: Dynamic code generation can enhance the interactivity of a program, such as by allowing users to define custom functions or calculations.<\/li>\n<\/ul>\n\n\n\n
          Step-by-step Guide on Creating Dynamic Code with exec<\/code> and eval<\/code><\/h3>\n\n\n\n
          Let’s explore a practical application of dynamic code generation using exec<\/code> and eval<\/code> through a simple interactive calculator.<\/p>\n\n\n\n
          Define the Calculator Function<\/strong>: The calculator function will take an arithmetic expression as a string and evaluate it using the eval<\/code> function:<\/p>\n\n\n
          def<\/span> calculator<\/span>(expression)<\/span>:<\/span>\n    try<\/span>:\n        return<\/span> eval(expression)\n    except<\/span> Exception as<\/span> e:\n        print(f\"Invalid expression: {e}<\/span>\"<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
          Interact with the User<\/strong>: The program interacts with the user, accepting input for arithmetic expressions and using the calculator function to evaluate them:<\/p>\n\n\n
          while<\/span> True<\/span>:\n    expression = input(\"Enter an arithmetic expression (or 'q' to quit): \"<\/span>)\n    \n    if<\/span> expression.lower() == 'q'<\/span>:\n        break<\/span>\n\n    result = calculator(expression)\n\n    if<\/span> result is<\/span> not<\/span> None<\/span>:\n        print(f\"Result: {result}<\/span>\"<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
          Practical Examples and Results Analysis<\/h3>\n\n\n\n
          Running the above interactive calculator program allows users to enter arithmetic expressions, which are evaluated dynamically. Here are some example inputs and outputs:<\/p>\n\n\n\n
            \n
          • Input: 2 + 3 * 4<\/code><\/li>\n\n\n\n
          • Output: 14<\/code><\/li>\n\n\n\n
          • Input: (2 + 3) * 4<\/code><\/li>\n\n\n\n
          • Output: 20<\/code><\/li>\n\n\n\n
          • Input: 2 +<\/code><\/li>\n\n\n\n
          • Output: Invalid expression: invalid syntax<\/code><\/li>\n<\/ul>\n\n\n\n
            The program correctly evaluates valid arithmetic expressions and provides appropriate error messages for invalid ones. This demonstrates the use of eval<\/code> for dynamic code evaluation in a simple yet practical application.<\/p>\n\n\n\n
            However, remember that this calculator program should not be exposed to untrusted users or used with untrusted inputs, as it could be vulnerable to code injection attacks.<\/p>\n","protected":false},"excerpt":{"rendered":"
            In the field of programming, the power of flexibility and adaptability cannot be overstated. One such powerful concept is dynamic code generation and execution, a process that provides programs with the ability to create and execute code on-the-fly, thereby enabling unparalleled flexibility in how they operate. This technique, a prominent feature in many programming languages, […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_post_was_ever_published":false},"categories":[4,6],"tags":[],"class_list":["post-85","post","type-post","status-publish","format-standard","category-programming-languages","category-python","entry"],"yoast_head":"\nDynamic Code Generation & Execution with Python's exec and eval<\/title>\n<meta name=\"description\" content=\"Explore dynamic code generation and execution with Python's powerful exec and eval functions. Uncover use cases, performance considerations,\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.w3computing.com\/articles\/dynamic-code-generation-execution-pythons-exec-eval\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Dynamic Code Generation & Execution with Python's exec and eval\" \/>\n<meta property=\"og:description\" content=\"Explore dynamic code generation and execution with Python's powerful exec and eval functions. Uncover use cases, performance considerations,\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/dynamic-code-generation-execution-pythons-exec-eval\/\" \/>\n<meta property=\"article:published_time\" content=\"2023-04-02T01:29:25+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-08-23T16:22:34+00:00\" \/>\n<meta name=\"author\" content=\"w3compadmin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"w3compadmin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"7 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/dynamic-code-generation-execution-pythons-exec-eval\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/dynamic-code-generation-execution-pythons-exec-eval\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"Dynamic Code Generation & Execution with Python’s exec and eval\",\"datePublished\":\"2023-04-02T01:29:25+00:00\",\"dateModified\":\"2023-08-23T16:22:34+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/dynamic-code-generation-execution-pythons-exec-eval\\\/\"},\"wordCount\":1995,\"commentCount\":0,\"articleSection\":[\"Programming Languages\",\"Python\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/dynamic-code-generation-execution-pythons-exec-eval\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/dynamic-code-generation-execution-pythons-exec-eval\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/dynamic-code-generation-execution-pythons-exec-eval\\\/\",\"name\":\"Dynamic Code Generation & Execution with Python's exec and eval\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2023-04-02T01:29:25+00:00\",\"dateModified\":\"2023-08-23T16:22:34+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"description\":\"Explore dynamic code generation and execution with Python's powerful exec and eval functions. Uncover use cases, performance considerations,\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/dynamic-code-generation-execution-pythons-exec-eval\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/dynamic-code-generation-execution-pythons-exec-eval\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/dynamic-code-generation-execution-pythons-exec-eval\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Articles Home\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programming Languages\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Dynamic Code Generation & Execution with Python’s exec and eval\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\",\"name\":\"Developer Articles Hub\",\"description\":\"\",\"alternateName\":\"Developer Articles\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\",\"name\":\"w3compadmin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781352167\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781352167\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781352167\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Dynamic Code Generation & Execution with Python's exec and eval","description":"Explore dynamic code generation and execution with Python's powerful exec and eval functions. Uncover use cases, performance considerations,","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.w3computing.com\/articles\/dynamic-code-generation-execution-pythons-exec-eval\/","og_locale":"en_US","og_type":"article","og_title":"Dynamic Code Generation & Execution with Python's exec and eval","og_description":"Explore dynamic code generation and execution with Python's powerful exec and eval functions. Uncover use cases, performance considerations,","og_url":"https:\/\/www.w3computing.com\/articles\/dynamic-code-generation-execution-pythons-exec-eval\/","article_published_time":"2023-04-02T01:29:25+00:00","article_modified_time":"2023-08-23T16:22:34+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/dynamic-code-generation-execution-pythons-exec-eval\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/dynamic-code-generation-execution-pythons-exec-eval\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"Dynamic Code Generation & Execution with Python’s exec and eval","datePublished":"2023-04-02T01:29:25+00:00","dateModified":"2023-08-23T16:22:34+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/dynamic-code-generation-execution-pythons-exec-eval\/"},"wordCount":1995,"commentCount":0,"articleSection":["Programming Languages","Python"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.w3computing.com\/articles\/dynamic-code-generation-execution-pythons-exec-eval\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/dynamic-code-generation-execution-pythons-exec-eval\/","url":"https:\/\/www.w3computing.com\/articles\/dynamic-code-generation-execution-pythons-exec-eval\/","name":"Dynamic Code Generation & Execution with Python's exec and eval","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2023-04-02T01:29:25+00:00","dateModified":"2023-08-23T16:22:34+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"description":"Explore dynamic code generation and execution with Python's powerful exec and eval functions. Uncover use cases, performance considerations,","breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/dynamic-code-generation-execution-pythons-exec-eval\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/dynamic-code-generation-execution-pythons-exec-eval\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/dynamic-code-generation-execution-pythons-exec-eval\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Articles Home","item":"https:\/\/www.w3computing.com\/articles\/"},{"@type":"ListItem","position":2,"name":"Programming Languages","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/"},{"@type":"ListItem","position":3,"name":"Dynamic Code Generation & Execution with Python’s exec and eval"}]},{"@type":"WebSite","@id":"https:\/\/www.w3computing.com\/articles\/#website","url":"https:\/\/www.w3computing.com\/articles\/","name":"Developer Articles Hub","description":"","alternateName":"Developer Articles","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.w3computing.com\/articles\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561","name":"w3compadmin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781352167","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781352167","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781352167","caption":"w3compadmin"},"sameAs":["http:\/\/w3computing.com\/articles"]}]}},"featured_image_src":null,"featured_image_src_square":null,"author_info":{"display_name":"w3compadmin","author_link":"https:\/\/www.w3computing.com\/articles\/author\/w3compadmin\/"},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/85","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/comments?post=85"}],"version-history":[{"count":14,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/85\/revisions"}],"predecessor-version":[{"id":746,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/85\/revisions\/746"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=85"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=85"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=85"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}