Python basic to advance

🚀 Day 64: Ever wondered how Python truly works under the hood? Today, we're diving deep into the very blueprint of your code: the Abstract Syntax Tree (AST)! 🤯 Learn to unmask, transform, and even generate Python code at runtime by directly manipulating its AST. This isn't just theory; it's a powerful technique for advanced metaprogramming, dynamic code generation, and building highly adaptable systems. Prepare to truly understand your code's structure! ✨

In this example, we'll parse a simple Python function, modify its AST to inject a logging `print` statement at the beginning of the function, and then execute the transformed code. See how we can alter code's behavior without touching the source string directly!

```python
import ast
import inspect

# Original Python code as a string
original_code = """
def calculate_sum(a, b):
# This is the original function body
result = a + b
return result

# This will print the result using the original function definition
print(f"Original sum result: {calculate_sum(5, 3)}")
"""

class FunctionLoggerTransformer(ast.NodeTransformer):
"""
A custom AST transformer that adds a print statement to the beginning
of any function it processes, logging its execution.
"""
def visit_FunctionDef(self, node):
# Create a new print statement node: print(f"--- Executing function: '{node.name}' ---")
# We embed the function's name (from AST transformation time) directly into the string.
log_message = ast.Constant(value=f"--- Executing function: '{node.name}' ---")

print_statement = ast.Expr(
value=ast.Call(
func=ast.Name(id='print', ctx=ast.Load()), # Call to the 'print' built-in
args=[log_message], # Argument is our logging message
keywords=[]
)
)

# Prepend the new print statement to the function's body
node.body.insert(0, print_statement)

# Important: Call generic_visit to ensure child nodes are also visited and potentially transformed
return self.generic_visit(node)

print("Original code before transformation:n" + original_code)

# 1. Parse the original code into an AST
tree = ast.parse(original_code)

# 2. Transform the AST using our custom transformer
transformer = FunctionLoggerTransformer()
new_tree = transformer.visit(tree)

# 3. Fix missing line numbers and column offsets in the new tree.
# This is crucial for compilation to work correctly and prevent errors.
ast.fix_missing_locations(new_tree)

# 4. Compile the modified AST back into executable code
# filename='<string>' is standard for in-memory code
# mode='exec' for a sequence of statements or a module
compiled_code = compile(new_tree, filename='<string>', mode='exec')

print("n--- Executing Transformed Code ---")

# 5. Execute the compiled code in a new scope
# This will run the `print` statement that calls `calculate_sum` from the original_code,
# but now `calculate_sum` has our injected logger.
exec_scope = {} # Define a scope for execution to catch definitions if needed
exec(compiled_code, exec_scope)
```

Output example:
```
Original code before transformation:

def calculate_sum(a, b):
# This is the original function body
result = a + b
return result

# This will print the result using the original function definition
print(f"Original sum result: {calculate_sum(5, 3)}")

--- Executing Transformed Code ---
--- Executing function: 'calculate_sum' ---
Original sum result: 8
```

💡 **Your Challenge:** Modify the `FunctionLoggerTransformer` to not just log the function execution, but also log the *arguments* passed to the function! Hint: You'll need to inspect `node.args` within `visit_FunctionDef` and create an AST node for a dictionary or a formatted string that prints argument names and values. Good luck!

---
📚 Quiz Question:

15 views06:10