Kurs Python · Moduł 3: Programowanie obiektowe
Dekoratory - adaptacja do środowiska
W tej lekcji12
Witaj po raz ostatni w Module 3! Tu Darwin, czas na najbardziej zaawansowaną lekcję.
W naturze zwierzęta adaptują się do środowiska - kameleon zyskuje zdolność zmiany koloru, nietoperze echolokację, ptaki migracyjne nawigację magnetyczną. W Pythonie dekoratory pozwalają na podobną adaptację - modyfikują zachowanie funkcji i klas bez zmiany ich kodu!
# Zwykła funkcja
def observe_species(name):
print(f"Obserwacja: {name}")
# Funkcja z dekoratorem - automatyczne logowanie!
@log_observation
def observe_species(name):
print(f"Obserwacja: {name}")Ciało funkcji się nie zmieniło. Jedna linia @log_observation nad definicją sprawia, że każde wywołanie jest teraz logowane automatycznie. Jak napisać taki dekorator, zobaczysz za chwilę.
Czym są dekoratory?
Dekorator to funkcja, która przyjmuje inną funkcję (lub klasę) i zwraca zmodyfikowaną wersję.
Analogia Safari: To jak wyposażenie badacza - lornetka nie zmienia badacza, ale rozszerza jego możliwości obserwacji!
def my_decorator(func):
"""Dekorator - przyjmuje funkcję, zwraca zmodyfikowaną"""
def wrapper():
print("Coś przed funkcją")
func() # Wywołaj oryginalną funkcję
print("Coś po funkcji")
return wrapper
@my_decorator
def say_hello():
print("Hello!")
say_hello()Wywołanie say_hello() wypisze:
Coś przed funkcją
Hello!
Coś po funkcjiŚrodkową linię wypisała oryginalna funkcja, a dwie pozostałe wrapper, który dekorator podstawił pod nazwę say_hello.
Składnia @decorator to skrót dla:
def say_hello():
print("Hello!")
say_hello = my_decorator(say_hello) # Ręczne dekorowanieJak działają dekoratory?
Dekorator to funkcja wyższego rzędu (higher-order function) - funkcja operująca na funkcjach!
def simple_decorator(func):
"""
Dekorator - wrapper pattern
1. Przyjmij funkcję
2. Zdefiniuj wrapper
3. Zwróć wrapper
"""
def wrapper():
print(f"[PRZED] Wywołanie {func.__name__}")
result = func()
print(f"[PO] Zakończono {func.__name__}")
return result
return wrapper
@simple_decorator
def greet():
print("Witaj!")
return "Done"
# greet jest teraz wrapper, nie oryginalną funkcją!
greet()Program wypisze:
[PRZED] Wywołanie greet
Witaj!
[PO] Zakończono greetWrapper zwraca też wynik oryginalnej funkcji (result), więc wartość "Done" nie ginie po drodze.
Dekoratory z argumentami funkcji
Aby dekorator działał z funkcjami przyjmującymi argumenty, użyj *args i **kwargs:
def log_decorator(func):
def wrapper(*args, **kwargs):
"""Wrapper przyjmuje dowolne argumenty"""
print(f"Wywołanie {func.__name__} z args={args}, kwargs={kwargs}")
result = func(*args, **kwargs)
print(f"Wynik: {result}")
return result
return wrapper
@log_decorator
def add(a, b):
return a + b
@log_decorator
def greet(name, greeting="Hello"):
return f"{greeting}, {name}!"
add(5, 3)
greet("Darwin", greeting="Cześć")Oba wywołania wypiszą:
Wywołanie add z args=(5, 3), kwargs={}
Wynik: 8
Wywołanie greet z args=('Darwin',), kwargs={'greeting': 'Cześć'}
Wynik: Cześć, Darwin!Ten sam wrapper obsłużył funkcję z dwoma argumentami pozycyjnymi i funkcję z argumentem nazwanym: *args zbiera argumenty pozycyjne, a **kwargs nazwane.
functools.wraps - zachowanie metadanych
Problem: dekorator zmienia __name__ i __doc__ funkcji!
def my_decorator(func):
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper
@my_decorator
def important_function():
"""Ta funkcja jest ważna"""
pass
print(important_function.__name__) # "wrapper" - źle!
print(important_function.__doc__) # None - brak dokumentacji!Rozwiązanie: Użyj @functools.wraps!
from functools import wraps
def my_decorator(func):
@wraps(func) # Zachowaj metadane oryginalnej funkcji
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper
@my_decorator
def important_function():
"""Ta funkcja jest ważna"""
pass
print(important_function.__name__) # "important_function" - dobrze!
print(important_function.__doc__) # "Ta funkcja jest ważna" - zachowane!WAŻNE: Zawsze używaj @wraps(func) w swoich dekoratorach!
Dekoratory z parametrami
Aby dekorator przyjmował parametry, potrzebujesz trzech poziomów funkcji:
def repeat(times):
"""Dekorator z parametrem - powtórz funkcję N razy"""
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
for i in range(times):
result = func(*args, **kwargs)
return result
return wrapper
return decorator
@repeat(times=3) # Parametr dekoratora!
def say_hello():
print("Hello!")
say_hello()Jedno wywołanie say_hello() wypisze teraz Hello! trzy razy, bo wrapper uruchamia oryginalną funkcję w pętli for tyle razy, ile podasz w times.
Struktura:
repeat(times)- zwraca dekoratordecorator(func)- prawdziwy dekoratorwrapper(*args, **kwargs)- wrapper funkcji
Wbudowane dekoratory
Już znasz niektóre wbudowane dekoratory Pythona!
@property, @classmethod, @staticmethod
Wszystkie trzy znasz z poprzednich lekcji. To zwykłe dekoratory wbudowane w Pythona: każdy zmienia sposób, w jaki wywołuje się metodę pod nim.
class Species:
def __init__(self, name, population):
self._name = name
self._population = population
@property # Getter
def name(self):
return self._name
@property
def population(self):
return self._population
@population.setter # Setter
def population(self, value):
if value < 0:
raise ValueError("Populacja nie może być ujemna")
self._population = value
@classmethod # Metoda klasowa
def from_dict(cls, data):
return cls(data['name'], data['population'])
@staticmethod # Metoda statyczna
def is_valid_name(name):
return len(name) > 0Praktyczne przykłady dekoratorów
1. Dekorator pomiaru czasu wykonania
Ten dekorator zapisuje czas przed wywołaniem i po nim, a różnicę wypisuje w sekundach. Mierzonej funkcji nie trzeba w tym celu zmieniać:
import time
from functools import wraps
def timer(func):
"""Zmierz czas wykonania funkcji"""
@wraps(func)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print(f"⏱ {func.__name__} zajęło {end - start:.4f}s")
return result
return wrapper
@timer
def analyze_dna_sequence(sequence):
"""Symuluj analizę DNA - czasochłonna operacja"""
time.sleep(2) # Symulacja
return f"Przeanalizowano {len(sequence)} nukleotydów"
result = analyze_dna_sequence("ATCGATCG") # ⏱ analyze_dna_sequence zajęło 2.0015s2. Dekorator logujący - automatyczne logowanie
Dekorator logujący wypisuje datę i godzinę, nazwę funkcji i argumenty każdego wywołania, a potem wynik albo błąd. Wyjątku nie połyka, tylko przekazuje go dalej przez raise:
from functools import wraps
from datetime import datetime
def log_calls(func):
"""Loguj każde wywołanie funkcji"""
@wraps(func)
def wrapper(*args, **kwargs):
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
print(f"[{timestamp}] Wywołanie: {func.__name__}")
print(f" Argumenty: args={args}, kwargs={kwargs}")
try:
result = func(*args, **kwargs)
print(f" Sukces: {result}")
return result
except Exception as e:
print(f" Błąd: {e}")
raise
return wrapper
@log_calls
def observe_species(name, location, count):
"""Zapisz obserwację gatunku"""
if count < 0:
raise ValueError("Liczba nie może być ujemna")
return f"Zapisano: {count}x {name} w {location}"
observe_species("Lew", "Serengeti", 12)W konsoli pojawi się (data i godzina będą aktualne):
[2024-01-15 14:30:45] Wywołanie: observe_species
Argumenty: args=('Lew', 'Serengeti', 12), kwargs={}
Sukces: Zapisano: 12x Lew w SerengetiGdyby funkcja zgłosiła błąd, na przykład dla ujemnej liczby osobników, zamiast linii Sukces zobaczysz Błąd, a wyjątek trafi dalej do kodu, który ją wywołał.
3. Dekorator cache - memoizacja
Dekorator cache zapamiętuje wynik dla każdego zestawu argumentów. Przy kolejnym wywołaniu z tymi samymi argumentami zwraca gotową wartość zamiast liczyć od nowa:
from functools import wraps
def cache(func):
"""Zapisz wyniki - nie przeliczaj tego samego dwa razy"""
cached_results = {}
@wraps(func)
def wrapper(*args):
if args in cached_results:
print(f"Cache hit dla {args}")
return cached_results[args]
print(f"Obliczanie dla {args}")
result = func(*args)
cached_results[args] = result
return result
return wrapper
@cache
def fibonacci(n):
"""Oblicz n-tą liczbę Fibonacciego"""
if n < 2:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
print(fibonacci(5))Program wypisze:
Obliczanie dla (5,)
Obliczanie dla (4,)
Obliczanie dla (3,)
Obliczanie dla (2,)
Obliczanie dla (1,)
Obliczanie dla (0,)
Cache hit dla (1,)
Cache hit dla (2,)
Cache hit dla (3,)
5Każda wartość od 0 do 5 jest liczona tylko raz, a drugie wywołania dla 1, 2 i 3 biorą wynik z cache. Bez dekoratora ta sama funkcja wywołałaby się 15 razy, a przy większym n liczba wywołań rośnie lawinowo.
Uwaga: Python ma wbudowany @functools.lru_cache!
from functools import lru_cache
@lru_cache(maxsize=128) # Pamięta ostatnie 128 wyników
def fibonacci(n):
if n < 2:
return n
return fibonacci(n - 1) + fibonacci(n - 2)4. Dekorator kontroli dostępu - autoryzacja
Ten dekorator przyjmuje parametr, czyli oczekiwany kod, i sprawdza pierwszy argument wywołania. Funkcja dostaje pozostałe argumenty dopiero wtedy, gdy kod się zgadza:
from functools import wraps
def require_authorization(authorization_code):
"""Dekorator z parametrem - wymaga autoryzacji"""
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
# Sprawdź czy pierwszy argument to poprawny kod
if len(args) == 0 or args[0] != authorization_code:
raise PermissionError(f"Nieautoryzowany dostęp do {func.__name__}")
# Usuń kod autoryzacji z argumentów
return func(*args[1:], **kwargs)
return wrapper
return decorator
@require_authorization("SAFARI_2024")
def access_classified_data(species_name):
"""Dostęp do niejawnych danych - wymaga autoryzacji"""
return f"Niejawne dane (gatunek: {species_name}): [KLASYFIKOWANE]"
# Poprawna autoryzacja
print(access_classified_data("SAFARI_2024", "Nosorożec czarny"))
# "Niejawne dane (gatunek: Nosorożec czarny): [KLASYFIKOWANE]"
# Brak autoryzacji - błąd!
try:
print(access_classified_data("WRONG_CODE", "Nosorożec czarny"))
except PermissionError as e:
print(f"Błąd: {e}")5. Dekorator ponawiania - kolejne próby po błędzie
Połączenie z odległą stacją badawczą czasem się zrywa. Dekorator ponawiania łapie wyjątek, czeka chwilę i próbuje jeszcze raz, aż wyczerpie limit prób:
from functools import wraps
import time
def retry(max_attempts=3, delay=1):
"""Ponów operację przy błędzie"""
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
for attempt in range(1, max_attempts + 1):
try:
return func(*args, **kwargs)
except Exception as e:
print(f"Próba {attempt}/{max_attempts} nie powiodła się: {e}")
if attempt < max_attempts:
print(f"Ponowienie za {delay}s...")
time.sleep(delay)
else:
print("Wszystkie próby wyczerpane")
raise
return wrapper
return decorator
@retry(max_attempts=3, delay=0.5)
def unstable_connection(success_rate=0.3):
"""Symuluj niestabilne połączenie"""
import random
if random.random() > success_rate:
raise ConnectionError("Połączenie przerwane")
return "Sukces!"
# Automatycznie ponawia przy błędzie
result = unstable_connection(success_rate=0.8)Łączenie wielu dekoratorów
Dekoratory można nakładać jeden na drugi - stosować wiele naraz!
@decorator1
@decorator2
@decorator3
def my_function():
passTaki zapis działa tak samo jak ręczne owinięcie my_function = decorator1(decorator2(decorator3(my_function))). Najbliżej funkcji stoi decorator3, więc to on owija ją jako pierwszy.
Kolejność ma znaczenie - wykonywane od dołu do góry!
from functools import wraps
def bold(func):
@wraps(func)
def wrapper(*args, **kwargs):
return f"**{func(*args, **kwargs)}**"
return wrapper
def italic(func):
@wraps(func)
def wrapper(*args, **kwargs):
return f"_{func(*args, **kwargs)}_"
return wrapper
@bold
@italic
def greet(name):
return f"Hello, {name}"
print(greet("Darwin")) # "**_Hello, Darwin_**"Najpierw italic otoczył wynik podkreśleniami, potem bold dołożył gwiazdki. Kolejność wykonania to greet → italic → bold.
Dekoratory klas
Dekoratory mogą również modyfikować całe klasy!
def singleton(cls):
"""Dekorator klasy - wzorzec Singleton"""
instances = {}
@wraps(cls)
def get_instance(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return get_instance
@singleton
class DatabaseConnection:
def __init__(self, host):
self.host = host
print(f"Łączenie z {host}...")
# Pierwsza instancja
db1 = DatabaseConnection("localhost") # Drukuje: "Łączenie z localhost..."
# "Druga" instancja - w rzeczywistości ta sama!
db2 = DatabaseConnection("localhost") # Nic nie drukuje
print(db1 is db2) # True - ten sam obiekt!Przykład z safari - kompletny system z dekoratorami
Na koniec klasa gatunku, w której pracuje pięć dekoratorów naraz: logowanie i pomiar czasu obserwacji, walidacja populacji, autoryzacja usuwania oraz cache obliczeń.
from functools import wraps
from datetime import datetime
import time
from typing import Callable, Any
# === DEKORATORY ===
def log_observation(func: Callable) -> Callable:
"""Loguj wszystkie obserwacje gatunków"""
@wraps(func)
def wrapper(*args, **kwargs):
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
print(f"[{timestamp}] Obserwacja: {func.__name__}")
result = func(*args, **kwargs)
print(f" Zapisano: {result}")
return result
return wrapper
def measure_time(func: Callable) -> Callable:
"""Zmierz czas wykonania operacji"""
@wraps(func)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
elapsed = time.time() - start
print(f" ⏱ Czas: {elapsed:.3f}s")
return result
return wrapper
def validate_population(func: Callable) -> Callable:
"""Waliduj dane populacji przed zapisem"""
@wraps(func)
def wrapper(self, population: int, *args, **kwargs):
if not isinstance(population, int):
raise TypeError("Populacja musi być liczbą całkowitą")
if population < 0:
raise ValueError("Populacja nie może być ujemna")
return func(self, population, *args, **kwargs)
return wrapper
def require_auth(authorization_level: str):
"""Wymagaj poziomu autoryzacji"""
def decorator(func: Callable) -> Callable:
@wraps(func)
def wrapper(self, auth_code: str, *args, **kwargs):
if auth_code != f"SAFARI_{authorization_level}":
raise PermissionError(
f"Wymagany poziom: {authorization_level}"
)
return func(self, *args, **kwargs)
return wrapper
return decorator
def cache_result(func: Callable) -> Callable:
"""Cache wyników obliczeń"""
cache = {}
@wraps(func)
def wrapper(*args):
if args in cache:
print(f" Cache hit")
return cache[args]
result = func(*args)
cache[args] = result
return result
return wrapper
# === KLASA Z DEKORATORAMI ===
class Species:
"""
Klasa gatunku z dekoratorami Safari
Demonstracja: logowanie, timing, walidacja, autoryzacja, cache
"""
_registry = {}
def __init__(self, scientific_name: str, common_name: str, population: int):
self.scientific_name = scientific_name
self.common_name = common_name
self._population = population
self.observations = []
Species._registry[scientific_name] = self
@property
def population(self) -> int:
"""Getter - zwykła property"""
return self._population
@population.setter
@validate_population # Dekorator walidacji!
def population(self, value: int) -> None:
"""Setter z automatyczną walidacją"""
self._population = value
@log_observation # Automatyczne logowanie
@measure_time # Pomiar czasu
def add_observation(self, location: str, count: int, date: str) -> str:
"""
Dodaj obserwację - automatycznie logowane i mierzone
Dekoratory: @log_observation, @measure_time
"""
time.sleep(0.1) # Symuluj operację
obs = {
"location": location,
"count": count,
"date": date
}
self.observations.append(obs)
return f"{count}x {self.common_name} w {location}"
@cache_result # Cache wyników
def calculate_biodiversity_score(self) -> float:
"""
Oblicz wynik bioróżnorodności - z cache
Czasochłonna operacja - cache oszczędza czas!
"""
print(f" Obliczanie score dla {self.common_name}...")
time.sleep(0.5) # Symuluj złożone obliczenia
total_obs = sum(obs["count"] for obs in self.observations)
unique_locations = len(set(obs["location"] for obs in self.observations))
return (total_obs * unique_locations) / (self.population + 1)
@require_auth("ADMIN") # Wymaga autoryzacji ADMIN
def delete_all_observations(self) -> str:
"""
Usuń wszystkie obserwacje - wymaga autoryzacji ADMIN
Dekorator: @require_auth("ADMIN")
"""
count = len(self.observations)
self.observations.clear()
return f"Usunięte obserwacje: {count}"
@classmethod
def get_total_population(cls) -> int:
"""Łączna populacja wszystkich gatunków"""
return sum(s.population for s in cls._registry.values())
@staticmethod
@cache_result # Nawet metody statyczne można cache'ować!
def calculate_extinction_risk(population: int, habitat_loss: float) -> str:
"""
Oblicz ryzyko wyginięcia - z cache
Args:
population: Liczba osobników
habitat_loss: Utrata siedliska (0.0-1.0)
"""
print(f" Obliczanie ryzyka...")
time.sleep(0.3)
risk_score = (1000 - population) * habitat_loss
if risk_score > 800:
return "Krytyczne"
elif risk_score > 500:
return "Wysokie"
elif risk_score > 200:
return "Średnie"
else:
return "Niskie"
def __repr__(self) -> str:
return f"Species('{self.common_name}', pop={self.population})"
# === DEMONSTRACJA ===
print("=== SYSTEM SAFARI Z DEKORATORAMI ===\n")
# Tworzenie gatunków
lion = Species("Panthera leo", "Lew", 120)
rhino = Species("Diceros bicornis", "Nosorożec", 45)
# 1. Obserwacje - automatyczne logowanie i timing
print("\n1. OBSERWACJE (z @log_observation i @measure_time):")
lion.add_observation("Serengeti", 12, "2024-01-15")
lion.add_observation("Masai Mara", 8, "2024-01-16")
# 2. Walidacja populacji
print("\n2. WALIDACJA (@validate_population):")
try:
lion.population = -10 # Błąd - ujemna!
except ValueError as e:
print(f"Błąd walidacji: {e}")
try:
lion.population = "sto" # Błąd - nie int!
except TypeError as e:
print(f"Błąd typu: {e}")
lion.population = 125 # OK
print(f"Populacja zaktualizowana: {lion.population}")
# 3. Cache - biodiversity score
print("\n3. CACHE (@cache_result):")
print("Pierwsze wywołanie:")
score1 = lion.calculate_biodiversity_score()
print(f"Score: {score1:.2f}")
print("\nDrugie wywołanie (z cache):")
score2 = lion.calculate_biodiversity_score()
print(f"Score: {score2:.2f}")
# 4. Autoryzacja
print("\n4. AUTORYZACJA (@require_auth):")
try:
lion.delete_all_observations("WRONG_CODE")
except PermissionError as e:
print(f"Brak dostępu: {e}")
result = lion.delete_all_observations("SAFARI_ADMIN")
print(f"{result}")
# 5. Cache w metodzie statycznej
print("\n5. CACHE W STATIC METHOD:")
print("Pierwsze wywołanie:")
risk1 = Species.calculate_extinction_risk(50, 0.8)
print(f"Ryzyko: {risk1}")
print("\nDrugie wywołanie (z cache):")
risk2 = Species.calculate_extinction_risk(50, 0.8)
print(f"Ryzyko: {risk2}")
print("\nInne parametry (nowe obliczenie):")
risk3 = Species.calculate_extinction_risk(500, 0.3)
print(f"Ryzyko: {risk3}")Podsumowanie
W tej lekcji nauczyłeś/aś się:
- Czym są dekoratory i jak działają
- Składni
@decorator - Tworzenia dekoratorów z
*argsi**kwargs - Używania
@functools.wrapsdo zachowania metadanych - Dekoratorów z parametrami (trzy poziomy funkcji)
- Wbudowanych dekoratorów (
@property,@classmethod,@staticmethod) - Praktycznych przykładów: timing, logging, cache, autoryzacja, retry
- Nakładania wielu dekoratorów
- Dekoratorów klas
- Kompletnego systemu Safari z dekoratorami
Checkpoint
Przed przejściem dalej:
- Rozumiesz jak dekoratory modyfikują funkcje
- Potrafisz stworzyć prosty dekorator
- Wiesz kiedy używać
@wraps - Rozumiesz dekoratory z parametrami
- Potrafisz nałożyć wiele dekoratorów
Analogia Safari: Dekoratory to adaptacje ewolucyjne - kameleon z chromatoforami, nietoperz z echolokacją - rozszerzają możliwości bez zmiany podstawowej natury!
Gratulacje! Ukończyłeś/aś Moduł 3 - Programowanie Obiektowe! Opanowałeś/aś klasy, dziedziczenie, enkapsulację, metody magiczne, type hints i dekoratory. Jesteś gotowy/a na kolejne wyzwania w Safari Python!
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. Dekorator w Pythonie to:
2. Jak zgodnie z konwencją nazywa się pierwszy parametr metody oznaczonej @classmethod?
To 2 z 6 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:
- Klikanie w kolejności
Kliknij elementy w prawidłowej kolejności:
- Edytor kodu
Stwórz @classmethod from_dict(cls, data), który tworzy Animal ze słownika z kluczami 'name' i 'species', np. Animal.from_dict({'name': 'Simba', 'species': 'Lew'})
- Edytor kodu
Stwórz @staticmethod is_dangerous(species), który zwraca True dla gatunków 'Lew', 'Krokodyl' i 'Hipopotam', a dla innych False
- Układanie w poziomie
Ułóż nagłówek metody klasowej from_dict (linia pod dekoratorem @classmethod):
- Układanie w pionie
Uporządkuj, co się dzieje po wywołaniu print(lion) dla obiektu z metodą __str__:
- Klikanie w kolejności
Kliknij elementy w prawidłowej kolejności:
- Edytor kodu
Stwórz klasy: Animal (bazowa), Mammal(Animal), Bird(Animal), Tiger(Mammal), Eagle(Bird)
- Edytor kodu
W klasie Animal(name, age, health_status) zapisz age i health_status w atrybutach chronionych lub prywatnych (self._age albo self.__age) i dodaj dla nich property age i health_status
- Układanie w pionie
Uporządkuj kroki tworzenia klasy potomnej:
- Edytor kodu
Stwórz klasę Zoo z metodami: add_animal(animal), remove_animal(name) (usuwa zwierzę o tym imieniu), find_by_species(species) i list_all() (obie zwracają listy zwierząt). Zwierzęta to obiekty Animal(name, species)
- Edytor kodu
Połącz Animal i Zoo w program: utwórz zoo = Zoo() i w pętli while pobieraj wybór przez input(): 1 - dodaj (imię, gatunek), 2 - usuń (imię), 3 - szukaj po gatunku i wypisz imiona, 0 - wyjście
- Układanie w pionie
Uporządkuj typy metod według pierwszego parametru: najpierw te, które dostają obiekt (self), potem klasę (cls), na końcu bez self i cls:
Zadania po tej lekcji
- PytanieDekoratory
- Pytanie@classmethod
- Pytanie@staticmethod
- Ułóż w kolejnościAtrybut instancji
- Kliknij w kolejnościBudowanie adnotacji typu zwracanego
- Zadanie z kodemMetoda klasowa
- Zadanie z kodemMetoda statyczna
- Ułóż w kolejnościDekorator @classmethod
- Ułóż w kolejnościprint() i __str__
- Kliknij w kolejnościBudowanie dekoratora @property
- Zadanie z kodemProjekt - Hierarchia klas
- Zadanie z kodemProjekt - Enkapsulacja
- Ułóż w kolejnościWzorzec dziedziczenia
- Zadanie z kodemProjekt - Zoo Manager
- Zadanie z kodemProjekt - Kompletny system
- Ułóż w kolejnościTypy metod w klasie
- PytaniePodsumowanie - Klasy
- PytaniePodsumowanie - Dziedziczenie
- PytaniePodsumowanie - OOP
- Projekt do wysłaniaWyślij Safari Animal Kingdom do mentora
- WideoPodsumowanie modułu