Question

Say I have a class, which has a number of subclasses.

I can instantiate the class. I can then set its __class__ attribute to one of the subclasses. I have effectively changed the class type to the type of its subclass, on a live object. I can call methods on it which invoke the subclass’s version of those methods.

So, how dangerous is doing this? It seems weird, but is it wrong to do such a thing? Despite the ability to change type at run-time, is this a feature of the language that should completely be avoided? Why or why not?

(Depending on responses, I’ll post a more-specific question about what I would like to do, and if there are better alternatives).

Answer 1

Here’s a list of things I can think of that make this dangerous, in rough order from worst to least bad:

• It’s likely to be confusing to someone reading or debugging your code.
• You won’t have gotten the right __init__ method, so you probably won’t have all of the instance variables initialized properly (or even at all).
• The differences between 2.x and 3.x are significant enough that it may be painful to port.
• There are some edge cases with classmethods, hand-coded descriptors, hooks to the method resolution order, etc., and they’re different between classic and new-style classes (and, again, between 2.x and 3.x).
• If you use __slots__, all of the classes must have identical slots. (And if you have the compatible but different slots, it may appear to work at first but do horrible things…)
• Special method definitions in new-style classes may not change. (In fact, this will work in practice with all current Python implementations, but it’s not documented to work, so…)
• If you use __new__, things will not work the way you naively expected.
• If the classes have different metaclasses, things will get even more confusing.

Meanwhile, in many cases where you’d think this is necessary, there are better options:

• Use a factory to create an instance of the appropriate class dynamically, instead of creating a base instance and then munging it into a derived one.
• Use __new__ or other mechanisms to hook the construction.
• Redesign things so you have a single class with some data-driven behavior, instead of abusing inheritance.

As a very most common specific case of the last one, just put all of the “variable methods” into classes whose instances are kept as a data member of the “parent”, rather than into subclasses. Instead of changing self.__class__ = OtherSubclass, just do self.member = OtherSubclass(self). If you really need methods to magically change, automatic forwarding (e.g., via __getattr__) is a much more common and pythonic idiom than changing classes on the fly.