Kurs Python · Moduł 3: Programowanie obiektowe

Dekoratory - adaptacja do środowiska

13 min czytania ·
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 dekorowanie

Jak 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 greet

Wrapper 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:

  1. repeat(times) - zwraca dekorator
  2. decorator(func) - prawdziwy dekorator
  3. wrapper(*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) > 0

Praktyczne 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.0015s

2. 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 Serengeti

Gdyby 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,)
5

Każ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():
    pass

Taki 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 *args i **kwargs
  • Używania @functools.wraps do 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. 1. Dekorator w Pythonie to:

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

  1. PytanieDekoratory
  2. Pytanie@classmethod
  3. Pytanie@staticmethod
  4. Ułóż w kolejnościAtrybut instancji
  5. Kliknij w kolejnościBudowanie adnotacji typu zwracanego
  6. Zadanie z kodemMetoda klasowa
  7. Zadanie z kodemMetoda statyczna
  8. Ułóż w kolejnościDekorator @classmethod
  9. Ułóż w kolejnościprint() i __str__
  10. Kliknij w kolejnościBudowanie dekoratora @property
  11. Zadanie z kodemProjekt - Hierarchia klas
  12. Zadanie z kodemProjekt - Enkapsulacja
  13. Ułóż w kolejnościWzorzec dziedziczenia
  14. Zadanie z kodemProjekt - Zoo Manager
  15. Zadanie z kodemProjekt - Kompletny system
  16. Ułóż w kolejnościTypy metod w klasie
  17. PytaniePodsumowanie - Klasy
  18. PytaniePodsumowanie - Dziedziczenie
  19. PytaniePodsumowanie - OOP
  20. Projekt do wysłaniaWyślij Safari Animal Kingdom do mentora
  21. WideoPodsumowanie modułu

Przydatne artykuły