Calling super class inheritance

Good question! The classes Agile and Sneaky certain could have been declared as inheriting from Character. It still would work but it starts to become less than clear what the intentions are.

class Agile(Character):
class Sneaky(Character):
class Thief(Agile, Sneaky):
# or
class Thief(Agile, Sneaky, Character): # still works

By having them both inherit from Character, it implies that one might wish to create an Agile instance or a Sneaky instance, but this isn't the goal of this code. Kenneth wished to create add-in (or "mix-in") attributes that could be used generically to add to any class.

An extension would be if there was a Monster class, then the Agile and Sneaky could be reused to add those attributes to a specific monster class, as opposed to creating a monster version of "agile" that inherited from Monster instead of Character.

Given the original code class Thief(Agile, Sneaky, Character): The super().__init__() order is the same as the Method Resolution Order (MRO):

>>> from thieves import Thief                                                             
>>> Thief.__mro__                                                                         
(<class 'thieves.Thief'>, <class 'attributes.Agile'>, <class 'attributes.Sneaky'>, <class 'characters.Character'>, <class 'object'>)                                                

You might think the MRO would be:

Thief --> Agile --> object --> Sneaky --> object --> Character --> object

But since Character depends on object, the earlier object references are removed and only the last object is retained:

Thief --> Agile --> Sneaky --> Character --> object

Post back if you have more questions. Good luck!

Edit: Hara and Pete ask: why use super() in Agile and Sneaky?

When using multiple inheritance (inheriting from more than one class) all references are resolved by looking in the local code first, then one by one each of the inherited classes are checked for the reference. Once a reference is found it is used immediately and the search stops.

The use of super() indicates to continue searching for the indicated reference down the Method Resolution Order (MRO) for more code to execute.

In the case of creating a new instance, the __init__ method is called. If the Thief class had an __init__ method without a super() call, execution would stop there. If there isn't a local __init__ then the search would continue with the inherited classes.

By using super() in the Agile and Sneaky class you guarantee that __init__ method in all inherited class will get an opportunity to be executed.

Edit: Kafe Hezam asks: why not remove *args from both Agile and Sneaky?

In this case, since no positional arguments are used *args could be removed. However, not removing the generic positional placeholder *args allows the attribute classes Agile and Sneaky to be used with other classes besides Character where positional arguments may be in use. It’s common practice to include both *args and **kwargs to allow greater reuse.