Parametrized inheritance in Python?

Question

I am curious whether there is a better way to achieve something like this? My intentions are to avoid unnecessary boilerplate. The provided example is obviously just simple enough to let the others understand what I had on my mind.

def create_parametrized_class(animal):
    class SomeClass:
        def __init__(self, name):
            self.name = name

        def __str__(self):
            return "{}: {}".format(animal, self.name)

    return SomeClass

class Cat(create_parametrized_class("Cat")):
    pass

class Dog(create_parametrized_class("Dog")):
    pass

cat = Cat("Micka")
dog = Dog("Rex")
assert str(cat) == "Cat: Micka", "Cats..."
assert str(dog) == "Dog: Rex", "Dogs..."

Answer 1

I'm going to presume that type(self).__name__ won't suffice here (for both your example classes that value is equal to the parameter value you passed in).

To set up per-class values at class-definition time, as of Python 3.6 you can use the __init_subclass__ classmethod:

class Animal:
    def __init_subclass__(cls, animal_name, **kw):
        super().__init_subclass__(**kw)
        self._animal_name = animal_name

    def __str__(self):
        return "{}: {}".format(self._animal_name, self.name)


class Cat(Animal, animal_name='Cat'):
    pass

class Dog(Animal, animal_name='Dog'):
    pass

__init_subclass__ is called for all new subclasses, and any parameters you specify in the class Subclass(...) line are passed into that method, letting you parameterise that specific subclass.

Answer 2

I think you're better off with simple inheritance and a class variable:

class Animal(object):
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return '{}: {}'.format(type(self).name, self.name)

class Cat(Animal):
    name = 'Cat'

class Dog(Animal):
    name = 'Dog'

This looks cleaner to me (especially if you have more variables than just one), and uses less "advanced" features (i.e. someone reading your code doesn't have to google how __init_subclasses__ works).

Also it works for both Python 2 and 3:

>>> cat = Cat('Micka')
>>> print(cat)
'Cat: Micka'

---

If you were to use classproperty, you could even have it default to the class's name and be overriddable with a simple class variable. This prevents you from using the same name for the class and instance variables though, so you'd have to use something like animal_name:

class Animal(object):

    @classproperty
    def animal_name(cls):
        return cls.__name__

    def __init__(self, name):
        self.name = name

    def __str__(self):
        return '{}: {}'.format(self.animal_name, self.name)


class Cat(Animal):
    pass

class Dog(Animal):
    animal_name = 'Doggo'

Usage example:

>>> dog = Dog('Mike')
>>> cat = Cat('Bob')
>>> str(dog)
'Doggo: Mike'
>>> str(cat)
'Cat: Bob'