"Stupid Python Tricks" explores ways to abuse Python features for the hell of it. Stupid Python Tricks may well be perpendicular to maintainability and sanity. Abandon all hope, ye who enter here.
Classes can be convenient namespaces for corralling related objects. You don't even need to instantiate such a class; you can just use the class itself, since attribute access works the same for classes and instances. (If you need methods in the namespaces, it is better to instantiate the class, since otherwise you need to decorate each method with
@classmethod. But for data, it works great, and saves the step of instantiation.)
One category of related objects that can be useful to put in a namespace are constants. You can even override
__setattr__ to slap the programmer's hand should he (or she) try to change those tempting attributes-what-should-be-constants. But disappointment lurks ahead... declaring
__setattr__ on a class won't actually override the behavior of setting the attribute on the class! See, for example, this:
class Const(object):
answer = 42
def __setattr__(self, name, value):
raise TypeError("variables may vary, but constants never do")
The intent here is to prevent the class attribute
answer (or any other attribute, for that matter) from being set or changed. But it doesn't work:
Const.answer = 13 # no problem!
It works only if we instantiate the class:
const = Const()
const.answer = 42 # TypeError
One way to solve this is to just go ahead and instantiate the class right after we define it. We can even give the instance the same name as the class, a cheap way of making it a little more difficult to make additional instances (not that it would matter too much if someone did, aside from a little bit of memory overhead, and not like it's difficult to get the class's type even if it's not in a convenient namespace):
Const = Const()
But now suppose we want to write a base class that provides the behavior of denying attribute changes, so that we can write subclasses that hold our constant definitions. Now we've gotta instantiate each of them because the desired behavior isn't fully contained in the class itself. And if we forget, the constants aren't constant anymore! Ugh. What we need to do is somehow override the attribute-setting behavior of
the class itself. How?
Well, we know that to override attribute-setting behavior on an
instance, we define
__setattr__ on its
class. We also know that every Python class is itself an object, which implies that
a class is an instance of some other class. So what we want to do is define
__setattr__ on the
class's class.
A class's class is called its
metaclass. Just as every ordinary instance is created from a class, so every class is an instance created from a metaclass. In Python, the default metaclass is a class called
type, so to write our own metaclass, we must inherit from
type.
To sum up, we can override the attribute-setting behavior of our
Const base class by writing a
__getattr__ method on a metaclass, then using that metaclass to define our base class. Metaclasses are inherited, so the behavior of our base class will carry over to any classes derived from it. Which is exactly what we want!
While we're at it, we can also define what happens if someone tries to instantiate the class, by overriding the
__call__ method. The
__call__ method of
type is what calls
__new__ and then
__init__ to construct the class. Since we're writing our own metaclass, we can make it do something different.
What should trying to instantiate a class that's just being used as a namespace do? Maybe raise
TypeError? Or, since someone who tries to instantiate the class is probably trying to get access to its attributes, just return the class itself (i.e., make the class a singleton, i.e., make the class its own instance, i.e., make instantiating the class a no-op)? This being
Stupid Python Tricks, let's do
that! (Also, it's less typing than raising a proper exception, although of course writing a sentence
explaining that ruins the economy.)
class ConstMeta(type):
def __setattr__(cls, name, value):
raise TypeError("variables may vary, but constants never do")
def __call__(cls):
return cls
Now we can define a base class. (Python 2 and Python 3 have slightly different syntax for specifying the metaclass.)
# Python 2 version
class Const(object):
__metaclass__ = ConstMeta
# Python 3 version
class Const(metaclass=ConstMeta):
pass
Aaand
now we can use that base class to define namespaces in which the attributes can't be modified:
class nums(Const):
ANSWER = 42
FUN = 69
UNLUCKY = 13
PI = 3.1415927 # close enough
Now let's try changing all circles to hexagons:
nums.PI = 3 # nope!
You might next reasonably ask: how does the class get defined in the first place if its metaclass disallows putting attributes on it? And the answer is that defining an attribute in the body of a class definition doesn't call
__setattr__! Instead, the attributes are placed in a dictionary, and when the class definition is complete, that dictionary becomes the class's
__dict__ attribute, where all its attributes are stored. Try it:
print (nums.__dict__.items())
Now you might think that knowing about
__dict__ will let you modify these read-only attributes anyway, even though we've written a metaclass to prevent it.
Right?
nums.__dict__["FUN"] -= 1 # Right????
But as it happens, the
__dict__ attribute of a class is not actually a Python
dict object, but rather a proxy object that does not allow item assignment. Foiled! You might also think you could just use
object.__setattr__ ... but that doesn't work either! Foiled again!
All right already...
type.__setattr__ does work:
# Deep Thought had an off-by-one error
type.__setattr__(nums, "ANSWER", 41)
Of course, you could also just go with the nuclear option:
del ConstMeta.__setattr__ # kaboom
Which goes to show you... even when you think you've put up a wall around something in Python, you really haven't. Ever. That's why Python's unofficial motto is "I'll show you mine if you show me yours." Whoops, I mean, "We're all consenting adults here."
And now you know... the
rest of the story.
