执行高阶函数

Question

I'm learning the concepts of first class functions and closures in Python and I was curious to know:

Given a higher-order function:

def html_tag(tag):
    def wrap_text(text):
        print("<{0}>{1}</{0}>".format(tag, text))
    return wrap_text

1. What's the difference between these two approaches of executing higher-order functions.
2. Are there any advantages of using one over the other.
3. What is the best way to execute a higher-order function in a program.

1.

print_h1 = html_tag('h1')
print_h1('Test Headline')
print_h1('Another Headline')

2.

html_tag('h1')('Test Headline')
html_tag('h1')('Another Headline')

Answer 1

The only advantage I can think of is that by assigning the return value of html_tag to a variable in the first example, you prevent the code from having to execute again and return a new function each time. Whereas in your second example, you are calling html_tag directly and it will produce a new function reference each time, which will result in a decrease in performance.

Depends on your usage, but if you're passing in the same argument to html_tag , then I would go with your first example. But if you need to use a different tag, then obviously you would have to re-call html_tag again with a different argument.

In terms of the references to the function, this could be important, for example, if you were for some reason storing the function in a dict , so you wouldn't be able to lookup the function as a key unless you keep around a reference to the same function (as in your first example)

Answer 2

In the example you give, there's no difference in the result. The second way is less efficient, since you're creating an equivalent function multiple times, which is redundant.

It becomes more relevant when you have functions that keep state between runs.

def counting_tag(tag):
    counter = 0
    def wrap_text(text):
        nonlocal counter
        counter += 1
        print("<{0}>{1}. {2}</{0}>".format(tag, counter, text))

Every time you call counting_tag() it will return a function with the counter reset back to 0 .

print_h1 = counting_tag('h1')
print_h1('Test Headline')
print_h1('Another Headline')

This will print

1. Test Headline
2. Another Headline

But if you do it the second way:

counting_tag('h1')('Test Headline')
counting_tag('h1')('Another Headline')

you'll get

1. Test Headline
1. Another Headline

Answer 3

The reason you'd have a higher order function would typically be so that you could easily generate named helper functions like print_h1 , as in your first example. This has two benefits:

1. You avoid repeating the 'h1' string. Any time you have to copy and paste a string literal multiple places, it's an invitation for a bug to happen due to a typo!
2. Less typing. (This is more like a secondary benefit of not repeating yourself.)

If you were going to re-invoke html_tag each time, as in your second example, making a higher order function offers no benefit over simply doing:

def html_tag(tag, text):
    print("<{0}>{1}</{0}>".format(tag, text))


html_tag('h1', 'Test Headline')
html_tag('h1', 'Another Headline')