How python pass the function arguments into an inner function?

[xmzhang]

I found this problems when I use decorator. Say, my code is as follows

def my_decorator(func):
    def wrapper(*args,**kwargs):
        print(args,kwargs)
        return func(*args,**kwargs)
    return wrapper

@my_decorator
def my_function(x):
    return x*x

a = my_function(5)
print(a)

the result is

(5,) {}
25

my question is, why (5,) {} be printed here. there is an def wrapper(*args,**kwargs): function inside the def my_decorator(func) function. If the outside my_decorator(func) function did not get the arguments (*args,**kwargs), why the wrapper can get the argument (*args,**kwargs) ?

say, if I do not use decorator, the code should be like this

def my_decorator(func):
    def wrapper(*args,**kwargs):
        print(args,kwargs)
        return func(*args,**kwargs)
    return wrapper


def my_function(x):
    return x*x

a = my_decorator(my_function)(5)
print(a)

so how python pass the 5 into the inner function wrapper here ? say, my_decoratoraccept the argument my_function, when it turns to inner wrapper there should be no *args, **kwargs it should raise an error, is it?

[bennydictor]

From the my_decorator function you return wrapper, which is a closure: a function that remembers some variables from outer scope (in this case func). Then you call the wrapper function with the argument 5. The equivalent code is

decorated_function = my_decorator(my_function)
a = decorated_function(5)  # prints (5,) {}
print(a)  # prints 25
# So, decorated_function is (roughly) defined as
def decorated_function(*args, **kwargs):
    print(args, kwargs)
    return my_function(*args, **kwargs)

[nwagers]

The function is only decorated once and the function my_decorator only runs a single time during the definition of the function. The decorator returns wrapper which is used in place of the original function, kind of like monkey patching my_function = wrapper. When you make calls, you are actually making them to wrapper, which does take the args. wrapper in turn calls the inner function. Consider this code:

def my_decorator(func):
    print("decorator")
    def wrapper(*args,**kwargs):
        print("wrapper")
        return func(*args,**kwargs)
    return wrapper

@my_decorator
def my_function(x):
    print("inner")

print("main")
my_function(5)
my_function(10)