Kurs Python · Moduł 3: Programowanie obiektowe

Klasy jako gatunki w naturze

9 min czytania ·
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:

  1. Klasa (Class) - szablon, przepis, gatunek biologiczny
  2. Obiekt (Object) - konkretna instancja klasy, konkretne zwierzę
  3. Atrybuty (Attributes) - dane obiektu (cechy zwierzęcia)
  4. 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())  # 1500

Saldo 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 Mammal

4. 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. 1. Klasa w Pythonie to:

  2. 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():

  1. PytanieCzym jest klasa?
  2. PytanieMetoda __init__
  3. PytanieParametr self
  4. Ułóż w kolejnościTworzenie klasy i obiektu
  5. PytanieTworzenie instancji
  6. Zadanie z kodemPierwsza klasa
  7. Zadanie z kodemTworzenie instancji
  8. Ułóż w kolejnościDefinicja klasy
  9. Kliknij w kolejnościMetoda __init__
  10. Ułóż w kolejnościKlasa z metodą

Przydatne artykuły