Problem z dziedziczeniem wielokrotnym

Cześć,
mógłby mi ktoś podpowiedzieć, dlaczego nie wychodzi mi dziedziczenie wielokrotnie w klasie "Uzytkownik"?

class Samochod:
    def __init__(self, marka, rok_produkcji):
        self.marka = marka
        self.rok_produkcji = rok_produkcji
    def info_o_marce(self):
        print(f"Marka: {self.marka} \nRok produkcji: {self.rok_produkcji}")
class Model(Samochod):
    def __init__(self, marka, rok_produkcji,model):
        super().__init__(marka,rok_produkcji)
        self.model = model
    def info_o_modelu(self):
        print(f"\n\nMarka samochodu: {self.marka} \nRok samochodu: {self.rok_produkcji} \nMarka samochodu: {self.model}")
class Uzytkownik(Samochod, Model):
    def __init(self, marka,rok_produkcji,model,typ_czlowieka):
        super().__init__(marka,rok_produkcji,model)
        self.typ_czlowieka = typ_czlowieka
    def info_calosc(self):
        print(f"\n\nMarka samochodu: {self.marka} \nRok samochodu: {self.rok_produkcji} \nMarka samochodu: {self.model}, \nUżytkownik: {self.typ_czlowieka}")

samochod = Samochod("Audi", 2022)
samochod.info_o_marce()

samochod2 = Model("BMW",2022,"Seria 3")
samochod2.info_o_modelu()

samochod3 = Uzytkownik("Volvo", 22, "S90", "Dobry kierowca")
samochod3.info_calosc()

https://pl.quish.tv/introduction-python-multiple-inheritance-with-examples

line 13, in <module>
    class Uzytkownik(Samochod, Model):
TypeError: Cannot create a consistent method resolution
order (MRO) for bases Samochod, Model

https://stackoverflow.com/questions/46199975/resolving-diamond-inheritance-within-python-classes
https://www.geeksforgeeks.org/method-resolution-order-in-python-inheritance/

Ale po co ci dziedziczenie wielokrotne, skoro Model dziedziczy już z Samochod, więc wystarczy odziedziczyć z Model i masz już dziedziczenie z samochód.

 class Uzytkownik(Model):

Pomijając już, że cała ta hierarchia klas żadnego logicznego sensu nie ma i jest nadużywaniem koncepcji dziedziczenia z OOP, żeby zrobić... nie wiem co? To wygląda jak kompozycja i relacje między różnymi "bytami"(Samochód, Model, Człowiek) zaimplementowane nie wiadomo czemu przy użyciu dziedziczenia.

LukeJL napisał(a):

Ale po co ci dziedziczenie wielokrotne, skoro Model dziedziczy już z Samochod, więc wystarczy odziedziczyć z Model i masz już dziedziczenie z samochód.

 class Uzytkownik(Samochod):

Pomijając już, że cała ta hierarchia klas żadnego logicznego sensu nie ma i jest nadużywaniem koncepcji dziedziczenia z OOP, żeby zrobić... nie wiem co?

Chcę się po prostu tego nauczyć. Wymyśliłem na szybko przykład, aby zrozumieć samą koncepcję. Dalej mi to niestety nie wychodzi. Obejrzałem tutorial, ale dalej jest gdzieś błąd

Aha masz tam literówkę:
masz:

def __init

a powinno być:

def __init__

przez to nie rozpoznaje tego jako konstruktor.
No i to zamienisz i dasz:

class Uzytkownik(Model):

zamiast dziedziczyć wielokrotnie i program się odpali i chyba prawidłowo wyświetla wszystko. Ale to sobie zobacz.

@LukeJL: Miałeś rację. Samo dziedziczenie po modelu jest poprawne.
Widocznie wymyśliłem zły i bezsensowny przykład i dlatego nie wychodziło

class Samochod:
    def __init__(self, marka, rok_produkcji):
        self.marka = marka
        self.rok_produkcji = rok_produkcji
    def info_o_marce(self):
        print(f"Marka: {self.marka} \nRok produkcji: {self.rok_produkcji}")
class Model(Samochod):
    def __init__(self, marka, rok_produkcji,model):
        super().__init__(marka,rok_produkcji)
        self.model = model
    def info_o_modelu(self):
        print(f"\n\nMarka samochodu: {self.marka} \nRok samochodu: {self.rok_produkcji} \nMarka samochodu: {self.model}")
class Uzytkownik(Model):
    def __init__(self, marka,rok_produkcji,model,typ_czlowieka):
        super().__init__(marka, rok_produkcji,model)
        self.typ_czlowieka = typ_czlowieka
    def info_calosc(self):
        print(f"\n\nMarka samochodu: {self.marka} \nRok samochodu: {self.rok_produkcji} \nMarka samochodu: {self.model}, \nUżytkownik: {self.typ_czlowieka}")

samochod = Samochod("Audi", 2022)
samochod.info_o_marce()

samochod2 = Model("BMW",2022,"Seria 3")
samochod2.info_o_modelu()

samochod3 = Uzytkownik("Volvo", 22, "S90", "Dobry kierowca")
samochod3.info_calosc()

Wrzuć sobie na yt hasło "Dziedziczenie" i jeszcze raz przejdź przez temat, bo nie do końca je rozumiesz.

@Ignacy: Znajdz jakis sensowny "use case" dla wielokrotnego dziedziczenia, i zaimplementuj; pamietaj o, mro.

To co up + hasło do wygooglowania -> Mixins

Ten przykład ja bym na dobry początek przepisał tak:

class Samochod:
    def __init__(self, marka, model, rok_produkcji):
        self.marka = marka
        self.model = model    
        self.rok_produkcji = rok_produkcji
    def info(self):
        return f"Marka: {self.marka} \nRok: {self.rok_produkcji} \nMarka: {self.model}"

class Uzytkownik:
    def __init__(self, samochod, typ_czlowieka):
        self.samochod = samochod
        self.typ_czlowieka = typ_czlowieka
    def info(self):
        return f"Użytkownik: {self.typ_czlowieka}\nSamochód: \n\n{self.samochod.info()}"
        
uzytkownik = Uzytkownik(Samochod("Volvo", "S90", 22), "Dobry kierowca")
print(uzytkownik.info())

Czyli:

1. wywaliłem dziedziczenie, zamieniłem na kompozycję - użytkownik jest skojarzony z samochodem, więc go "ma" - self.samochod = samochod. Dzięki temu mamy niezależność tych dwóch klas i samochód sam umie wyświetlić info o sobie i nie ma duplikacji kodu, kiedy w każdej klasie musiałeś w znacznej mierze duplikować kod wypisujący info
2. metody do wyświetlania info nazwałem po prostu info oraz zamieniłem, żeby nie drukowały tekstu, tylko zwracały stringa z tekstem. Jest to bardziej elastyczne, bo dzięki temu masz kontrolę, jak to wyświetlać. A np. mógłbyś nie chcieć wyświetlać info w konsoli, tylko zapisać ten tekst do pliku.
3. klasę Samochód i Model scaliłem w jedno. I na tak małym przykładzie jest to okej, natomiast można się zastanawiać, czy w większym projekcie nie lepiej byłoby zrobić dodatkowych klas, które reprezentowałyby konkretną markę (tylko nie trzeba z nich dziedziczyć, wystarczyłoby, że marka to nie byłby string tylko egzemplarz klasy Marka):

volvo = Marka("Volvo")
samochod = Samochod(volvo, "S90", 22)

jednak w tak małym projekcie jest to zbyteczne.

Dalsze rzeczy, które bym zrobił:

1. zamieniłbym nazwy zmiennych, klas, funkcji na angielskie
2. zastanowiłbym się, czy w ogóle klasy są potrzebne. Przecież tu nie ma żadnej logiki, a jedynie formatowanie danych, te dane można byłoby trzymać po prostu w słownikach.

Czyli finalnie zrobiłbym coś takiego

def car_info(car):
    return f"Marka: {car['brand']} \nRok: {car['year']} \nModel: {car['model']}"
def user_info(user):
    return f"Użytkownik: {user['kind']}\nSamochód: \n{car_info(user['car'])}"
        
user = {
    'car': {
        'brand': "Volvo", 
        'model': "S90",
        'year': 22,
    },
    'kind': "Dobry kierowca"
}
print(user_info(user))

I z 18 linijek kodu hierarchii klas wychodzą raptem 4 linijki, które wyświetlają słowniki w sposób przyjazny dla użytkownika.