Kurs Python · Moduł 3: Programowanie obiektowe
Tworzenie własnych gatunków
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 statyczna1. 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, nieRunsLion
# 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
pass2. 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 = name3. 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 wszystkichKiedy używać którego?
| Typ atrybutu | Kiedy używać | Przykład |
|---|---|---|
| Instancji | Dane unikalne dla obiektu | self.name, self.age |
| Klasowy | Dane współdzielone | liczniki, 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ń" - inny4. 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()}") # False5. 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.15Kiedy 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łaPrzykł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
selfdo 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
selfacls - Znasz różnicę między atrybutami instancji a klasowymi
- Wiesz kiedy użyć
@classmethoda 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. Atrybut klasy jest wspólny dla:
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: