Adding lines to a function

Question

Suppose I had two functions within another function like so:

def FooBar(isTheWorldRound = True):

    def Foo():
        print("Hi, I'm foo.")

    def Bar():
        print("Hi, I'm bar.")

    theFunction = None
    if (isTheWorldRound):
        return Bar
    else:
        return [Bar, Foo]

So, I can do this:

myFunction = FooBar(False)
myFunction()
>>> Hi, I'm Bar
>>> Hi, I'm Foo

Concerning this example I have two questions:

1. What is the proper way to perform the commented line?
2. Is there a way I can do this without explicitly defining Foo?

Answer 1

Putting two functions into a list gives you just that; a list of functions. It does not make a new function that calls both of the previous functions. For that, you need to define a new wrapper function, e.g.:

def call_all(*funcs):
    """Create a new wrapper to call each function in turn."""
    def wrapper(*args, **kwargs):
        """Call the functions and return a list of their outputs."""
        return [func(*args, **kwargs) for func in funcs]
    return wrapper

(if the * syntax is unfamiliar, see What does ** (double star) and * (star) do for parameters?), which you can now use like:

theFunction = call_all(Bar, Foo)

---

Note also that:

theFunction = None
if (isTheWorldRound):
    return Bar
else:
    return [Bar, Foo]

is a bit awkward, I would write it as:

if isTheWorldRound:
    return Bar
return [Bar, Foo]

You should also rename the functions/variables per the style guide.

Answer 2

You can certainly compose a new function in a way FooBar will return a single function that evaluates one or both of them.

Consider this:

def F():
    funcs = [Foo, Bar]
    ret = None
    for f in funcs:
        ret = f()
    return ret

You can make a closure in your FooBar to return a single composition:

def FooBar(isTheWorldRound = True):
    if (isTheWorldRound):
        funcs = [Bar]
    else:
        funcs = [Bar, Foo]

    def theFunction():
        ret = None
        for f in funcs:
            ret = f()
        return ret
    return theFunction

Luckily this is easy in Python where functions are first-class objects.

Edit: seems you want to execute the functions directly during the execution of FooBar. Then you can ditch the closure but still call all the functions in a loop.

Answer 3

Replace the commented line with:

return lambda: [None, Foo(), Bar()][0]

It will work as expected:

>>> myFunction = FooBar(False)
>>> myFunction()
Hi, I'm foo.
Hi, I'm bar.

What it does is creating an anonymous function, calling both Foo() and Bar() when invoked, and returning None.

Answer 4

Actually, that should work. Without the parentheses, it's a function pointer (or whatever Python's equivalent is).

To call it, you'd do something like:

theFunction[0]()

To get the 0th function in the list, then apply the parentheses (or any arguments if needed).