Question

What is the most pythonic way to add several identical methods to several classes?

---

I could use a class decorator, but that seems to bring in a fair bit of complication and its harder to write and read than the other methods.

I could make a base class with all the methods and let the other classes inherit, but then for some of the classes I would be very tempted to allow multiple inheritance, which I have read frequently is to be avoided or minimized. Also, the “is-a” relationship does not apply.

I could also change them from being methods to make them stand-alone functions which just expect their values to supply the appropriate properties through duck-typing. This is in some ways clean, but it is less object oriented and makes it less clear when a function could be used on that type of object.

I could use delegation, but this requires all of the classes that want to call to have methods calling up to the helper classes methods. This would make the code base much longer than the other options and require adding a method to delegate every time I want to add a new function to the helper class.

I know giving one class an instance of the other as an attribute works nicely in some cases, but it does not always work cleanly and can make calls more complicated than they would be otherwise.

After playing around with it a bit, I am leaning towrds inheritance even when it leads to multiple inheritance. But I hesitate due to numerous texts warning very strongly against ever allowing multiple inheritance and some (such as the wikipedia entry) going so far as to say that inheritance just for code reuse such as this should be minimized.

---

This may be more clear with an example, so for a simplified example say we are dealing with numerous distinct classes which all have a location on an x, y grid. There are a lot of operations we might want to make methods of everything with an x, y location, such as a method to get the distance between two such entities, or the relative direction, midpoint between them, etc.

What would be the most pythonic way to give all such classes access to these methods that rely only on having x and y as attributes?

Answer 1

For your specific example, I would try to take advantage of duck-typing. Write plain simple functions that take objects which are assumed to have x and y attributes:

def distance(a, b):
    """ 
    Returns distance between `a` and `b`.
    `a` and `b` should have `x` and `y` attributes.
    """

    return math.sqrt((a.x-b.x)**2 + (a.y-b.y)**2)

Very simple. To make it clear how the function can be used, just document it.