Kurs Python · Moduł 3: Programowanie obiektowe
Klasy jako gatunki w naturze
W tej lekcji9
Witaj w Module 3! Tu Darwin, mam dla Ciebie nowy paradygmat programowania.
Do tej pory nauczyłeś/aś się programowania proceduralnego - pisałeś/aś funkcje, które przetwarzają dane. Teraz czas na Programowanie Obiektowe (OOP - Object-Oriented Programming) - sposób organizowania kodu wokół obiektów, które łączą dane i zachowania.
Wyobraź sobie klasyfikację biologiczną. Biologowie nie opisują każdego zwierzęcia od zera. Zamiast tego tworzą gatunki (species) ze wspólnymi cechami:
- Wszystkie lwy (Panthera leo) mają cztery łapy, są mięsożerne, żyją w stadach
- Wszystkie pytony królewskie (Python regius) są wężami, zjadają zdobycz w całości, polują nocą
W OOP robimy to samo - tworzymy klasy jako "szablony" dla obiektów!
Czym jest Programowanie Obiektowe?
OOP to paradygmat programowania oparty na koncepcji obiektów, które zawierają:
- Dane (atrybuty, właściwości) - opisują stan obiektu
- Zachowania (metody) - opisują co obiekt może robić
Kluczowe pojęcia OOP:
- Klasa (Class) - szablon, przepis, gatunek biologiczny
- Obiekt (Object) - konkretna instancja klasy, konkretne zwierzę
- Atrybuty (Attributes) - dane obiektu (cechy zwierzęcia)
- Metody (Methods) - funkcje związane z obiektem (zachowania zwierzęcia)
# Prosty przykład - klasyfikacja biologiczna
class Species:
"""Klasa reprezentująca gatunek"""
def __init__(self, name, habitat, diet):
"""Konstruktor - inicjalizuje obiekt"""
self.name = name
self.habitat = habitat
self.diet = diet
def describe(self):
"""Metoda - opisz gatunek"""
return f"{self.name} - siedlisko: {self.habitat}, dieta: {self.diet}"
# Tworzenie obiektów (instancji klasy)
lion = Species("Lew", "sawanna", "mięso")
python = Species("Pyton", "dżungla", "gryzonie")
# Używanie obiektów
print(lion.describe()) # "Lew - siedlisko: sawanna, dieta: mięso"
print(python.describe()) # "Pyton - siedlisko: dżungla, dieta: gryzonie"W tym przykładzie są dwa nowe elementy. __init__ to konstruktor: Python wywołuje go sam przy tworzeniu obiektu, np. Species("Lew", "sawanna", "mięso"). self to odwołanie do aktualnego obiektu, czyli do tego konkretnego zwierzęcia: self.name = name zapisuje nazwę właśnie w nim. Dokładniej omówimy oba w następnej lekcji.
Dlaczego OOP?
Bez OOP (proceduralnie)
Zacznijmy od stylu, który już znasz: każda cecha zwierzęcia to osobna zmienna, a funkcja dostaje je wszystkie jako argumenty.
# Dane i funkcje są oddzielne
lion_name = "Lew"
lion_habitat = "sawanna"
lion_diet = "mięso"
python_name = "Pyton"
python_habitat = "dżungla"
python_diet = "gryzonie"
def describe_animal(name, habitat, diet):
return f"{name} - siedlisko: {habitat}, dieta: {diet}"
print(describe_animal(lion_name, lion_habitat, lion_diet))
print(describe_animal(python_name, python_habitat, python_diet))Dla dwóch zwierząt to jeszcze działa, ale każde kolejne to trzy nowe zmienne do śledzenia. Przy dwudziestu gatunkach łatwo pomylić nazwy i podać funkcji siedlisko lwa razem z dietą pytona.
Z OOP
Teraz te same dwa zwierzęta zapisane jako obiekty: klasa Animal trzyma dane i metodę describe() w jednym miejscu.
# Dane i funkcje są razem w obiektach
class Animal:
def __init__(self, name, habitat, diet):
self.name = name
self.habitat = habitat
self.diet = diet
def describe(self):
return f"{self.name} - siedlisko: {self.habitat}, dieta: {self.diet}"
lion = Animal("Lew", "sawanna", "mięso")
python = Animal("Pyton", "dżungla", "gryzonie")
print(lion.describe())
print(python.describe())Wynik jest taki sam, ale kod jest lepiej zorganizowany: dane i zachowania są razem, a kolejne zwierzę to jedna linia Animal(...) zamiast trzech nowych zmiennych.
4 Filary OOP
1. Enkapsulacja (Encapsulation)
Grupowanie danych i metod w jednym obiekcie + ukrywanie szczegółów implementacji.
class BankAccount:
def __init__(self, balance):
self.__balance = balance # Prywatny atrybut (__)
def deposit(self, amount):
"""Publiczna metoda"""
if amount > 0:
self.__balance += amount
def get_balance(self):
"""Publiczny dostęp do prywatnego atrybutu"""
return self.__balance
account = BankAccount(1000)
account.deposit(500)
print(account.get_balance()) # 1500Saldo zmienia się wyłącznie przez metodę deposit(), która przyjmuje tylko dodatnie kwoty. Próba odczytu account.__balance spoza klasy kończy się błędem AttributeError, bo atrybut z dwoma podkreśleniami jest prywatny.
2. Abstrakcja (Abstraction)
Ukrywanie złożoności, pokazywanie tylko niezbędnego interfejsu.
class Car:
def start_engine(self):
"""Prosty interfejs"""
self.__check_fuel()
self.__ignite_spark_plugs()
self.__start_motor()
print("Silnik uruchomiony!")
def __check_fuel(self):
"""Ukryta implementacja"""
pass
def __ignite_spark_plugs(self):
"""Ukryta implementacja"""
pass
def __start_motor(self):
"""Ukryta implementacja"""
pass
car = Car()
car.start_engine() # Prosty interfejs - nie musisz znać szczegółów!3. Dziedziczenie (Inheritance)
Tworzenie nowych klas na bazie istniejących - hierarchia taksonomiczna!
class Animal:
"""Klasa bazowa (parent, superclass)"""
def __init__(self, name):
self.name = name
def eat(self):
return f"{self.name} je"
class Mammal(Animal):
"""Klasa pochodna (child, subclass)"""
def __init__(self, name, fur_color):
super().__init__(name) # Wywołaj konstruktor klasy bazowej
self.fur_color = fur_color
def nurse_young(self):
return f"{self.name} karmi młode mlekiem"
lion = Mammal("Lew", "złoty")
print(lion.eat()) # Dziedziczone z Animal
print(lion.nurse_young()) # Własna metoda Mammal4. Polimorfizm (Polymorphism)
Różne obiekty mogą reagować na tę samą metodę na różne sposoby.
class Dog:
def speak(self):
return "Hau hau!"
class Cat:
def speak(self):
return "Miau!"
class Cow:
def speak(self):
return "Muuu!"
# Polimorfizm - ta sama metoda, różne zachowania
animals = [Dog(), Cat(), Cow()]
for animal in animals:
print(animal.speak()) # Każdy "mówi" inaczej!Przykład z safari - Klasyfikacja gatunków
Połączmy te elementy w jednej klasie: gatunek ma nazwę naukową, siedlisko i listę obserwacji, a metody liczą osobniki i oceniają, czy gatunek jest zagrożony.
class Species:
"""
Klasa reprezentująca gatunek w ekspedycji Safari
Analogia: Biologiczny gatunek z cechami wspólnymi
"""
def __init__(self, scientific_name, common_name, habitat, dangerous=False):
"""
Konstruktor - inicjalizuje nowy gatunek
Args:
scientific_name: Nazwa naukowa (np. "Panthera leo")
common_name: Nazwa zwyczajowa (np. "Lew")
habitat: Środowisko naturalne
dangerous: Czy niebezpieczny dla ludzi
"""
self.scientific_name = scientific_name
self.common_name = common_name
self.habitat = habitat
self.dangerous = dangerous
self.observations = [] # Lista obserwacji
def add_observation(self, location, count, notes=""):
"""Dodaj obserwację gatunku"""
observation = {
"location": location,
"count": count,
"notes": notes
}
self.observations.append(observation)
print(f"Dodano obserwację: {count}x {self.common_name} w {location}")
def get_total_observed(self):
"""Zwróć łączną liczbę zaobserwowanych osobników"""
return sum(obs["count"] for obs in self.observations)
def is_threatened(self):
"""Sprawdź czy gatunek jest zagrożony (mniej niż 10 obserwacji)"""
return self.get_total_observed() < 10
def get_status(self):
"""Zwróć status gatunku"""
total = self.get_total_observed()
if total == 0:
return "Nie zaobserwowano"
elif self.is_threatened():
return f"Zagrożony ({total} osobników)"
else:
return f"Stabilny ({total} osobników)"
def describe(self):
"""Pełny opis gatunku"""
danger_status = "NIEBEZPIECZNY" if self.dangerous else "Bezpieczny"
return f"""
╔═══════════════════════════════════════════════╗
{self.common_name} ({self.scientific_name})
Siedlisko: {self.habitat}
Status: {danger_status}
Obserwacje: {len(self.observations)}
Osobniki: {self.get_total_observed()}
Stan: {self.get_status()}
╚═══════════════════════════════════════════════╝
""".strip()
# Użycie
lion = Species(
scientific_name="Panthera leo",
common_name="Lew",
habitat="sawanna",
dangerous=True
)
# Dodaj obserwacje
lion.add_observation("Sawanna Północna", 5, "Stado polujące")
lion.add_observation("Dolina Rift", 3, "Dwa dorosłe lwy z młodymi")
lion.add_observation("Park Serengeti", 8)
# Wyświetl informacje
print(lion.describe())
print(f"\nŁącznie zaobserwowano: {lion.get_total_observed()} lwów")
print(f"Czy zagrożony? {'Tak' if lion.is_threatened() else 'Nie'}")Porównanie: Funkcje vs Klasy
Podejście proceduralne (funkcje i słowniki)
Najpierw gatunek jako zwykły słownik i trzy osobne funkcje, które ten słownik tworzą, zmieniają i podsumowują.
def create_species(name, habitat):
"""Zwraca słownik reprezentujący gatunek"""
return {
"name": name,
"habitat": habitat,
"observations": []
}
def add_observation(species_dict, location, count):
"""Modyfikuje słownik"""
species_dict["observations"].append({"location": location, "count": count})
def get_total(species_dict):
"""Oblicza ze słownika"""
return sum(obs["count"] for obs in species_dict["observations"])
# Użycie - funkcje i dane są oddzielne
lion = create_species("Lew", "sawanna")
add_observation(lion, "Północ", 5)
print(get_total(lion))Podejście obiektowe
Ta sama logika jako klasa: klucze słownika stają się atrybutami obiektu, a funkcje jego metodami.
class Species:
def __init__(self, name, habitat):
self.name = name
self.habitat = habitat
self.observations = []
def add_observation(self, location, count):
"""Dane i logika razem!"""
self.observations.append({"location": location, "count": count})
def get_total(self):
return sum(obs["count"] for obs in self.observations)
# Użycie - dane i zachowania razem
lion = Species("Lew", "sawanna")
lion.add_observation("Północ", 5)
print(lion.get_total())Zalety OOP:
- Dane i metody są razem (logiczne grupowanie)
- Łatwiejsze zarządzanie stanem
- Możliwość dziedziczenia i reużycia kodu
- Lepszy design dla złożonych systemów
- Enkapsulacja chroni dane
Kiedy używać OOP?
Użyj OOP gdy:
- Modelujesz rzeczywiste encje (zwierzęta, pojazdy, użytkowników)
- Potrzebujesz wielu podobnych obiektów z różnymi danymi
- Chcesz ukryć szczegóły implementacji (enkapsulacja)
- Potrzebujesz hierarchii i dziedziczenia
- Projektujesz API lub bibliotekę
Użyj funkcji/procedur gdy:
- Prosty, liniowy skrypt
- Przetwarzanie danych bez stanu
- Funkcje pomocnicze (utility functions)
- Nie potrzebujesz wielu instancji
Praktyczny przykład - menedżer ekspedycji
Na koniec większa klasa, która prowadzi całą ekspedycję: zapisuje członków zespołu i odkrycia z kolejnych dni, a potem drukuje raport.
class Expedition:
"""
Klasa zarządzająca ekspedycją Safari
Łączy dane (lokacja, zespół, odkrycia) i zachowania (dodawanie, raportowanie)
"""
def __init__(self, name, leader, start_date):
self.name = name
self.leader = leader
self.start_date = start_date
self.team_members = []
self.discovered_species = []
self.days_elapsed = 0
def add_team_member(self, member_name, role):
"""Dodaj członka zespołu"""
member = {"name": member_name, "role": role}
self.team_members.append(member)
print(f"{member_name} ({role}) dołączył/a do ekspedycji")
def discover_species(self, species_name, location, count=1):
"""Zapisz odkrycie gatunku"""
discovery = {
"species": species_name,
"location": location,
"count": count,
"day": self.days_elapsed
}
self.discovered_species.append(discovery)
print(f"Dzień {self.days_elapsed}: Odkryto {count}x {species_name} w {location}")
def advance_day(self):
"""Kolejny dzień ekspedycji"""
self.days_elapsed += 1
print(f"\nDzień {self.days_elapsed} ekspedycji '{self.name}'")
def get_statistics(self):
"""Statystyki ekspedycji"""
unique_species = len(set(d["species"] for d in self.discovered_species))
total_animals = sum(d["count"] for d in self.discovered_species)
return {
"ekspedycja": self.name,
"lider": self.leader,
"dni": self.days_elapsed,
"zespół": len(self.team_members),
"unikalne_gatunki": unique_species,
"łącznie_osobników": total_animals
}
def generate_report(self):
"""Wygeneruj raport ekspedycji"""
stats = self.get_statistics()
report = f"""
╔══════════════════════════════════════════════════════════╗
RAPORT EKSPEDYCJI: {self.name}
╠══════════════════════════════════════════════════════════╣
Lider: {self.leader}
Data rozpoczęcia: {self.start_date}
Dni w terenie: {stats['dni']}
Członkowie zespołu: {stats['zespół']}
╠══════════════════════════════════════════════════════════╣
ODKRYCIA:
- Unikalne gatunki: {stats['unikalne_gatunki']}
- Łączna liczba osobników: {stats['łącznie_osobników']}
╠══════════════════════════════════════════════════════════╣
ZESPÓŁ:
"""
for member in self.team_members:
report += f"\n - {member['name']} ({member['role']})"
report += "\n╚══════════════════════════════════════════════════════════╝"
return report
# Symulacja ekspedycji
expedition = Expedition("Safari 2024", "Dr. Jane Wilson", "2024-06-01")
# Dodaj zespół
expedition.add_team_member("Darwin Brown", "Biolog")
expedition.add_team_member("Alex Chen", "Fotograf")
expedition.add_team_member("Maya Patel", "Przewodnik")
# Dni ekspedycji
expedition.advance_day()
expedition.discover_species("Panthera leo", "Sawanna Północna", 5)
expedition.discover_species("Loxodonta africana", "Dolina Słoni", 12)
expedition.advance_day()
expedition.discover_species("Python regius", "Dżungla", 2)
expedition.discover_species("Panthera leo", "Sawanna Południowa", 3)
expedition.advance_day()
expedition.discover_species("Gorilla gorilla", "Las mglisty", 8)
# Raport końcowy
print("\n" + expedition.generate_report())Podsumowanie
W tej lekcji nauczyłeś/aś się:
- Czym jest Programowanie Obiektowe (OOP)
- Różnicy między podejściem proceduralnym a obiektowym
- 4 filarów OOP: enkapsulacja, abstrakcja, dziedziczenie, polimorfizm
- Dlaczego OOP jest potężne dla organizacji kodu
- Kiedy używać OOP, a kiedy funkcji
- Podstawowych konceptów: klasa, obiekt, atrybut, metoda
- Praktycznych przykładów Safari
Checkpoint
Przed przejściem dalej:
- Rozumiesz różnicę między klasą a obiektem
- Znasz 4 filary OOP (enkapsulacja, abstrakcja, dziedziczenie, polimorfizm)
- Rozumiesz dlaczego grupujemy dane i zachowania razem
- Widzisz analogię między klasami a gatunkami biologicznymi
- Wiesz kiedy używać OOP, a kiedy funkcji
Analogia Safari: Klasa to gatunek (Panthera leo), obiekt to konkretne zwierzę (konkretny lew o imieniu Simba)!
W następnej lekcji Darwin nauczy Cię jak tworzyć własne klasy i obiekty - stworzysz kompletny system klasyfikacji gatunków!
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. Klasa w Pythonie to:
2. Metoda __init__ służy do:
To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w pionie
Uporządkuj kroki tworzenia klasy i obiektu:
- Edytor kodu
Utwórz klasę Animal z metodą __init__, która przyjmuje name i species i zapisuje je w atrybutach self.name i self.species
- Edytor kodu
Zdefiniuj klasę Animal z __init__(self, name, species) i utwórz jej instancję: tiger = Animal('Tygrys', 'Panthera tigris')
- Układanie w poziomie
Ułóż nagłówek definicji klasy Animal:
- Klikanie w kolejności
Kliknij elementy nagłówka konstruktora, który przyjmuje parametr name:
- Układanie w pionie
Uporządkuj linie klasy Animal z konstruktorem (pierwsza metoda) i metodą describe():