Very occasionally, I write code where I'm given an object of some class (usually from a library call), but I wish to use additional methods on that class as though they had been defined there. In some languages (Objective-C shines in this regard with categories), you can do this very naturally. In Python, most people probably resort to monkey patching to accomplish this.

This is Probably An Anti-Pattern

I want to preface this with an admission that I have no idea if this will generally work (please comment if you know of a reason why it won't!), and that I suspect that this is a horrible idea. And yet, here we go:

import copy class Base ( object ): def __init__ ( self ): self . base_init = True def foo ( self ): return 'base foo' def bar ( self ): return 'base bar' class Child ( Base ): def __new__ ( cls , other ): if isinstance ( other , Base ): other = copy . copy ( other ) other . __class__ = Child return other return object . __new__ ( cls ) def __init__ ( self , other ): self . child_init = True def bar ( self ): return 'child bar' b = Base () assert b . base_init == True assert b . foo () == 'base foo' assert b . bar () == 'base bar' assert b . __class__ == Base c = Child ( b ) assert c . base_init == True assert c . child_init == True assert c . foo () == 'base foo' assert c . bar () == 'child bar' assert c . __class__ == Child assert b . __class__ == Base

Have I made some glaring mistake? Is there something obviously wrong with this, other than the abuse of the language inherent in trying to do such a thing?