I was checking this problem to understand multiple inheritance and I got stuck. How can I set the fields of the inherited objects from the last class?

class Vehicle():
  def __init__(self, name:str, seats:int):
    self.name = name
    self.seats = seats

  def print_vehicle(self):
    print(f'Vehicle {self.name} has {self.seats} seats')

class Boat(Vehicle):
  def __init__(self, name:str, seats:int, engine_type:str):
    super().__init__(name, seats)
    self.engine_type = engine_type

  def print_vehicle(self):
    print(f'Boat {self.name} has {self.seats} seats and engine {self.engine_type}')

class Car(Vehicle):
  def __init__(self, name:str, seats:int, fuel:str):
    super().__init__(name, seats)
    self.fuel = fuel

  def print_vehicle(self):
    print(f'Car {self.name} has fuel {self.fuel}')

class AnphibiousCar(Boat, Car):
  def __init__(self, name, seats, engine_type, fuel):
    super(AnphibiousCar, self).__init__(name, seats, engine_type) # ???
    
  def print_vehicle(self):
    print(f'Anphibious car {self.name} has {self.seats} seats and {self.engine_type} - {self.fuel} engine')
    
ac = AnphibiousCar('name', 4, 'piston', 'gas')
ac.print_vehicle()

CodePudding user response：

The point is that each class should focus only on the stuff which is its direct responsibility; the rest should be delegated to superclasses (and note that, when you deal with such a cooperative inheritance with super(), your methods that call super() should not need to know what exactly are the actual superclasses, in particular the nearest one - as this can change, depending on the actual class of self).

So let's reimplement your classes (with a bunch of explanations in the comments):

class Vehicle:

    # Added the `*,` marker to make `name` and `seats` *keyword-only*
    # arguments (i.e., arguments that are identified only by their
    # *names*, never by their positions in a call's arguments list).
    def __init__(self, *, name: str, seats: int):
        self.name = name
        self.seats = seats

    # We abstract out class-specific features into separate methods,
    # keeping in the `print_vehicle()` method only the common stuff,
    # so that in subclasses we'll need to customize only those methods
    # (`list_features()`, `get_type_label()`), *not* `print_vehicle()`.
    def print_vehicle(self):
        vehicle_type_label = self.get_type_label()
        features = ', '.join(self.list_features())
        print(f'{vehicle_type_label} {self.name}: {features}.')

    # Side note: the `list[str]` type annotation requires Python 3.9
    # or newer (for compatibility with older versions you need to
    # replace it with `List[str]`, using `from typing import List`).
    def list_features(self) -> list[str]:
        return [f'has {self.seats} seats']

    # This implementation is, in fact, quite generic (so that
    # in most subclasses we will *not* need to customize it).
    def get_type_label(self) -> str:
        return self.__class__.__name__


class Boat(Vehicle):

    # Only `Boat`-specific arguments (as keyword-only ones, as above...)
    # are declared here explicitly. Any other are treated as a "black
    # box", just being passed into superclasses...
    def __init__(self, *, engine_type: str, **kwargs):
        super().__init__(**kwargs)
        self.engine_type = engine_type

    # Also here we focus only on this-class-specific stuff, handling
    # other stuff as "agnostically" as possible...
    def list_features(self) -> list[str]:
        return super().list_features()   [f'has {self.engine_type} engine']


class Car(Vehicle):

    # And analogously...
    def __init__(self, *, fuel: str, **kwargs):
        super().__init__(**kwargs)
        self.fuel = fuel

    def list_features(self) -> list[str]:
        return super().list_features()   [f'needs {self.fuel} fuel']


class AmphibiousCar(Boat, Car):

    # Note: here we get our `__init__()` and `list_features()`
    # for free (!), as the superclasses provide all we need
    # when it comes to those two methods.

    # The only thing we may want to customize is:
    def get_type_label(self) -> str:
        return 'Amphibious car'


ac = AmphibiousCar(
    name='Julia-III',
    seats=4,
    engine_type='piston',
    fuel='gas')

# "Amphibious car Julia-III: has 4 seats, needs gas fuel, has piston engine."
ac.print_vehicle()

As a further reading, I'd recommend: https://rhettinger.wordpress.com/2011/05/26/super-considered-super/

CodePudding user response：

You have some errors:

• super(AnphibiousCar, self).__init__(name, seats, engine_type) could become Boat.__init__(self, name, seats, engine_type) so calling the class you could give information about how to initialize it.
• there is a missing parameter in Boat where you should give a fuel argument to the superclass Vehicle, like super().__init__(name, seats, "oil")

As you can note if you use super you don't need to pass self, if you use the class name you are using it.

My point of view is that, yes, is good to understand, but don't loose to much time as this kind of multiple inheritance is only theoretical and practically not used in real coding. This in fact can cause a lot of confusion and add boilerplate... "new" languages like, for example, Rust do not even provide inheritance. Just to say: "Yes, study it, but keep it simple" ^_^