Python Cookbook

Defining Constants

Credit: Alex Martelli

Problem

You need to define module-level variables that client code cannot accidentally rebind (i.e., named constants).

Solution

In Python 2.1 and later, you can install any instance as if it was a module. Just put the following in const.py:

class _const:

    class ConstError(TypeError): pass

    def _ _setattr_ _(self, name, value):
        if self._ _dict_ _.has_key(name):
            raise self.ConstError, "Can't rebind const(%s)"%name
        self._ _dict_ _[name] = value

    def _ _delattr_ _(self, name):
        if self._ _dict_ _.has_key(name):
            raise self.ConstError, "Can't unbind const(%s)"%name
        raise NameError, name

import sys
sys.modules[_ _name_ _] = _const(  )

Now any client code can import const, then bind an attribute on the const module just once, as follows:

const.magic = 23

Once the attribute is bound, the program cannot accidentally rebind or unbind it:

const.magic = 88      # would raise const.ConstError
del const.magic       # would raise const.ConstError

Discussion

In Python, variables can be rebound at will, and modules don’t let you define special methods such as an instance’s _ _setattr_ _ to stop rebinding. An easy solution (in Python 2.1 and later) is to set up an instance as if it was a module.

In Python 2.1 and later, no check is made to force entries in sys.modules to be actual module objects. You can install an instance object there and take advantage of attribute-access special methods (e.g., to prevent rebinding, to synthesize attributes on the fly in _ _getattr_ _, and so on), while still allowing client code to access it with import somename. You may even see this as a more Pythonic Singleton-style idiom (but see Recipe 5.23).

Note that this recipe ensures a constant binding for a given name, not an object’s immutability, which is quite a different issue. Numbers, strings, and tuples are immutable: if you bind a name in const to such an object, not only will the name always be bound to that object, but the object’s contents will also always be the same, since the object is immutable. However, other objects, such as lists and dictionaries, are mutable: if you bind a name in const to, for example, a list object, the name will always remain bound to that list object, but the contents of the list may change (items in it may be rebound or unbound, more items can be added with the object’s append method, and so on).

See Also

Recipe 5.23 and Recipe 15.6; the description of the modules attribute of the sys built-in module in the Library Reference.