Here’s a Python code pattern that I find myself falling into every once in awhile. If you’re a highly disciplined milspec-type non-pragmatic programmer, I suggest you stop reading here lest you burn your eyes.
The patterm useful in two situations:
- when you have an evolving superclass that may take new constructor (or method!) arguments in the future and you don’t want to have to recode your subclasses to reflect those changes
- you have a number of interchangeable subclasses that may or may not use certain arguments (say, because you’re constructing the object from a command line)
class Component:
def __init__(self, a, b = None, *av, **ad):
...
class ComponentTemplate(Component):
def __init__(self, *av, **ad):
Component.__init__(self, *av, **ad)
a and b are two arguments that are being used by superclass. With this pattern you can add c to Component in the future without worrying about rewriting ComponentTemplate. Similarly, if an unexpected argument is passed down to Component, it will be silently ignored.
In case you’re wondering what *av and **ad are, they’re Python’s way of referring to arguments that have been passed in, by position and by name, but have not been explicitly listed in the method’s signature. The first is a list and the second a dictionary. If you’re a Python user and you’re not familiar with this, you can and should read more about this here.