what is function(var1)(var2) in python

Question

I have a piece of code I pulled from someone I don't understand:

def __init__(self, func):
        self.func = func
        wraps(func)(self)

I've seen things like wraps(func)(self) several times but never seen it explained. How is there a function with parameters and then another (var) thing after it? What does it all mean? Thank you

In your particular example, that is almost certainly a usage of [`functools.wraps`](https://docs.python.org/2/library/functools.html#functools.wraps), which is a helper for creating decorators. (It does some handy stuff to make sure the right function names are used during logging, for example.) — Two-Bit Alchemist, Aug 27 '15 at 20:47

score 16 · Accepted Answer · edited May 23 '17 at 12:02

Functions are first-class objects in Python.

You have no doubt encountered this on the command line if you have typed the name only of a function without parentheses.

In [2]: a
Out[2]: <function __main__.a>

When you see a(b)(c) it is a method of chaining:

The function a is defined to return another function.
a(b) calls a and returns that reference (to a callable function)
a(b)(c) calls whatever function was returned by a with c as an argument.

This is equivalent to the following:

new_func = a(b)
new_func(c)

An example:

In [1]: def multiply_by(x):
   ...:     def multiply_by_x(y):
   ...:         return x * y
   ...:     return multiply_by_x    # notice no parens
   ...: 

In [2]: multiply_by(10)
Out[2]: <function __main__.multiply_by_x>

Notice when you call this you get a function object. (This is what I mean when I am saying a "reference to a function" or the like.)

In [3]: multiply_by(10)(5)
Out[3]: 50

You're calling the function returned by multiply_by() with 5 as an argument, and it's exactly the same as doing:

In [4]: multiply_by_10 = multiply_by(10)

In [5]: multiply_by_10(4)
Out[5]: 40

In [6]: multiply_by_10(8)
Out[6]: 80

The cool thing about doing this, as you can see from this example, is that now your multiply_by function is a factory for functions that multiply by something. Above, we created multiply_by_10 which, obviously, multiplies what you feed it by 10. We can just as easily do:

In [7]: multiply_by_5 = multiply_by(5)

and have a function that multiplies by 5. This is obviously extremely useful. Incidentally, it's also how Python's decorators work.

Thanks @MarkusMeskanen in the comments for pointing out a way to make my silly example into a cooler one!

See also:

I think a bit better, or at least more useful example would be something like this: http://pastebin.com/afJHmtNs — Markus Meskanen, Aug 27 '15 at 20:53
This might be clearer if you changed `example_func` to actually use `x`, which would also give you the chance to explain closures, which most useful function objects are going to be. — porglezomp, Aug 27 '15 at 20:54
These are both excellent ideas and I will add them. Keep an eye out for corrections as I make edits please. — Two-Bit Alchemist, Aug 27 '15 at 20:57
so it seems if a(b) out of the a(b)(c) doesn't return a function, but an integer or somethin, it'll blow up? — codyc4321, Aug 27 '15 at 21:04
Haha if by "blow up" you mean raise `TypeError: 'int' object is not callable`, then yes! — Two-Bit Alchemist, Aug 27 '15 at 21:05
exactly, that's cool I blew through it because my decorator worked but I'll try to use these — codyc4321, Aug 28 '15 at 13:47

score 3 · Answer 2 · answered Aug 27 '15 at 20:43

The key is that wraps() takes a function as its parameter and returns a function, probably with some extra goodness added to it, sort of like what a decorator function does.

If you were to print(wraps(func)) you should see output that identifies the object as a function.

So wraps(func)(self) can be rewritten as

wrapped_func = wraps(func)
wrapped_func(self)

which looks more "normal" to some people.

score 2 · Answer 3 · answered Aug 27 '15 at 21:03

You case is that the function wrap returns a callable, i.e. a function or a class or any object that implements the __call__ method. So just to understand take a look at this example:

def wraps(arg):
   def decor(func):
      print(arg)
      return func
   return decor

This is a typical decorator, meaning that you can do the following:

@wrap('some arg')
def func(a):
    print(a)

So what happens here is the following:

First the wrap function is being called with the argument value some arg. As you can the inside wrap we have another decor function defined, which is being returned
Whatever is returned from the wrap function, is being called, i.e. the __call__ method is being invoked on the returned object, with the argument being the function being decorated. In this case we have decor(func).
Our decor function simply prints the value of arg ('some arg' in our case), and return the func.

Note: This is being done only once!

func('hello1')
func('hello2')

...you will get the following output

some arg
hello1
hello2

what is function(var1)(var2) in python

3 Answers3