Modifying function arguments

by

It can be done but I’m warning you – it won’t be pretty! What you can do is to capture the caller frame in your function, then pick up the call line, parse it and extract the arguments passed, then compare them with your function signature and create an argument map, then call your function and once your function finishes compare the changes in the local stack and update the caller frame with the mapped changes. If you want to see how silly it can get, here’s a demonstration:

# HERE BE DRAGONS
# No, really, here be dragons, this is strictly for demonstration purposes!!!
# Whenever you use this in code a sweet little pixie is brutally killed!

import ast
import inspect
import sys

def here_be_dragons(funct):  # create a decorator so we can, hm, enhance 'any' function
    def wrapper(*args, **kwargs):
        caller = inspect.getouterframes(inspect.currentframe())[1]  # pick up the caller
        parsed = ast.parse(caller[4][0], mode="single")  # parse the calling line
        arg_map = {}  # a map for our tracked args to establish global <=> local link
        for node in ast.walk(parsed):  # traverse the parsed code...
            # and look for a call to our wrapped function
            if isinstance(node, ast.Call) and node.func.id == funct.__name__:
                # loop through all positional arguments of the wrapped function
                for pos, var in enumerate(funct.func_code.co_varnames):
                    try:  # and try to find them in the captured call
                        if isinstance(node.args[pos], ast.Name):  # named argument!
                            arg_map[var] = node.args[pos].id  # add to our map
                    except IndexError:
                        break  # no more passed arguments
                break  # no need for further walking through the ast tree
        def trace(frame, evt, arg):  # a function to capture the wrapped locals
            if evt == "return":  # we're only interested in our function return
                for arg in arg_map:  # time to update our caller frame
                    caller[0].f_locals[arg_map[arg]] = frame.f_locals.get(arg, None)
        profile = sys.getprofile()  # in case something else is doing profiling
        sys.setprofile(trace)  # turn on profiling of the wrapped function
        try:
            return funct(*args, **kwargs)
        finally:
            sys.setprofile(profile)  # reset our profiling
    return wrapper

And now you can easily decorate your function to enable it to perform this ungodly travesty:

# Zap, there goes a pixie... Poor, poor, pixie. It will be missed.
@here_be_dragons
def your_function(in1, in2):
    in1 = in1 + 1
    in2 = in2 + 1

And now, demonstration:

a = 1
b = 2
c = 3
d = 4
# Now is the time to play and sing along: Queen - A Kind Of Magic...
your_function(a, b)  # bam, two pixies down... don't you have mercy?
your_function(c, d)  # now you're turning into a serial pixie killer...

print(a, b, c, d)  # Woooo! You made it! At the expense of only three pixie lives. Savage!
# prints: (2, 3, 4, 5)

This, obviously, works only for non-nested functions with positional arguments, and only if you pass simple local arguments, feel free to go down the rabbit hole of handling keyword arguments, different stacks, returned/wrapped/chained calls, and other shenanigans if that’s what you fancy.

Or, you know, you can use structures invented for this, like globals, classes, or even enclosed mutable objects. And stop murdering pixies.

More Related Contents:

  1. Why does using `arg=None` fix Python’s mutable default argument issue?
  2. How do I create a Python function with optional arguments?
  3. Python: Passing variables between functions
  4. How can I pass information (a variable) out of a function? How can I use that from outside, e.g. in other functions?
  5. Best way to check function arguments? [closed]
  6. How do I define a function with optional arguments?
  7. Python function as a function argument?
  8. Overloaded functions in Python
  9. Python passing list as argument
  10. What is a maximum number of arguments in a Python function?
  11. Python Class Based Decorator with parameters that can decorate a method or a function
  12. How to have multiple conditions for one if statement in python [duplicate]
  13. Get a list/tuple/dict of the arguments passed to a function?
  14. How does using a function (callback) as an argument to another function work in Python?
  15. In Python, can I specify a function argument’s default in terms of other arguments?
  16. How can the built-in range function take a single argument or three?
  17. Python for in range()
  18. Apply function to each element of a list
  19. python max function using ‘key’ and lambda expression
  20. Why does Python code use len() function instead of a length method?
  21. Calling variable defined inside one function from another function
  22. Why do some functions have underscores “__” before and after the function name?
  23. Defining private module functions in python
  24. Difference between returns and printing in python? [duplicate]
  25. How to pass an operator to a python function?
  26. How to make a local variable (inside a function) global [duplicate]
  27. Is it pythonic for a function to return multiple values?
  28. How to pass dictionary items as function arguments in python? [duplicate]
  29. function is not defined error in Python
  30. “TypeError: method() takes 1 positional argument but 2 were given” but I did only pass one

Leave a Comment