Functions as arguments to functions

Question

I saw this example in a Python book, which showcases how to use a function as an argument to another function:

def diff2(f, x, h=1E-6):
    r = (f(x-h) - 2*f(x) + f(x+h))/float(h*h)
    return r

def g(t):
    return t**(-6)

t = 1.2
d2g = diff2(g, t)
print d2g

My question is, how does this script work without providing an argument to function g? The line in question is:

d2g = diff2(g,t)

Shouldn't it be done like:

d2g = diff2(g(t), t)

Answer 1

g is passed as an argument to diff2. In diff2, that argument is called f, so inside diff2 the name f refers to the function g. When diff2 calls f(x-h) (and the other calls it does), it is calling g, and providing the argument.

In other words, when you do diff2(g, t), you are telling diff2 that g is the function to call. The arguments to g are provided in diff2:

f(x-h) # calls g with x-h as the argument
f(x)   # calls g with x as the argument
f(x+h) # calls g with x+h as the argument

If you called diff2(g(t), t), you would be passing the result of g(1.2) as the argument. g would be called before calling diff2, and diff2 would then fail when it tries to call f, because f would be a number (the value g(1.2)) instead of a function.

Answer 2

The functions in question are rather random, and perhaps difficult to understand. Let's consider a simple example, a function sum which takes two numbers a and b, and returns their sum. Actually, we can easily define another function prod, which returns their product too.

def sum(a,b):
    return a + b

def prod(a,b):
    return a * b

Let's say we have another function compute, which takes as its arguments the operation (a function), and two operands (two numbers to call the function on). In compute, we call the given operation on the arguments.

def compute(fn, a, b):
    return fn(a, b)

We can compute different things. We can compute the sum of two numbers:

compute(sum, 1, 3)

We can compute the product of two numbers:

compute(prod, 1, 3)

Basically, without parentheses after the function name, we're not actually calling the function, it's just another object in the namespace (which happens to be a function which we can call). We don't call the function until inside of compute, when we do fn(a,b).

Let's see what the console outputs look like:

>>> compute(sum,1,3)
4
>>> compute(prod,1,3)
3
>>> sum
<function sum at mem-address>
>>> prod
<function prod at mem-address>
>>> sum(1,2)
3