Problem z dziedziczeniem wielokrotnym

Problem z dziedziczeniem wielokrotnym
IG
  • Rejestracja: dni
  • Ostatnio: dni
  • Postów: 27
0

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

Kopiuj
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()
lion137
  • Rejestracja: dni
  • Ostatnio: dni
  • Postów: 5023
1
Kopiuj
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/

LukeJL
  • Rejestracja: dni
  • Ostatnio: dni
  • Postów: 8487
3

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.

Kopiuj
 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.

IG
  • Rejestracja: dni
  • Ostatnio: dni
  • Postów: 27
0
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.

Kopiuj
 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

LukeJL
  • Rejestracja: dni
  • Ostatnio: dni
  • Postów: 8487
1

Aha masz tam literówkę:
masz:

Kopiuj
def __init

a powinno być:

Kopiuj
def __init__

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

Kopiuj
class Uzytkownik(Model):

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

IG
  • Rejestracja: dni
  • Ostatnio: dni
  • Postów: 27
0

@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

Kopiuj
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()
ledi12
  • Rejestracja: dni
  • Ostatnio: dni
  • Lokalizacja: Wrocław
45

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

lion137
  • Rejestracja: dni
  • Ostatnio: dni
  • Postów: 5023
3

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

ledi12
  • Rejestracja: dni
  • Ostatnio: dni
  • Lokalizacja: Wrocław
48

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

LukeJL
  • Rejestracja: dni
  • Ostatnio: dni
  • Postów: 8487
2

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

Kopiuj
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):
Kopiuj
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

Kopiuj
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.

Zarejestruj się i dołącz do największej społeczności programistów w Polsce.

Otrzymaj wsparcie, dziel się wiedzą i rozwijaj swoje umiejętności z najlepszymi.