Python Cookbook

Implementing a Collection

Credit: Skip Montanaro

Problem

You have a bunch of objects and want to make method calls and implement attribute lookups that operate on each object in the bunch.

Solution

I’m used to thinking of a proxy that forwards attribute lookups to a bunch of objects as a collection. Here’s how to make one in Python 2.2:

class Collection(list):
    def get(self, attr):
        """ Return a collection of same-named attributes from our items. """
        return Collection([getattr(x, attr) for x in self if hasattr(x, attr)])
    def call(self, attr, *args, **kwds):
        """ Return the result of calling 'attr' for each of our elements. """
        attrs = self.get(attr)
        return Collection([x(*args, **kwds) for x in attrs if callable(x)])

If you need to be portable to Python 2.0 or 2.1, you can get a similar effect by subclassing UserList.UserList instead of list (this means you have to import UserList first).

Using this recipe is fairly simple:

>>> import sys
>>> streams = Collection([sys.stdout, sys.stderr, sys.stdin])
>>> streams.call('fileno')
[1, 2, 0]
>>> streams.get('name')
['<stdout>', '<stderr>', '<stdin>']

Discussion

In some object-oriented environments, such Collection classes are heavily used. This recipe implements a Python class that defines methods named get (for retrieving attribute values) and call (for calling attributes).

In this recipe’s class, it’s not an error to try to fetch attributes or call methods that not all items in the collection implement. The resulting collection just skips any ...