Kurs Python · Moduł 3: Programowanie obiektowe
Dziedziczenie - ewolucja gatunków
W tej lekcji11
Witaj znowu! Tu Darwin, mam dla Ciebie fascynujący temat.
W poprzednich lekcjach nauczyłeś/aś się tworzyć klasy reprezentujące gatunki. Ale w naturze gatunki nie są izolowane - są częścią hierarchii taksonomicznej! Lwy i tygrysy to różne gatunki, ale oba są kotowatymi. Kotowate i psowate to różne rodziny, ale oba są ssakami.
W programowaniu obiektowym ta hierarchia to dziedziczenie (inheritance) - jeden z najpotężniejszych mechanizmów OOP!
Czym jest dziedziczenie?
Dziedziczenie pozwala tworzyć nowe klasy na podstawie istniejących:
- Klasa bazowa (parent, superclass) - ogólniejsza, np. "Ssak"
- Klasa pochodna (child, subclass) - bardziej specyficzna, np. "Lew"
Klasa pochodna dziedziczy atrybuty i metody klasy bazowej, a następnie może:
- Używać dziedziczonych metod bez zmian
- Rozszerzać klasy bazowe (dodawać nowe metody)
- Nadpisywać metody (override) - zmienić zachowanie
# Klasa bazowa - ogólny Ssak
class Mammal:
def __init__(self, name):
self.name = name
def breathe(self):
return f"{self.name} oddycha powietrzem"
def move(self):
return f"{self.name} porusza się"
# Klasa pochodna - Lew dziedziczy z Mammal
class Lion(Mammal):
def __init__(self, name, pride_name):
super().__init__(name) # Wywołaj konstruktor rodzica
self.pride_name = pride_name # Dodaj własny atrybut
def roar(self):
"""Nowa metoda - tylko dla lwów"""
return f"{self.name} ryczy: RRROAAR!"
def move(self):
"""Nadpisanie metody rodzica"""
return f"{self.name} biegnie przez sawannę"
# Użycie
simba = Lion("Simba", "Pride Rock")
# Dziedziczone z Mammal
print(simba.breathe()) # "Simba oddycha powietrzem"
# Nadpisane w Lion
print(simba.move()) # "Simba biegnie przez sawannę"
# Własna metoda Lion
print(simba.roar()) # "Simba ryczy: RRROAAR!"
# Własny atrybut Lion
print(simba.pride_name) # "Pride Rock"Składnia dziedziczenia
Nazwę klasy bazowej wpisujesz w nawiasie po nazwie nowej klasy. Klasa pochodna od razu dostaje wszystkie metody rodzica, a może też dodać własne:
# Podstawowa składnia
class ChildClass(ParentClass):
pass
# Dziedziczenie z rozszerzeniem
class Animal:
def eat(self):
return "Jem"
class Dog(Animal): # Dog dziedziczy z Animal
def bark(self):
return "Hau hau!"
dog = Dog()
print(dog.eat()) # Dziedziczone: "Jem"
print(dog.bark()) # Własne: "Hau hau!"Funkcja super()
super() pozwala odwołać się do klasy bazowej - używaj jej do:
- Wywołania konstruktora rodzica
- Rozszerzenia metody rodzica (nie całkowitego nadpisania)
class Animal:
def __init__(self, name, age):
self.name = name
self.age = age
print(f"Tworzę zwierzę: {name}")
def describe(self):
return f"{self.name}, wiek: {self.age}"
class Bird(Animal):
def __init__(self, name, age, wingspan):
# Wywołaj konstruktor Animal
super().__init__(name, age)
# Dodaj własny atrybut
self.wingspan = wingspan
print(f"Rozpiętość skrzydeł: {wingspan}m")
def describe(self):
# Rozszerz metodę rodzica
base_desc = super().describe() # Wywołaj Animal.describe()
return f"{base_desc}, rozpiętość: {self.wingspan}m"
eagle = Bird("Orzeł", 5, 2.3)
# Drukuje:
# Tworzę zwierzę: Orzeł
# Rozpiętość skrzydeł: 2.3m
print(eagle.describe()) # "Orzeł, wiek: 5, rozpiętość: 2.3m"Nadpisywanie metod (Method Overriding)
Klasa pochodna może całkowicie zastąpić metodę rodzica:
class Animal:
def speak(self):
return "Zwierzę wydaje dźwięk"
class Dog(Animal):
def speak(self):
"""Nadpisz całkowicie"""
return "Hau hau!" # Całkowicie nowe zachowanie
class Cat(Animal):
def speak(self):
"""Nadpisz całkowicie"""
return "Miau!"
dog = Dog()
cat = Cat()
print(dog.speak()) # "Hau hau!" - nie "Zwierzę wydaje dźwięk"
print(cat.speak()) # "Miau!"Hierarchia klas - drzewo taksonomiczne
W naturze hierarchia jest głęboka: Królestwo → Typ → Klasa → Rząd → Rodzina → Rodzaj → Gatunek
# 1. Królestwo Animalia
class Animal:
kingdom = "Animalia"
def __init__(self, name):
self.name = name
def is_alive(self):
return True
def __str__(self):
return f"{self.name} ({self.__class__.__name__})"
# 2. Typ Chordata
class Chordate(Animal):
phylum = "Chordata"
def has_notochord(self): # struna grzbietowa
return True
# 3. Klasa Mammalia (Ssaki)
class Mammal(Chordate):
class_name = "Mammalia"
def __init__(self, name, fur_color):
super().__init__(name)
self.fur_color = fur_color
def nurse_young(self):
return f"{self.name} karmi młode mlekiem"
def regulate_temperature(self):
return f"{self.name} utrzymuje stałą temperaturę ciała"
# 4. Rząd Carnivora (Drapieżniki)
class Carnivore(Mammal):
order = "Carnivora"
def __init__(self, name, fur_color, hunting_style):
super().__init__(name, fur_color)
self.hunting_style = hunting_style
def hunt(self):
return f"{self.name} poluje używając: {self.hunting_style}"
# 5. Rodzina Felidae (Kotowate)
class Feline(Carnivore):
family = "Felidae"
def retract_claws(self):
return f"{self.name} chowa pazury"
def purr(self):
return f"{self.name} mruczy"
# 6. Gatunek Panthera leo (Lew)
class Lion(Feline):
species = "Panthera leo"
def __init__(self, name, fur_color, pride_name):
super().__init__(name, fur_color, "polowanie stadne")
self.pride_name = pride_name
def roar(self):
return f"{self.name} ryczy głośno!"
def lead_pride(self):
return f"{self.name} przewodzi stadzie {self.pride_name}"
# Użycie - lew ma dostęp do WSZYSTKICH metod hierarchii!
simba = Lion("Simba", "złoty", "Pride Rock")
# Z Animal
print(simba.is_alive()) # True
# Z Chordate
print(simba.has_notochord()) # True
# Z Mammal
print(simba.nurse_young()) # "Simba karmi młode mlekiem"
print(simba.regulate_temperature()) # "Simba utrzymuje stałą temperaturę ciała"
# Z Carnivore
print(simba.hunt()) # "Simba poluje używając: polowanie stadne"
# Z Feline
print(simba.retract_claws()) # "Simba chowa pazury"
print(simba.purr()) # "Simba mruczy"
# Własne Lion
print(simba.roar()) # "Simba ryczy głośno!"
print(simba.lead_pride()) # "Simba przewodzi stadzie Pride Rock"
# Atrybuty
print(simba.kingdom) # "Animalia"
print(simba.species) # "Panthera leo"
print(simba.fur_color) # "złoty"Sprawdzanie relacji klas
Python oferuje funkcje do sprawdzania hierarchii:
class Animal:
pass
class Mammal(Animal):
pass
class Lion(Mammal):
pass
simba = Lion()
# isinstance() - sprawdź czy obiekt jest instancją klasy
print(isinstance(simba, Lion)) # True
print(isinstance(simba, Mammal)) # True - Lion dziedziczy z Mammal
print(isinstance(simba, Animal)) # True - Lion dziedziczy z Animal (przez Mammal)
print(isinstance(simba, str)) # False
# issubclass() - sprawdź czy klasa dziedziczy z innej klasy
print(issubclass(Lion, Mammal)) # True
print(issubclass(Lion, Animal)) # True
print(issubclass(Mammal, Lion)) # False
print(issubclass(Lion, Lion)) # True - klasa jest podklasą samej siebie
# type() - zwróć dokładny typ
print(type(simba)) # <class '__main__.Lion'>
print(type(simba) == Lion) # True
print(type(simba) == Mammal) # False - simba to Lion, nie MammalWielodziedziczenie (Multiple Inheritance)
Python pozwala dziedziczyć z wielu klas naraz - klasa może mieć wielu rodziców!
class Swimmer:
def swim(self):
return f"{self.name} pływa"
class Flyer:
def fly(self):
return f"{self.name} lata"
class Walker:
def walk(self):
return f"{self.name} chodzi"
# Duck dziedziczy z trzech klas!
class Duck(Swimmer, Flyer, Walker):
def __init__(self, name):
self.name = name
def quack(self):
return f"{self.name}: Kwa kwa!"
donald = Duck("Donald")
# Ma dostęp do metod ze wszystkich klas bazowych
print(donald.swim()) # "Donald pływa"
print(donald.fly()) # "Donald lata"
print(donald.walk()) # "Donald chodzi"
print(donald.quack()) # "Donald: Kwa kwa!"MRO - Method Resolution Order
Gdy klasa dziedziczy z wielu rodziców, Python używa MRO (Method Resolution Order), aby określić kolejność szukania metod:
class A:
def method(self):
return "A"
class B(A):
def method(self):
return "B"
class C(A):
def method(self):
return "C"
class D(B, C): # Dziedziczy z B i C
pass
d = D()
print(d.method()) # "B" - Python szuka: D → B → C → A
# Sprawdź MRO
print(D.__mro__)
# (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>,
# <class '__main__.A'>, <class 'object'>)
# Lub czytelniej:
print(D.mro())Zasada: Python przeszukuje klasy od lewej do prawej, od najbardziej specyficznej do najbardziej ogólnej.
Przykład z safari - hierarchia gatunków z obserwacjami
Teraz cała hierarchia safari: wspólna klasa Species, pod nią ssaki i ptaki, dalej drapieżniki i roślinożercy, a na samym dole kotowate i psowate. Każdy poziom dokłada swoje atrybuty i rozszerza describe() przez super().
class Species:
"""
Klasa bazowa dla wszystkich gatunków w katalogu Safari
"""
kingdom = "Animalia"
total_species_count = 0
def __init__(self, scientific_name, common_name, habitat):
self.scientific_name = scientific_name
self.common_name = common_name
self.habitat = habitat
self.observations = []
Species.total_species_count += 1
def add_observation(self, date, location, count, notes=""):
"""Dodaj obserwację w terenie"""
self.observations.append({
"date": date,
"location": location,
"count": count,
"notes": notes
})
def get_total_observed(self):
"""Łączna liczba zaobserwowanych osobników"""
return sum(obs["count"] for obs in self.observations)
def describe(self):
"""Podstawowy opis gatunku"""
return f"{self.common_name} ({self.scientific_name})"
def __str__(self):
return self.describe()
class Mammal(Species):
"""
Klasa reprezentująca ssaki - rozszerza Species
"""
class_name = "Mammalia"
def __init__(self, scientific_name, common_name, habitat, fur_color, gestation_days):
# Wywołaj konstruktor Species
super().__init__(scientific_name, common_name, habitat)
# Dodaj atrybuty specyficzne dla ssaków
self.fur_color = fur_color
self.gestation_days = gestation_days
def nurse_young(self):
"""Ssaki karmią młode mlekiem"""
return f"{self.common_name} karmi młode mlekiem (ciąża trwa {self.gestation_days} dni)"
def describe(self):
"""Rozszerz opis o informacje o ssakach"""
base = super().describe() # Wywołaj Species.describe()
return f"{base} | Ssak | Futro: {self.fur_color}"
class Bird(Species):
"""
Klasa reprezentująca ptaki
"""
class_name = "Aves"
def __init__(self, scientific_name, common_name, habitat, wingspan_m, can_fly=True):
super().__init__(scientific_name, common_name, habitat)
self.wingspan_m = wingspan_m
self.can_fly = can_fly
def lay_eggs(self):
return f"{self.common_name} składa jaja"
def describe(self):
base = super().describe()
flight_status = "latający" if self.can_fly else "nielotny"
return f"{base} | Ptak {flight_status} | Rozpiętość: {self.wingspan_m}m"
class Carnivore(Mammal):
"""
Drapieżniki - dziedziczą z Mammal
"""
order = "Carnivora"
def __init__(self, scientific_name, common_name, habitat, fur_color,
gestation_days, hunting_style, pack_hunter=False):
super().__init__(scientific_name, common_name, habitat, fur_color, gestation_days)
self.hunting_style = hunting_style
self.pack_hunter = pack_hunter
def hunt(self):
style = "w stadzie" if self.pack_hunter else "samotnie"
return f"{self.common_name} poluje {style} używając: {self.hunting_style}"
def calculate_danger_level(self):
"""Oblicz poziom niebezpieczeństwa (1-10)"""
base_danger = 5
if self.pack_hunter:
base_danger += 3
if "zasadzka" in self.hunting_style:
base_danger += 2
return min(10, base_danger)
def describe(self):
base = super().describe()
danger = self.calculate_danger_level()
return f"{base} | Drapieżnik | Niebezp.: {danger}/10"
class Herbivore(Mammal):
"""
Roślinożercy - dziedziczą z Mammal
"""
def __init__(self, scientific_name, common_name, habitat, fur_color,
gestation_days, diet_type):
super().__init__(scientific_name, common_name, habitat, fur_color, gestation_days)
self.diet_type = diet_type # "liście", "trawa", "owoce"
def graze(self):
return f"{self.common_name} je {self.diet_type}"
def describe(self):
base = super().describe()
return f"{base} | Roślinożerca | Dieta: {self.diet_type}"
class Feline(Carnivore):
"""
Kotowate - dziedziczą z Carnivore
"""
family = "Felidae"
def __init__(self, scientific_name, common_name, habitat, fur_color,
gestation_days, has_mane=False, pride_size=1):
super().__init__(
scientific_name, common_name, habitat, fur_color,
gestation_days, "zasadzka i pościg", pack_hunter=(pride_size > 1)
)
self.has_mane = has_mane
self.pride_size = pride_size
def retract_claws(self):
return f"{self.common_name} chowa ostre pazury"
def stalk_prey(self):
return f"{self.common_name} skrada się cicho do zdobyczy"
def describe(self):
base = super().describe()
social = f"stadne ({self.pride_size})" if self.pride_size > 1 else "samotne"
return f"{base} | Kotowate | {social}"
class Canine(Carnivore):
"""
Psowate - dziedziczą z Carnivore
"""
family = "Canidae"
def __init__(self, scientific_name, common_name, habitat, fur_color,
gestation_days, pack_size=1):
super().__init__(
scientific_name, common_name, habitat, fur_color,
gestation_days, "pościg na dystansie", pack_hunter=(pack_size > 1)
)
self.pack_size = pack_size
def howl(self):
return f"{self.common_name} wyje do stada"
def track_scent(self):
return f"{self.common_name} tropi zdobycz po zapachu"
def describe(self):
base = super().describe()
social = f"wataha ({self.pack_size})" if self.pack_size > 1 else "samotne"
return f"{base} | Psowate | {social}"
# === DEMONSTRACJA - Tworzenie hierarchii Safari ===
print("=== KATALOG GATUNKÓW SAFARI - HIERARCHIA ===\n")
# Kotowate
lion = Feline(
scientific_name="Panthera leo",
common_name="Lew",
habitat="sawanna",
fur_color="złoty",
gestation_days=110,
has_mane=True,
pride_size=15
)
leopard = Feline(
scientific_name="Panthera pardus",
common_name="Lampart",
habitat="sawanna i lasy",
fur_color="żółty w czarne plamy",
gestation_days=90,
has_mane=False,
pride_size=1 # Samotnik
)
# Psowate
wild_dog = Canine(
scientific_name="Lycaon pictus",
common_name="Likaon",
habitat="sawanna",
fur_color="pstrokaty",
gestation_days=70,
pack_size=20
)
# Roślinożercy
elephant = Herbivore(
scientific_name="Loxodonta africana",
common_name="Słoń afrykański",
habitat="sawanna",
fur_color="szary",
gestation_days=645, # Najdłuższa ciąża!
diet_type="liście, kora, trawa"
)
giraffe = Herbivore(
scientific_name="Giraffa camelopardalis",
common_name="Żyrafa",
habitat="sawanna",
fur_color="żółty w brązowe plamy",
gestation_days=440,
diet_type="liście akacji"
)
# Ptaki
eagle = Bird(
scientific_name="Aquila rapax",
common_name="Orzeł sawannowy",
habitat="sawanna",
wingspan_m=2.1,
can_fly=True
)
# Dodaj obserwacje
lion.add_observation("2024-01-15", "Serengeti", 12, "Stado polujące na gnu")
lion.add_observation("2024-01-20", "Masai Mara", 8, "Rodzina z młodymi")
leopard.add_observation("2024-01-16", "Obszar skalny", 1, "Samotny samiec")
wild_dog.add_observation("2024-01-18", "Savuti", 18, "Wataha polująca")
elephant.add_observation("2024-01-17", "Amboseli", 45, "Duże stado przy wodopoju")
giraffe.add_observation("2024-01-19", "Tarangire", 23, "Żyrafy żerujące na akacjach")
eagle.add_observation("2024-01-21", "Niebo nad sawanną", 3, "Para z młodym")
# Wyświetl opisy - każdy używa swojej wersji describe()
print("LEW:")
print(f" {lion.describe()}")
print(f" {lion.hunt()}")
print(f" {lion.stalk_prey()}")
print(f" {lion.retract_claws()}")
print(f" {lion.nurse_young()}")
print(f" Obserwacje: {lion.get_total_observed()} osobników")
print(f"\nLAMPART:")
print(f" {leopard.describe()}")
print(f" {leopard.hunt()}")
print(f" Poziom niebezpieczeństwa: {leopard.calculate_danger_level()}/10")
print(f"\nLIKAON:")
print(f" {wild_dog.describe()}")
print(f" {wild_dog.hunt()}")
print(f" {wild_dog.howl()}")
print(f" {wild_dog.track_scent()}")
print(f"\nSŁOŃ:")
print(f" {elephant.describe()}")
print(f" {elephant.graze()}")
print(f" Obserwacje: {elephant.get_total_observed()} osobników")
print(f"\nŻYRAFA:")
print(f" {giraffe.describe()}")
print(f" {giraffe.graze()}")
print(f"\nORZEŁ:")
print(f" {eagle.describe()}")
print(f" {eagle.lay_eggs()}")
# Sprawdź hierarchię
print(f"\n=== HIERARCHIA KLAS ===")
print(f"Lew dziedziczy z Feline? {isinstance(lion, Feline)}")
print(f"Lew dziedziczy z Carnivore? {isinstance(lion, Carnivore)}")
print(f"Lew dziedziczy z Mammal? {isinstance(lion, Mammal)}")
print(f"Lew dziedziczy z Species? {isinstance(lion, Species)}")
print(f"Lew dziedziczy z Bird? {isinstance(lion, Bird)}")
print(f"\nMRO Feline: {[cls.__name__ for cls in Feline.mro()]}")
# ['Feline', 'Carnivore', 'Mammal', 'Species', 'object']
print(f"\n=== STATYSTYKI ===")
print(f"Łączna liczba gatunków w katalogu: {Species.total_species_count}")
# Polimorfizm - każdy gatunek ma swoją implementację describe()
print(f"\nWszystkie gatunki:")
all_animals = [lion, leopard, wild_dog, elephant, giraffe, eagle]
for animal in all_animals:
print(f" - {animal.describe()}")Praktyczne zasady dziedziczenia
1. Kiedy używać dziedziczenia?
Użyj dziedziczenia gdy:
- Relacja "jest" (is-a): Lew jest Ssakiem
- Chcesz reużyć kod z klasy bazowej
- Tworzysz hierarchię typów
NIE używaj dziedziczenia gdy:
- Relacja "ma" (has-a): Samochód ma Silnik (użyj kompozycji!)
- Klasy nie mają wspólnej natury
- Chcesz tylko pożyczyć kilka metod
# Dobre - relacja "jest"
class Animal:
pass
class Dog(Animal): # Pies JEST zwierzęciem
pass
# Złe - relacja "ma"
class Engine:
def start(self):
return "Silnik uruchomiony"
class Car(Engine): # NIE! Samochód NIE JEST silnikiem!
pass
# Dobre - kompozycja
class Car:
def __init__(self):
self.engine = Engine() # Samochód MA silnik
def start(self):
return self.engine.start()2. Zasada podstawienia Liskov (LSP)
Obiekt klasy pochodnej powinien móc zastąpić obiekt klasy bazowej bez zmiany poprawności programu.
def make_sound(animal):
"""Funkcja przyjmuje dowolne Animal"""
print(animal.speak())
class Animal:
def speak(self):
return "..."
class Dog(Animal):
def speak(self):
return "Hau!"
class Cat(Animal):
def speak(self):
return "Miau!"
# LSP - Dog i Cat mogą zastąpić Animal
make_sound(Dog()) # "Hau!" - działa
make_sound(Cat()) # "Miau!" - działa3. Unikaj głębokiej hierarchii
Każdy poziom dziedziczenia to kolejna klasa, którą trzeba przeczytać, żeby zrozumieć obiekt. Porównaj sześć pustych poziomów z trzema, które coś znaczą:
# Złe - zbyt głęboka hierarchia
class A:
pass
class B(A):
pass
class C(B):
pass
class D(C):
pass
class E(D):
pass
class F(E): # 6 poziomów!
pass
# Dobre - płaska, zrozumiała hierarchia
class Animal:
pass
class Mammal(Animal):
pass
class Lion(Mammal):
passTrzy poziomy, Animal → Mammal → Lion, czyta się od razu. Gdy hierarchia rośnie ponad trzy lub cztery poziomy, sprawdź, czy części zachowań nie lepiej przenieść do kompozycji.
Podsumowanie
W tej lekcji nauczyłeś/aś się:
- Czym jest dziedziczenie i dlaczego jest potężne
- Jak tworzyć klasy pochodne z
class Child(Parent) - Używania
super()do wywołania metod rodzica - Nadpisywania i rozszerzania metod
- Budowania hierarchii klas (drzewo taksonomiczne)
- Sprawdzania relacji z
isinstance()iissubclass() - Wielodziedziczenia i MRO
- Praktycznych zasad: kiedy używać dziedziczenia, a kiedy nie
Checkpoint
Przed przejściem dalej:
- Rozumiesz różnicę między klasą bazową a pochodną
- Potrafisz użyć
super()w konstruktorze - Wiesz jak nadpisać metodę rodzica
- Rozumiesz hierarchię i dziedziczenie wielu poziomów
- Znasz różnicę między relacją "jest" (dziedziczenie) a "ma" (kompozycja)
Analogia Safari: Hierarchia klas to drzewo ewolucyjne - każdy potomek dziedziczy cechy przodków, ale rozwija własne unikalne adaptacje!
W następnej lekcji Darwin nauczy Cię enkapsulacji - jak chronić wrażliwe dane gatunków przed nieautoryzowanym dostępem!
Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Jak zdefiniować klasę Cat dziedziczącą po Animal?
2. Do czego służy super().__init__()?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż elementy w prawidłowej kolejności:
- Edytor kodu
Stwórz klasę Tiger dziedziczącą po Animal(name, species): w __init__ wywołaj super().__init__(name, species) i dodaj atrybut stripes. Utwórz jednego tygrysa
- Edytor kodu
Klasa Animal ma metodę speak(). Nadpisz ją w klasie Tiger(Animal) tak, aby wyświetlała 'Rrrrr!'. Utwórz tygrysa i wywołaj speak()
- Układanie w poziomie
Ułóż nagłówek klasy Tiger, która dziedziczy po klasie Animal:
- Klikanie w kolejności
Kliknij elementy wywołania konstruktora klasy nadrzędnej z argumentem name: