Question

I’ve got some old code where I stored lists of functions in Python as class attributes. These lists are used as a sort of event hook.

To call each function in the list with appropriate arguments, I’ve used one-liners, mixing map with lambda expressions. I’m now concerned that there is unnecessary overhead in using lambda expressions like this.. I guess the recommended way would be to drop both map and lambda and just use a standard for loop, for readability.

Is there a better (read faster) one-liner to do this, though?

For example:

class Foo:
    """Dummy class demonstrating event hook usage."""
    pre  = [] # list of functions to call before entering loop.
    mid  = [] # list of functions to call inside loop, with value
    post = [] # list of functions to call after loop.
    def __init__(self, verbose=False, send=True):
        """Attach functions when initialising class."""
        self._results = []
        if verbose:
            self.mid.append( self._print )
        self.mid.append( self._store )
        if send:
            self.post.append( self._send )

    def __call__(self, values):

        # call each function in self.pre (no functions there)
        map( lambda fn: fn(), self.pre )

        for val in values:
            # call each function in self.mid, with one passed argument
            map( lambda fn: fn(val), self.mid )

        # call each fn in self.post, with no arguments
        map( lambda fn: fn(), self.post )

    def _print(self, value):
        """Print argument, when verbose=True."""
        print value

    def _store(self, value):
        """Store results"""
        self._results.append(value)

    def _send(self):
        """Send results somewhere"""

# create instance of Foo
foo = Foo(verbose=True)

# equivalent to: foo.__call__( ... )
foo( [1, 2, 3, 4] )

Is there a better way to write those one-liner map calls?

Answer 1

The recommended way is definitely to use for loops, however, if you insist on using map, then operator.methodcaller might be just what you need:

>>> def foo(*args):
...    print 'foo',args
... 
>>> def bar(*args):
...    print 'bar',args
... 
>>> from operator import methodcaller
>>> 
>>> map(methodcaller('__call__',1,2,3),[foo,bar])
foo (1, 2, 3)
bar (1, 2, 3)
[None, None]

A word of caution about using map for this — It won’t work if you port your code to python 3 since map became lazy.

You could also use list comprehensions pretty trivially (and that works on python3 also):

[fn() for fn in self.pre]
[fn(val) for fn in self.mid]

etc.