Book Excerpt: The Python Standard Library by Example

Chapter 3: Algorithms

Python includes several modules for implementing algorithms elegantly and concisely using whatever style is most appropriate for the task. It supports purely procedural, object-oriented, and functional styles. All three styles are frequently mixed within different parts of the same program.

functools includes functions for creating function decorators, enabling aspect-oriented programming and code reuse beyond what a traditional object-oriented approach supports. It also provides a class decorator for implementing all rich comparison APIs using a shortcut and partial objects for creating references to functions with their arguments included.

The itertools module includes functions for creating and working with iterators and generators used in functional programming. The operator module eliminates the need for many trivial lambda functions when using a functional programming style by providing function-based interfaces to built-in operations, such as arithmetic or item lookup.

contextlib makes resource management easier, more reliable, and more concise for all programming styles. Combining context managers and the with statement reduces the number of try:finally blocks and indentation levels needed, while ensuring that files, sockets, database transactions, and other resources are closed and released at the right time.

3.1 functools—Tools for Manipulating Functions

Purpose Functions that operate on other functions.

Python Version 2.5 and later

The functools module provides tools for adapting or extending functions and other callable objects, without completely rewriting them.

3.1.1 Decorators

The primary tool supplied by the functools module is the class partial, which can be used to “wrap” a callable object with default arguments. The resulting object is itself callable and can be treated as though it is the original function. It takes all the same arguments as the original, and it can be invoked with extra positional or named arguments as well. A partial can be used instead of a lambda to provide default arguments to a function, while leaving some arguments unspecified.

Partial Objects

This example shows two simple partial objects for the function myfunc(). The output of show_details() includes the func, args, and keywords attributes of the partial object.

import functools 

def myfunc(a, b=2): 
  """Docstring for myfunc().""" 
  print ’ called myfunc with:’, (a, b) 
  return 

def show_details(name, f, is_partial=False): 
    """Show details of a callable object.""" 
    print ’%s:’ % name 

    print ’ object:’,f 

    if not is_partial: 
       print ’ __name__:’, f.__name__ 
    if is_partial:
       print ’ func:’, f.func 
       print ’ args:’, f.args 
       print ’ keywords:’, f.keywords 
     return 
show_details(’myfunc’, myfunc) 
myfunc(’a’, 3)
print 

# Set a different default value for ’b’, but require 
# the caller to provide ’a’.
p1 = functools.partial(myfunc, b=4) 
show_details(’partial with named default’, p1, True) 
p1(’passing a’) 
p1(’override b’, b=5)
print 

# Set default values for both ’a’ and ’b’. 
p2 = functools.partial(myfunc, ’default a’, b=99) 
show_details(’partial with defaults’, p2, True) 
p2() 
p2(b=’override b’)
print 

print ’Insufficient arguments:’ 
p1() 

At the end of the example, the first partial created is invoked without passing a value for a, causing an exception.

$ python functools_partial.py 

myfunc:
 object: <function myfunc at 0x100d9bf50>
 __name__: myfunc
 called myfunc with: (’a’, 3) 
partial with named default:
 object: <functools.partial object at 0x100d993c0>
 func: <function myfunc at 0x100d9bf50>
 args: ()
 keywords: {’b’: 4}
 called myfunc with: (’passing a’, 4)
 called myfunc with: (’override b’, 5) 
partial with defaults:
 object: <functools.partial object at 0x100d99418>
 func: <function myfunc at 0x100d9bf50>
 args: (’default a’,)
 keywords: {’b’: 99}
 called myfunc with: (’default a’, 99)
 called myfunc with: (’default a’, ’override b’) 
Insufficient arguments:
Traceback (most recent call last): 
File "functools_partial.py", line 51, in <module>
 p1() 
TypeError: myfunc() takes at least 1 argument (1 given)