210. Automatic Code Generation

🔹 1. Generating a Function Dynamically Using exec

Copy

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

print(greet("Alice"))  # Hello, Alice!

🔍 How it works:

• exec runs the string as Python code, defining greet at runtime.

---

🔹 2. Creating a Class Dynamically Using exec

Copy

class_code = """
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        return f"{self.name} is {self.age} years old."
"""

exec(class_code)
p = Person("Bob", 25)
print(p.info())  # Bob is 25 years old.

🔍 How it works:

• Defines a class dynamically and instantiates an object.

---

🔹 3. Generating Functions with exec Using a Loop

Copy

for i in range(3):
    exec(f"def square_{i}(x): return x ** {i}")

print(square_0(5))  # 1
print(square_1(5))  # 5
print(square_2(5))  # 25

🔍 How it works:

• Creates square_0, square_1, and square_2 functions dynamically.

---

🔹 4. Using eval to Execute Simple Expressions

Copy

expression = "3 + 5 * 2"
result = eval(expression)
print(result)  # 13

🔍 How it works:

• eval evaluates a string as a Python expression.

---

🔹 5. Generating a Lambda Function with eval

Copy

fn_code = "lambda x: x ** 2 + 2 * x + 1"
quadratic = eval(fn_code)
print(quadratic(3))  # 16

🔍 How it works:

• Dynamically creates a lambda function and evaluates it.

---

🔹 6. Creating a Dynamic Dictionary Using exec

Copy

fields = ["name", "age", "city"]
exec("data = {" + ", ".join(f'"{field}": None' for field in fields) + "}")

print(data)  # {'name': None, 'age': None, 'city': None}

🔍 How it works:

• Constructs a dictionary with dynamic keys.

---

🔹 7. Dynamically Creating Properties in a Class

Copy

class DynamicClass:
    pass

attributes = {"name": "Alice", "age": 30}

for key, value in attributes.items():
    exec(f"DynamicClass.{key} = {repr(value)}")

print(DynamicClass.name)  # Alice
print(DynamicClass.age)   # 30

🔍 How it works:

• Uses exec to set class attributes dynamically.

---

🔹 8. Creating a Custom Function Generator

Copy

def generate_function(op):
    code = f"""
def operation(x, y):
    return x {op} y
"""
    exec(code)
    return locals()["operation"]

add = generate_function("+")
print(add(10, 5))  # 15

mul = generate_function("*")
print(mul(10, 5))  # 50

🔍 How it works:

• Generates a function dynamically based on the operator.

---

🔹 9. Using eval to Create List Comprehensions

Copy

lst_code = "[x**2 for x in range(5)]"
squares = eval(lst_code)
print(squares)  # [0, 1, 4, 9, 16]

🔍 How it works:

• Uses eval to generate a list dynamically.

---

🔹 10. Securely Using exec with a Limited Namespace

Copy

code = """
def add(x, y):
    return x + y
"""

safe_globals = {}
exec(code, safe_globals)
print(safe_globals["add"](2, 3))  # 5

🔍 How it works:

• Restricts exec to a limited namespace for safety.

---

🚀 Final Thoughts

• exec: Runs Python statements dynamically.

• eval: Evaluates expressions but should be used carefully.

• Use Cases: Dynamic class creation, function generation, code execution.