Question

I’m struggling to find a “pythonic” approach to the following class organization:

I have a base class with properties initialized in its constructor, for example:

class Animal(object):
    def __init__(self, class_, species, is_domesticated):
        self.class_ = class_
        self.species = species
        self.is_domesticated = is_domesticated

Then, when I subclass, I would like to “hard-code” one or more of these properties, like so:

class Mammal(Animal):
    def __init__(self, species, is_domesticated):
        Animal.__init__(self, 'Mammal', species, is_domesticated)

A Mammal is thus instantiated like so:

monkey = Mammal('Primate', false)

The problem is, I would like to use *args so as to leave any derived classes alone when altering the base class definition. Thus the definition of Mammal becomes:

class Mammal(Animal):
    def __init__(self, *args):
        Animal.__init(self, *(args + (class_='Mammal',)))

Which (needless to say) looks horrible. Some tips would be appreciated =)

Answer 1

If you only have a fixed set of arguments in the base class, there isn’t much need to worry about variable arguments. Just do what you did in your first example and it’s fine. If you want to be able to randomly add arguments to the base class, but add them as positional arguments and without defaults, there’s no hope; you can’t just change the base class willy-nilly and expect all derived classes to keep working.

However, there is a fairly common intermediate case where you might have a large set of attributes, various combinations of which may be passed to any class in the hierarchy. You might want to add new arguments to the base class, but they’ll have defaults so that derived classes don’t need to know about them explicitly; they’ll just gracefully degrade to the base-class default. In such a case it’s usually a better idea to use **kwargs rather than *args.

class Animal(object):
    def __init__(self, **kwargs):
        self.class_ = kwargs['class_']
        self.species = kwargs['species']
        # etc.
class Mammal(Animal):
    def __init__(self, **kwargs):
        Animal.__init__(self, class_="Mammal", **kwargs)

This requires the arguments to passed by keyword:

>>> Animal(class_='Fish', species='barracuda', is_domesticated=False)
4: <__main__.Animal object at 0x0177ABF0>
>>> Mammal(species="monkey", is_domesticated=False)
5: <__main__.Mammal object at 0x0177AFB0>

. . . but this is better if there are a lot of them, because no one will remember which order to pass them in if you have 10 different things getting passed in positionally. It also means that you can add new arguments easily; no one has to know where in the list to put the new ones, they can just add them anywhere by keyword.

In Python 2 you have to manually extract the kwargs as I did above. In Python 3 you can use keyword-only arguments to make this even easier.