Kurs Python · Moduł 3: Programowanie obiektowe

Tworzenie własnych gatunków

11 min czytania ·
W tej lekcji11

Witaj ponownie! Tu Darwin, gotowy, żeby zanurzyć się z Tobą głębiej w OOP.

W poprzedniej lekcji poznałeś/aś koncepcję klas i obiektów. Teraz czas nauczyć się jak tworzyć własne klasy od podstaw - tak jak biologowie klasyfikują nowe gatunki w terenie!

Anatomia klasy w Pythonie

Klasa składa się z kilku kluczowych elementów:

class Animal:  # 1. Nazwa klasy (PascalCase)
    """Dokumentacja klasy - opis co reprezentuje"""  # 2. Docstring

    species_count = 0  # 3. Atrybut klasowy (współdzielony)

    def __init__(self, name, age):  # 4. Konstruktor
        """Inicjalizuje nowy obiekt"""
        self.name = name  # 5. Atrybuty instancji
        self.age = age
        Animal.species_count += 1  # Zwiększ licznik

    def make_sound(self):  # 6. Metoda instancji
        """Zwierzę wydaje dźwięk"""
        return f"{self.name} wydaje dźwięk!"

    @classmethod  # 7. Metoda klasowa
    def get_species_count(cls):
        """Zwróć liczbę stworzonych zwierząt"""
        return cls.species_count

    @staticmethod  # 8. Metoda statyczna
    def is_adult(age):
        """Sprawdź czy dorosłe (bez dostępu do self/cls)"""
        return age >= 2

# Tworzenie obiektów
lion = Animal("Simba", 3)
elephant = Animal("Dumbo", 5)

print(lion.name)  # "Simba" - atrybut instancji
print(Animal.get_species_count())  # 2 - metoda klasowa
print(Animal.is_adult(3))  # True - metoda statyczna

1. Definiowanie klasy - class

Składnia: class NazwaKlasy:

Konwencje nazewnictwa:

  • PascalCase (każde słowo wielką literą): Species, AnimalBehavior, DataProcessor
  • Opisowa nazwa: co klasa reprezentuje
  • Rzeczownik, nie czasownik: Lion, nie RunsLion
# Dobre nazwy
class Species:
    pass

class ExpeditionTeam:
    pass

class GeneticAnalyzer:
    pass

# Złe nazwy
class species:  # małe litery
    pass

class data:  # zbyt ogólne
    pass

class doSomething:  # camelCase + czasownik
    pass

2. Konstruktor - __init__

Konstruktor (__init__) to specjalna metoda wywoływana automatycznie przy tworzeniu obiektu.

class Species:
    def __init__(self, name, habitat):
        """
        Konstruktor - inicjalizuje nowy gatunek

        Args:
            name: Nazwa gatunku
            habitat: Środowisko naturalne
        """
        print(f"Tworzę nowy gatunek: {name}")
        self.name = name  # Atrybut instancji
        self.habitat = habitat
        self.discovered_date = "2024-01-01"  # Domyślna wartość

# Wywołanie konstruktora
lion = Species("Lew", "sawanna")
# Automatycznie wywołuje: Species.__init__(lion, "Lew", "sawanna")
# Drukuje: "Tworzę nowy gatunek: Lew"

print(lion.name)  # "Lew"
print(lion.habitat)  # "sawanna"

Parametr self

self to referencja do aktualnego obiektu. Python automatycznie przekazuje obiekt jako pierwszy argument!

class Animal:
    def __init__(self, name):
        self.name = name  # self = aktualny obiekt
        # self.name oznacza "atrybut 'name' TEGO obiektu"

    def greet(self):
        # self pozwala dostać się do atrybutów obiektu
        return f"Cześć, jestem {self.name}!"

lion = Animal("Simba")
# Wywołanie: lion.greet()
# Python automatycznie: Animal.greet(lion)  ← lion staje się self!

elephant = Animal("Dumbo")
# elephant.greet() → Animal.greet(elephant) ← elephant to self!

print(lion.greet())     # "Cześć, jestem Simba!"
print(elephant.greet()) # "Cześć, jestem Dumbo!"

UWAGA: Możesz użyć innej nazwy niż self, ale jest to silna konwencja Pythona!

# Standardowe (używaj tego!)
def __init__(self, name):
    self.name = name

# Technicznie poprawne, ale NIE RÓB TAK
def __init__(this, name):  # Jak w Javie/C#
    this.name = name

def __init__(obj, name):  # Mylące
    obj.name = name

3. Atrybuty instancji vs atrybuty klasowe

Atrybuty instancji

Atrybuty instancji należą do konkretnego obiektu. Każdy obiekt ma własne wartości!

class Species:
    def __init__(self, name, count):
        self.name = name  # Atrybut instancji
        self.count = count  # Każdy obiekt ma własną wartość

lion = Species("Lew", 500)
elephant = Species("Słoń", 300)

print(lion.count)     # 500 - osobna wartość
print(elephant.count) # 300 - osobna wartość

lion.count = 550  # Zmienia TYLKO lwa
print(lion.count)     # 550
print(elephant.count) # 300 - bez zmian!

Atrybuty klasowe

Atrybuty klasowe należą do klasy, są współdzielone przez wszystkie obiekty!

class Species:
    total_species = 0  # Atrybut klasowy - współdzielony!

    def __init__(self, name):
        self.name = name  # Atrybut instancji
        Species.total_species += 1  # Zwiększ współdzielony licznik

lion = Species("Lew")
elephant = Species("Słoń")
python = Species("Pyton")

print(Species.total_species)  # 3 - klasa wie o wszystkich!
print(lion.total_species)     # 3 - można też przez instancję
print(elephant.total_species) # 3 - ta sama wartość dla wszystkich

Kiedy używać którego?

Typ atrybutuKiedy używaćPrzykład
InstancjiDane unikalne dla obiektuself.name, self.age
KlasowyDane współdzieloneliczniki, stałe, konfiguracja
class Species:
    # Atrybuty klasowe
    kingdom = "Animalia"  # Stała dla wszystkich
    species_count = 0  # Licznik

    def __init__(self, name, population):
        # Atrybuty instancji
        self.name = name  # Unikalny dla każdego
        self.population = population
        Species.species_count += 1

lion = Species("Lew", 500)
elephant = Species("Słoń", 300)

print(Species.kingdom)  # "Animalia" - współdzielone
print(lion.name)  # "Lew" - unikalny
print(elephant.name)  # "Słoń" - inny

4. Metody instancji

Metody instancji działają na konkretnym obiekcie, mają dostęp do self.

class Species:
    def __init__(self, name, population):
        self.name = name
        self.population = population
        self.observations = []

    def add_observation(self, location, count):
        """Dodaj obserwację - metoda instancji"""
        self.observations.append({
            "location": location,
            "count": count
        })
        print(f"Obserwacja {self.name}: {count} w {location}")

    def get_total_observed(self):
        """Oblicz łączną liczbę obserwacji"""
        return sum(obs["count"] for obs in self.observations)

    def is_endangered(self):
        """Sprawdź czy zagrożony (< 100 osobników)"""
        return self.population < 100

# Użycie
lion = Species("Lew", 500)
lion.add_observation("Serengeti", 25)
lion.add_observation("Masai Mara", 18)

print(f"Łącznie zaobserwowano: {lion.get_total_observed()}")  # 43
print(f"Zagrożony? {lion.is_endangered()}")  # False

5. Metody klasowe - @classmethod

Metody klasowe działają na całej klasie, nie na konkretnym obiekcie. Mają dostęp do cls.

class Species:
    all_species = []  # Rejestr wszystkich gatunków

    def __init__(self, name):
        self.name = name
        Species.all_species.append(self)

    @classmethod
    def get_species_count(cls):
        """Zwróć liczbę wszystkich gatunków"""
        return len(cls.all_species)

    @classmethod
    def find_by_name(cls, name):
        """Znajdź gatunek po nazwie w rejestrze klasy"""
        for species in cls.all_species:
            if species.name == name:
                return species
        return None

    @classmethod
    def clear_registry(cls):
        """Wyczyść rejestr"""
        cls.all_species.clear()

# Użycie
lion = Species("Lew")
elephant = Species("Słoń")
python = Species("Pyton")

print(Species.get_species_count())  # 3 - metoda klasowa

found = Species.find_by_name("Słoń")
print(found.name)  # "Słoń"

Różnica self vs cls:

  • self = konkretny obiekt (instancja)
  • cls = klasa (typ)

6. Metody statyczne - @staticmethod

Metody statyczne NIE mają dostępu ani do self, ani do cls. To zwykłe funkcje w przestrzeni nazw klasy.

class Species:
    @staticmethod
    def is_valid_name(name):
        """Sprawdź czy nazwa gatunku jest poprawna"""
        # Brak self, brak cls - tylko argumenty!
        return (
            len(name) > 0 and
            name[0].isupper() and
            " " not in name
        )

    @staticmethod
    def calculate_biodiversity_index(species_count, area_km2):
        """Oblicz indeks bioróżnorodności"""
        return species_count / area_km2 if area_km2 > 0 else 0

# Użycie - nie potrzeba obiektu!
print(Species.is_valid_name("Lew"))  # True
print(Species.is_valid_name("lew"))  # False - mała litera
print(Species.is_valid_name(""))     # False - puste

index = Species.calculate_biodiversity_index(150, 1000)
print(f"Indeks bioróżnorodności: {index}")  # 0.15

Kiedy używać metod statycznych?

  • Funkcje pomocnicze (utility) związane tematycznie z klasą
  • Walidatory, konwertery, kalkulatory
  • Nie potrzebują dostępu do atrybutów obiektu ani klasy

Porównanie typów metod

Zestawmy trzy rodzaje metod w jednej klasie i sprawdźmy, które z nich da się wywołać na samej klasie, a które wymagają obiektu.

class Species:
    species_count = 0  # Atrybut klasowy

    def __init__(self, name):
        self.name = name
        Species.species_count += 1

    # 1. Metoda instancji - ma self
    def describe(self):
        """Dostęp do self.name"""
        return f"Gatunek: {self.name}"

    # 2. Metoda klasowa - ma cls
    @classmethod
    def get_count(cls):
        """Dostęp do cls.species_count"""
        return cls.species_count

    # 3. Metoda statyczna - bez self/cls
    @staticmethod
    def is_valid_name(name):
        """Tylko argumenty, brak dostępu do klasy/obiektu"""
        return len(name) > 0

lion = Species("Lew")

# 1. Metoda instancji - potrzebuje obiektu
print(lion.describe())  # OK - działa na obiekcie
# print(Species.describe())  # BŁĄD - brak obiektu!

# 2. Metoda klasowa - działa na klasie
print(Species.get_count())  # OK - działa na klasie
print(lion.get_count())  # OK - też działa (Python przekaże klasę)

# 3. Metoda statyczna - działa zawsze
print(Species.is_valid_name("Lew"))  # OK
print(lion.is_valid_name("Lew"))  # OK - też działa

Przykład z safari - System katalogowania gatunków

Ten katalog łączy wszystko z tej lekcji: atrybuty klasowe prowadzą wspólny rejestr gatunków, metody instancji obsługują jeden gatunek, metody klasowe cały katalog, a metody statyczne to narzędzia pomocnicze, np. walidacja nazwy naukowej.

class SpeciesCatalog:
    """
    Kompletny system katalogowania gatunków Safari

    Demonstruje wszystkie koncepcje: atrybuty, metody, konstruktor
    """

    # Atrybut klasowy - rejestr wszystkich gatunków
    all_species = {}  # {nazwa: obiekt Species}
    next_id = 1

    def __init__(self, scientific_name, common_name, habitat, diet, dangerous=False):
        """
        Konstruktor - tworzy nowy gatunek w katalogu

        Args:
            scientific_name: Nazwa naukowa (np. "Panthera leo")
            common_name: Nazwa zwyczajowa (np. "Lew")
            habitat: Środowisko ("sawanna", "dżungla", "góry", etc.)
            diet: Dieta ("mięsożerca", "roślinożerca", "wszystkożerca")
            dangerous: Czy niebezpieczny dla ludzi
        """
        # Atrybuty instancji - unikalne dla każdego gatunku
        self.id = SpeciesCatalog.next_id
        SpeciesCatalog.next_id += 1

        self.scientific_name = scientific_name
        self.common_name = common_name
        self.habitat = habitat
        self.diet = diet
        self.dangerous = dangerous

        self.observations = []  # Lista obserwacji
        self.population_estimate = 0
        self.conservation_status = "Unknown"  # Nieznany domyślnie

        # Dodaj do rejestru klasowego
        SpeciesCatalog.all_species[scientific_name] = self

    # === METODY INSTANCJI (działają na konkretnym gatunku) ===

    def add_observation(self, date, location, count, notes=""):
        """Dodaj obserwację gatunku w terenie"""
        observation = {
            "date": date,
            "location": location,
            "count": count,
            "notes": notes
        }
        self.observations.append(observation)
        self.population_estimate += count
        return f"Dodano obserwację: {count}x {self.common_name}"

    def get_total_observed(self):
        """Zwróć łączną liczbę zaobserwowanych osobników"""
        return sum(obs["count"] for obs in self.observations)

    def update_conservation_status(self):
        """Aktualizuj status ochrony na podstawie populacji"""
        total = self.get_total_observed()

        if total == 0:
            self.conservation_status = "Not observed"
        elif total < 50:
            self.conservation_status = "Critically Endangered"
        elif total < 250:
            self.conservation_status = "Endangered"
        elif total < 1000:
            self.conservation_status = "Vulnerable"
        else:
            self.conservation_status = "Least Concern"

        return self.conservation_status

    def get_risk_level(self):
        """Oblicz poziom ryzyka dla zespołu (0-10)"""
        if not self.dangerous:
            return 0

        # Bazowy poziom ryzyka dla niebezpiecznych
        risk = 5

        # Zwiększ ryzyko, jeśli gatunek jest mięsożerny
        if self.diet == "mięsożerca":
            risk += 3

        # Zmniejsz jeśli populacja mała (rzadko spotykane)
        if self.get_total_observed() < 50:
            risk -= 2

        return max(0, min(10, risk))  # Ogranicz do 0-10

    def generate_report(self):
        """Wygeneruj raport o gatunku"""
        self.update_conservation_status()

        report = f"""
┌─────────────────────────────────────────────────────────┐
│ ID: {self.id:03d} - {self.common_name.upper()}
├─────────────────────────────────────────────────────────┤
│ Nazwa naukowa: {self.scientific_name}
│ Siedlisko: {self.habitat}
│ Dieta: {self.diet}
│ Niebezpieczny: {'TAK' if self.dangerous else 'Nie'}
│ Poziom ryzyka: {self.get_risk_level()}/10
├─────────────────────────────────────────────────────────┤
│ OBSERWACJE:
│ - Łączna liczba: {self.get_total_observed()} osobników
│ - Liczba obserwacji: {len(self.observations)}
│ - Status ochrony: {self.conservation_status}
└─────────────────────────────────────────────────────────┘
        """.strip()
        return report

    # === METODY KLASOWE (działają na całym katalogu) ===

    @classmethod
    def get_total_species(cls):
        """Zwróć liczbę wszystkich zarejestrowanych gatunków"""
        return len(cls.all_species)

    @classmethod
    def find_by_name(cls, scientific_name):
        """Znajdź gatunek po nazwie naukowej"""
        return cls.all_species.get(scientific_name)

    @classmethod
    def get_by_habitat(cls, habitat):
        """Zwróć wszystkie gatunki z danego siedliska"""
        return [
            species for species in cls.all_species.values()
            if species.habitat == habitat
        ]

    @classmethod
    def get_dangerous_species(cls):
        """Zwróć wszystkie niebezpieczne gatunki"""
        return [
            species for species in cls.all_species.values()
            if species.dangerous
        ]

    @classmethod
    def get_most_observed(cls, n=5):
        """Zwróć n najczęściej obserwowanych gatunków"""
        sorted_species = sorted(
            cls.all_species.values(),
            key=lambda s: s.get_total_observed(),
            reverse=True
        )
        return sorted_species[:n]

    @classmethod
    def clear_catalog(cls):
        """Wyczyść cały katalog (ostrożnie!)"""
        cls.all_species.clear()
        cls.next_id = 1
        return "Katalog wyczyszczony"

    # === METODY STATYCZNE (narzędzia pomocnicze) ===

    @staticmethod
    def validate_scientific_name(name):
        """Waliduj nazwę naukową (format: "Genus species")"""
        parts = name.split()
        if len(parts) != 2:
            return False

        genus, species = parts
        # Genus z wielką, species z małą
        return genus[0].isupper() and species[0].islower()

    @staticmethod
    def calculate_biodiversity_index(species_list):
        """Oblicz indeks różnorodności Simpsona"""
        if not species_list:
            return 0.0

        total = sum(s.get_total_observed() for s in species_list)
        if total == 0:
            return 0.0

        # Indeks Simpsona: 1 - Σ(ni/N)²
        sum_squares = sum(
            (s.get_total_observed() / total) ** 2
            for s in species_list
        )
        return 1 - sum_squares

    @staticmethod
    def format_scientific_name(genus, species):
        """Formatuj nazwę naukową: rodzaj wielką literą, gatunek małą"""
        return f"{genus.capitalize()} {species.lower()}"

# === DEMONSTRACJA UŻYCIA ===

print("=== TWORZENIE KATALOGU GATUNKÓW ===\n")

# Tworzenie gatunków (konstruktor)
lion = SpeciesCatalog(
    scientific_name="Panthera leo",
    common_name="Lew",
    habitat="sawanna",
    diet="mięsożerca",
    dangerous=True
)

elephant = SpeciesCatalog(
    scientific_name="Loxodonta africana",
    common_name="Słoń afrykański",
    habitat="sawanna",
    diet="roślinożerca",
    dangerous=False
)

python = SpeciesCatalog(
    scientific_name="Python regius",
    common_name="Pyton królewski",
    habitat="dżungla",
    diet="mięsożerca",
    dangerous=False
)

crocodile = SpeciesCatalog(
    scientific_name="Crocodylus niloticus",
    common_name="Krokodyl nilowy",
    habitat="rzeka",
    diet="mięsożerca",
    dangerous=True
)

# Dodawanie obserwacji (metody instancji)
lion.add_observation("2024-01-15", "Serengeti", 12, "Stado polujące")
lion.add_observation("2024-01-20", "Masai Mara", 8, "Rodzina z młodymi")
elephant.add_observation("2024-01-16", "Amboseli", 45, "Duże stado")
python.add_observation("2024-01-18", "Dżungla Konga", 3)
crocodile.add_observation("2024-01-19", "Nil", 25, "Na brzegu rzeki")

# Raporty dla poszczególnych gatunków
print(lion.generate_report())
print()
print(elephant.generate_report())

# Metody klasowe - statystyki całego katalogu
print(f"\n=== STATYSTYKI KATALOGU ===")
print(f"Łączna liczba gatunków: {SpeciesCatalog.get_total_species()}")

print(f"\nGatunki sawanny:")
for species in SpeciesCatalog.get_by_habitat("sawanna"):
    print(f"  - {species.common_name} ({species.get_total_observed()} osobników)")

print(f"\nNiebezpieczne gatunki:")
for species in SpeciesCatalog.get_dangerous_species():
    risk = species.get_risk_level()
    print(f"   {species.common_name} - Ryzyko: {risk}/10")

print(f"\nTop 3 najczęściej obserwowane:")
for i, species in enumerate(SpeciesCatalog.get_most_observed(3), 1):
    print(f"  {i}. {species.common_name}: {species.get_total_observed()} osobników")

# Metody statyczne - narzędzia
print(f"\n=== WALIDACJA ===")
names_to_test = ["Panthera leo", "panthera leo", "Lion", "Canis lupus familiaris"]
for name in names_to_test:
    valid = "[OK]" if SpeciesCatalog.validate_scientific_name(name) else "[BŁĄD]"
    print(f"{valid} {name}")

# Indeks bioróżnorodności
all_species_list = list(SpeciesCatalog.all_species.values())
biodiversity = SpeciesCatalog.calculate_biodiversity_index(all_species_list)
print(f"\nIndeks bioróżnorodności: {biodiversity:.3f}")

Podsumowanie

W tej lekcji nauczyłeś/aś się:

  • Jak definiować klasy z class
  • Tworzenia konstruktora __init__
  • Używania self do dostępu do atrybutów
  • Różnicy między atrybutami instancji a klasowymi
  • Tworzenia metod instancji, klasowych i statycznych
  • Kiedy używać każdego typu metody
  • Budowania kompletnego systemu katalogowania

Checkpoint

Przed przejściem dalej:

  • Potrafisz zdefiniować klasę z konstruktorem
  • Rozumiesz różnicę między self a cls
  • Znasz różnicę między atrybutami instancji a klasowymi
  • Wiesz kiedy użyć @classmethod a kiedy @staticmethod
  • Potrafisz stworzyć obiekt i wywołać jego metody

Kluczowa koncepcja: self to "ja" - obiekt odnosi się do samego siebie, aby dostać się do swoich danych i zachowań!

W następnej lekcji Darwin nauczy Cię dziedziczenia - jak tworzyć hierarchie klas jak w drzewie ewolucyjnym!

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. Atrybut klasy jest wspólny dla:

  2. 2. Jak zgodnie z konwencją nazywa się pierwszy parametr metody instancji?

Zadania praktyczne w grze

  • Klikanie w kolejności

    Kliknij elementy w prawidłowej kolejności:

  • Edytor kodu

    Dodaj do klasy Animal metodę speak(), która wypisuje (print) dźwięk zwierzęcia, np. 'Simba: Roar!'. Utwórz zwierzę i wywołaj speak()

  • Edytor kodu

    W klasie Animal dodaj atrybut klasy kingdom = "Animalia" i atrybut instancji name (ustawiany w __init__)

  • Układanie w poziomie

    Ułóż elementy w prawidłowej kolejności:

  1. PytanieAtrybuty klasy vs instancji
  2. PytanieMetody instancji
  3. Kliknij w kolejnościBudowanie nagłówka klasy
  4. Zadanie z kodemMetody klasy
  5. Zadanie z kodemAtrybuty klasy
  6. Ułóż w kolejnościDefinicja metody

Przydatne artykuły