This is an old copy of the Python FAQ. The information here may be outdated.

How do you make a higher order function in Python?

Functions and methods are first-class objects in Python, so if you want to pass a function to another function, you can just treat it as any other object.

To bind a function object to a specific context, you can use either nested scopes or callable objects. For example, suppose you wanted to define linear(a,b) which returns a function f(x) that computes the value a*x+b. Using nested scopes:

def linear(a, b):
    def result(x):
        return a*x + b
    return result

Or using a callable object:

class linear:
   def __init__(self, a, b):
       self.a, self.b = a,b
   def __call__(self, x):
       return self.a * x + self.b

In both cases:

taxes = linear(0.3, 2)

gives a callable object where taxes(10e6) == 0.3 * 10e6 + 2.

The callable object approach has the disadvantage that it is a bit slower and results in slightly longer code. It can be a bit easier to understand, though, especially if you’re used to OO design. It also allows a collection of callables to share their signature via inheritance:

class exponential(linear):
   # __init__ inherited
   def __call__(self, x):
       return self.a * (x ** self.b)

And the object can encapsulate state for several methods:

class counter:
    value = 0
    def set(self, x):
        self.value = x
    def up(self):
    def down(self):

count = counter()
inc, dec, reset = count.up, count.down, count.set

Here inc(), dec() and reset() act like functions which share the same counting variable.

CATEGORY: programming


A Django site. rendered by a django application. hosted by webfaction.