Kurs Python · Moduł 3: Programowanie obiektowe

Metody magiczne - ukryte zachowania zwierząt

13 min czytania ·
W tej lekcji11

Witaj ponownie! Tu Darwin, dziś fascynująca lekcja o ukrytych mocach Pythona.

W naturze zwierzęta mają ukryte zachowania - lew ryczy, słoń trąbi, kameleon się maskuje. W Pythonie klasy też mogą mieć ukryte zachowania przez metody magiczne (magic methods) - specjalne metody z podwójnym podkreśleniem!

lion = Animal("Lew")
print(lion)  # Jak Python wie, co wyświetlić? __str__!
len(lion)    # Jak Python wie, co zmierzyć? __len__!
lion + elephant  # Jak Python wie, co dodać? __add__!

Czym są metody magiczne?

Metody magiczne (zwane też dunder methods od "double underscore") to specjalne metody z nazwami w formacie __method__, które Python automatycznie wywołuje w określonych sytuacjach.

Analogia Safari: To jak naturalne instynkty zwierząt - nie musisz ich uczyć, są wbudowane w ich naturę!

class Animal:
    def __init__(self, name):
        """Wywoływane przy TWORZENIU obiektu"""
        self.name = name

    def __str__(self):
        """Wywoływane przez print() i str()"""
        return f"Animal: {self.name}"

    def __len__(self):
        """Wywoływane przez len()"""
        return len(self.name)

lion = Animal("Lew")  # Wywołuje __init__
print(lion)           # Wywołuje __str__
print(len(lion))      # Wywołuje __len__

Dlaczego "magiczne"?

  • Python wywołuje je automatycznie
  • Sprawiają, że Twoje klasy zachowują się jak wbudowane typy
  • Pozwalają używać standardowej składni Pythona

Podstawowe metody magiczne

1. __init__ - Konstruktor

Już znasz! Wywoływana przy tworzeniu obiektu.

class Species:
    def __init__(self, name, population):
        """Inicjalizacja - już to znasz!"""
        self.name = name
        self.population = population

lion = Species("Lew", 500)  # Wywołuje __init__

2. __str__ - Reprezentacja czytelna dla ludzi

Wywoływana przez print() i str() - zwraca string przyjazny użytkownikowi. Gdy piszesz print(lion), print() najpierw zamienia argument na tekst przez str(lion), a str() wywołuje metodę lion.__str__().

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        """Dla ludzi - czytelne"""
        return f"{self.name} (wiek: {self.age} lat)"

lion = Animal("Simba", 5)
print(lion)  # "Simba (wiek: 5 lat)" - wywołuje __str__
print(str(lion))  # To samo

3. __repr__ - Reprezentacja dla programistów

Wywoływana przez repr() i w konsoli - zwraca jednoznaczną reprezentację obiektu.

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        """Dla programistów - precyzyjne"""
        return f"Animal(name='{self.name}', age={self.age})"

    def __str__(self):
        """Dla użytkowników - czytelne"""
        return f"{self.name} ({self.age} lat)"

lion = Animal("Simba", 5)

# W konsoli Python
>>> lion
Animal(name='Simba', age=5)  # Wywołuje __repr__

# Przez print()
print(lion)  # "Simba (5 lat)" - wywołuje __str__

# repr() wywołane jawnie
print(repr(lion))  # "Animal(name='Simba', age=5)"

Zasada: __repr__ powinien zwracać kod, którym można odtworzyć obiekt!

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        return f"Point({self.x}, {self.y})"

p = Point(3, 4)
print(repr(p))  # "Point(3, 4)" - możesz skopiować i wkleić!

Metody porównania

Pozwalają porównywać obiekty z ==, <, >, etc.

class Animal:
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight  # kg

    def __eq__(self, other):
        """Równość: =="""
        if not isinstance(other, Animal):
            return False
        return self.weight == other.weight

    def __lt__(self, other):
        """Mniejsze niż: <"""
        if not isinstance(other, Animal):
            return NotImplemented
        return self.weight < other.weight

    def __le__(self, other):
        """Mniejsze lub równe: <="""
        return self.weight <= other.weight

    def __gt__(self, other):
        """Większe niż: >"""
        return self.weight > other.weight

    def __ge__(self, other):
        """Większe lub równe: >="""
        return self.weight >= other.weight

    def __ne__(self, other):
        """Nierówne: !="""
        return not self.__eq__(other)

lion = Animal("Lew", 190)
elephant = Animal("Słoń", 5000)
rhino = Animal("Nosorożec", 2300)

print(lion < elephant)  # True - wywołuje __lt__
print(elephant > rhino)  # True - wywołuje __gt__
print(lion == Animal("Tygrys", 190))  # True - taka sama waga

Tip: Możesz użyć dekoratora @functools.total_ordering - zdefiniuj tylko __eq__ i jeden z __lt__, __le__, __gt__, __ge__, reszta zostanie automatycznie wygenerowana!

from functools import total_ordering

@total_ordering
class Animal:
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight

    def __eq__(self, other):
        """Tylko to i __lt__ - reszta automatycznie!"""
        if not isinstance(other, Animal):
            return False
        return self.weight == other.weight

    def __lt__(self, other):
        """Tylko to i __eq__ - reszta automatycznie!"""
        if not isinstance(other, Animal):
            return NotImplemented
        return self.weight < other.weight

    # __le__, __gt__, __ge__, __ne__ - automatycznie wygenerowane!

Metody arytmetyczne

Pozwalają używać operatorów matematycznych z obiektami!

class Population:
    """Reprezentuje populację gatunku"""

    def __init__(self, species, count):
        self.species = species
        self.count = count

    def __add__(self, other):
        """Dodawanie: +"""
        if isinstance(other, Population):
            if self.species != other.species:
                raise ValueError("Różne gatunki!")
            return Population(self.species, self.count + other.count)
        elif isinstance(other, int):
            return Population(self.species, self.count + other)
        return NotImplemented

    def __sub__(self, other):
        """Odejmowanie: -"""
        if isinstance(other, int):
            return Population(self.species, max(0, self.count - other))
        return NotImplemented

    def __mul__(self, other):
        """Mnożenie: *"""
        if isinstance(other, (int, float)):
            return Population(self.species, int(self.count * other))
        return NotImplemented

    def __str__(self):
        return f"{self.species}: {self.count} osobników"

# Użycie operatorów!
lions_north = Population("Lew", 120)
lions_south = Population("Lew", 85)

# Dodawanie populacji
total_lions = lions_north + lions_south
print(total_lions)  # "Lew: 205 osobników"

# Dodawanie liczby
more_lions = lions_north + 30
print(more_lions)  # "Lew: 150 osobników"

# Odejmowanie (zmniejszenie populacji)
fewer_lions = lions_north - 20
print(fewer_lions)  # "Lew: 100 osobników"

# Mnożenie (szacowanie wzrostu)
projected = lions_north * 1.5  # Wzrost o 50%
print(projected)  # "Lew: 180 osobników"

Metody kontenerowe

Sprawiają, że Twoje obiekty zachowują się jak listy, słowniki!

__len__ - Długość

Gdy klasa ma metodę __len__, funkcja len() działa na jej obiektach tak samo jak na liście. Stado zwraca liczbę swoich członków:

class Pack:
    """Stado zwierząt"""

    def __init__(self, species):
        self.species = species
        self.members = []

    def add(self, name):
        self.members.append(name)

    def __len__(self):
        """Wywołane przez len()"""
        return len(self.members)

pack = Pack("Lwy")
pack.add("Simba")
pack.add("Nala")
pack.add("Mufasa")

print(len(pack))  # 3 - wywołuje __len__

__getitem__ i __setitem__ - Dostęp przez indeks

Te dwie metody pozwalają czytać i zmieniać elementy obiektu przez nawiasy kwadratowe, jak w liście. Siedlisko dostaje przy okazji metodę __contains__, która obsługuje operator in:

class Habitat:
    """Siedlisko ze zwierzętami"""

    def __init__(self, name):
        self.name = name
        self.animals = []

    def __getitem__(self, index):
        """Dostęp do odczytu: habitat[0]"""
        return self.animals[index]

    def __setitem__(self, index, value):
        """Dostęp do zapisu: habitat[0] = "Lew" """
        self.animals[index] = value

    def __len__(self):
        return len(self.animals)

    def __contains__(self, item):
        """Operator 'in': "Lew" in habitat"""
        return item in self.animals

    def append(self, animal):
        self.animals.append(animal)

savanna = Habitat("Sawanna")
savanna.append("Lew")
savanna.append("Słoń")
savanna.append("Żyrafa")

# Dostęp jak do listy!
print(savanna[0])  # "Lew" - wywołuje __getitem__
savanna[1] = "Nosorożec"  # Wywołuje __setitem__

# Operator in
print("Lew" in savanna)  # True - wywołuje __contains__

# len()
print(len(savanna))  # 3 - wywołuje __len__

# Iteracja (automatyczna przez __getitem__)
for animal in savanna:
    print(animal)

__iter__ i __next__ - Iteracja

Pętla for najpierw wywołuje __iter__, a potem __next__ w każdym kroku, aż dostanie wyjątek StopIteration. Tak zbudujemy kalendarz dni ekspedycji:

class Expedition:
    """Iterator po dniach ekspedycji"""

    def __init__(self, days):
        self.days = days
        self.current_day = 0

    def __iter__(self):
        """Zwróć iterator (siebie)"""
        self.current_day = 0
        return self

    def __next__(self):
        """Zwróć następny element"""
        if self.current_day >= self.days:
            raise StopIteration  # Koniec iteracji

        self.current_day += 1
        return f"Dzień {self.current_day}"

expedition = Expedition(5)

# Iteracja przez for
for day in expedition:
    print(day)
# Dzień 1
# Dzień 2
# Dzień 3
# Dzień 4
# Dzień 5

# Lub manualnie
exp2 = Expedition(3)
print(next(exp2))  # "Dzień 1"
print(next(exp2))  # "Dzień 2"
print(next(exp2))  # "Dzień 3"

Czwarte wywołanie next(exp2) zgłosiłoby wyjątek StopIteration. To ten sam sygnał, po którym pętla for sama kończy pracę.

__call__ - Obiekty wywoływalne

Sprawia, że obiekt można wywołać jak funkcję!

class AnimalSound:
    """Callable - obiekt jak funkcja"""

    def __init__(self, species, sound):
        self.species = species
        self.sound = sound

    def __call__(self, times=1):
        """Wywołanie obiektu jak funkcji"""
        return " ".join([self.sound] * times)

lion_roar = AnimalSound("Lew", "ROAR")
elephant_trumpet = AnimalSound("Słoń", "TRUUU")

# Wywołaj jak funkcję!
print(lion_roar())  # "ROAR" - wywołuje __call__
print(lion_roar(3))  # "ROAR ROAR ROAR"
print(elephant_trumpet(2))  # "TRUUU TRUUU"

Context managers - __enter__ i __exit__

Pozwala używać with statement!

class SafariCamera:
    """Context manager do robienia zdjęć"""

    def __init__(self, location):
        self.location = location
        self.photos = []

    def __enter__(self):
        """Wywoływane przy wejściu do bloku 'with'"""
        print(f"Włączam kamerę w {self.location}")
        return self  # Zwróć obiekt do użycia

    def __exit__(self, exc_type, exc_val, exc_tb):
        """Wywoływane przy wyjściu z bloku 'with'"""
        print(f"Zapisane zdjęcia: {len(self.photos)}")
        print(f"Wyłączam kamerę")
        return False  # Nie tłum wyjątków

    def take_photo(self, subject):
        """Zrób zdjęcie"""
        self.photos.append(subject)
        print(f"  Zdjęcie: {subject}")

# Użycie z 'with' - automatyczne __enter__ i __exit__!
with SafariCamera("Serengeti") as camera:
    camera.take_photo("Lew polujący")
    camera.take_photo("Stado słoni")
    camera.take_photo("Żyrafa przy drzewie")

Po uruchomieniu w konsoli zobaczysz:

Włączam kamerę w Serengeti
  Zdjęcie: Lew polujący
  Zdjęcie: Stado słoni
  Zdjęcie: Żyrafa przy drzewie
Zapisane zdjęcia: 3
Wyłączam kamerę

Nigdzie nie wywołaliśmy __enter__ ani __exit__ ręcznie. with uruchomił pierwszą metodę na początku bloku, a drugą automatycznie na jego końcu i zrobiłby to nawet wtedy, gdyby w środku wystąpił błąd.

Przykład z safari - kompletny system katalogowania

Na koniec klasa gatunku, która korzysta z prawie wszystkich metod magicznych z tej lekcji: jej obiekty mają czytelny opis, porównują się po populacji, obsługują + i -, zachowują się jak kontener i można je wywołać jak funkcję.

from functools import total_ordering
from datetime import datetime

@total_ordering
class Species:
    """
    Klasa gatunku z pełnym zestawem metod magicznych

    Zachowuje się jak wbudowany typ Pythona!
    """

    all_species = []  # Rejestr wszystkich gatunków

    def __init__(self, scientific_name, common_name, population, habitat):
        """Konstruktor"""
        self.scientific_name = scientific_name
        self.common_name = common_name
        self.population = population
        self.habitat = habitat
        self.observations = []

        Species.all_species.append(self)

    # === REPREZENTACJA ===

    def __str__(self):
        """Dla print() - przyjazne dla człowieka"""
        return f"{self.common_name} ({self.population} osobników)"

    def __repr__(self):
        """Dla repr() - jednoznaczne"""
        return (f"Species(scientific_name='{self.scientific_name}', "
                f"common_name='{self.common_name}', "
                f"population={self.population}, "
                f"habitat='{self.habitat}')")

    # === PORÓWNANIA (tylko __eq__ i __lt__, reszta przez @total_ordering) ===

    def __eq__(self, other):
        """Równość: =="""
        if not isinstance(other, Species):
            return False
        return self.population == other.population

    def __lt__(self, other):
        """Mniejsze niż: < (porównanie po populacji)"""
        if not isinstance(other, Species):
            return NotImplemented
        return self.population < other.population

    def __hash__(self):
        """Hash z tego samego pola co __eq__ - obiekty równe muszą mieć równy hash"""
        return hash(self.population)

    # === ARYTMETYKA ===

    def __add__(self, other):
        """Dodawanie: species + 50"""
        if isinstance(other, int):
            return Species(
                self.scientific_name,
                self.common_name,
                self.population + other,
                self.habitat
            )
        return NotImplemented

    def __sub__(self, other):
        """Odejmowanie: species - 20"""
        if isinstance(other, int):
            return Species(
                self.scientific_name,
                self.common_name,
                max(0, self.population - other),
                self.habitat
            )
        return NotImplemented

    # === KONTENER ===

    def __len__(self):
        """len(species) - liczba obserwacji"""
        return len(self.observations)

    def __getitem__(self, index):
        """species[0] - dostęp do obserwacji"""
        return self.observations[index]

    def __contains__(self, location):
        """'Serengeti' in species - sprawdź lokalizację"""
        return any(obs["location"] == location for obs in self.observations)

    # === CALLABLE ===

    def __call__(self, location, count):
        """Wywołanie jak funkcja - dodaj obserwację"""
        observation = {
            "date": datetime.now().strftime("%Y-%m-%d"),
            "location": location,
            "count": count
        }
        self.observations.append(observation)
        return f"Dodano: {count}x {self.common_name} w {location}"

    # === BOOL ===

    def __bool__(self):
        """bool(species) - czy gatunek ma jakąś populację?"""
        return self.population > 0

# === DEMONSTRACJA WSZYSTKICH MAGICZNYCH METOD ===

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

lion = Species("Panthera leo", "Lew", 120, "sawanna")
elephant = Species("Loxodonta africana", "Słoń", 450, "sawanna")
rhino = Species("Diceros bicornis", "Nosorożec", 45, "sawanna")
extinct = Species("Dodo", "Dodo", 0, "Mauritius")

# __str__ i __repr__
print("__str__ (print):")
print(lion)  # "Lew (120 osobników)"

print("\n__repr__ (repr):")
print(repr(lion))
# Species(scientific_name='Panthera leo', common_name='Lew', population=120, habitat='sawanna')

# Porównania (__eq__, __lt__, etc.)
print("\n=== PORÓWNANIA ===")
print(f"lion == elephant? {lion == elephant}")  # False
print(f"rhino < lion? {rhino < lion}")  # True (45 < 120)
print(f"elephant > lion? {elephant > lion}")  # True (450 > 120)

# Sortowanie (działa przez __lt__)
species_list = [lion, rhino, elephant]
species_list.sort()
print(f"\nPosortowane (rosnąco): {[str(s) for s in species_list]}")
# ['Nosorożec (45 osobników)', 'Lew (120 osobników)', 'Słoń (450 osobników)']

# Arytmetyka (__add__, __sub__)
print("\n=== ARYTMETYKA ===")
more_lions = lion + 30  # Zwiększ populację
print(f"lion + 30 = {more_lions}")  # "Lew (150 osobników)"

fewer_rhinos = rhino - 10
print(f"rhino - 10 = {fewer_rhinos}")  # "Nosorożec (35 osobników)"

# Callable (__call__)
print("\n=== CALLABLE - dodawanie obserwacji ===")
print(lion("Serengeti", 12))  # Wywołaj jak funkcję!
print(lion("Masai Mara", 8))
print(elephant("Amboseli", 35))

# Kontener (__len__, __getitem__, __contains__)
print("\n=== KONTENER ===")
print(f"Liczba obserwacji lwów: {len(lion)}")  # __len__
print(f"Pierwsza obserwacja: {lion[0]}")  # __getitem__
print(f"'Serengeti' in lion? {'Serengeti' in lion}")  # __contains__ - True

# Iteracja (przez __getitem__)
print("\nWszystkie obserwacje lwów:")
for obs in lion:
    print(f"  - {obs['date']} w {obs['location']}: {obs['count']} osobników")

# Bool (__bool__)
print("\n=== BOOL ===")
print(f"bool(lion)? {bool(lion)}")  # True - ma populację
print(f"bool(extinct)? {bool(extinct)}")  # False - populacja 0

if lion:
    print("Lew ma populację!")

if not extinct:
    print("Dodo wymarł...")

# Hash (__hash__) - działa w set i dict
print("\n=== HASH - użycie w set/dict ===")
species_set = {lion, elephant, rhino}
print(f"Zbiór gatunków: {len(species_set)} elementów")

species_dict = {
    lion: "Drapieżnik",
    elephant: "Roślinożerca",
    rhino: "Roślinożerca"
}
print(f"Typ lwa: {species_dict[lion]}")

Lista najważniejszych metod magicznych

Inicjalizacja i reprezentacja

  • __init__(self, ...) - konstruktor
  • __new__(cls, ...) - tworzy obiekt; Python wywołuje tę metodę przed __init__ (rzadko nadpisywana)
  • __str__(self) - string dla użytkownika (print)
  • __repr__(self) - string dla programisty (repr)
  • __format__(self, format_spec) - formatowanie (f"{obj:spec}")

Porównania

  • __eq__(self, other) - równość ==
  • __ne__(self, other) - nierówność !=
  • __lt__(self, other) - mniejsze <
  • __le__(self, other) - mniejsze lub równe <=
  • __gt__(self, other) - większe >
  • __ge__(self, other) - większe lub równe >=

Arytmetyka

  • __add__(self, other) - dodawanie +
  • __sub__(self, other) - odejmowanie -
  • __mul__(self, other) - mnożenie *
  • __truediv__(self, other) - dzielenie /
  • __floordiv__(self, other) - dzielenie całkowite //
  • __mod__(self, other) - modulo %
  • __pow__(self, other) - potęgowanie **

Kontener

  • __len__(self) - długość len()
  • __getitem__(self, key) - odczyt obj[key]
  • __setitem__(self, key, value) - zapis obj[key] = value
  • __delitem__(self, key) - usunięcie del obj[key]
  • __contains__(self, item) - członkostwo item in obj
  • __iter__(self) - iterator for x in obj
  • __next__(self) - następny element

Callable i Context Manager

  • __call__(self, ...) - wywołanie obj()
  • __enter__(self) - wejście do with
  • __exit__(self, ...) - wyjście z with

Inne

  • __bool__(self) - konwersja do bool
  • __hash__(self) - hash dla set/dict
  • __del__(self) - destruktor (rzadko używane)

Podsumowanie

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

  • Czym są metody magiczne (dunder methods)
  • Jak sprawić, by klasy zachowywały się jak wbudowane typy
  • Implementacji __str__, __repr__, __eq__, __lt__
  • Operatorów arytmetycznych (__add__, __sub__, __mul__)
  • Zachowań kontenerowych (__len__, __getitem__, __contains__)
  • Callable objects z __call__
  • Context managers z __enter__ i __exit__
  • Praktycznego przykładu z kompletnym systemem katalogowania

Checkpoint

Przed przejściem dalej:

  • Rozumiesz różnicę między __str__ a __repr__
  • Potrafisz zaimplementować porównania
  • Wiesz jak dodać operatory arytmetyczne
  • Rozumiesz __len__, __getitem__, __iter__
  • Potrafisz stworzyć callable object z __call__

Analogia Safari: Metody magiczne to instynkty zwierząt - lew nie uczy się ryczeć, po prostu to robi! Twoje klasy też mogą mieć naturalne zachowania!

W następnej lekcji Darwin nauczy Cię type hints - jak precyzyjnie opisywać typy danych, żeby kod był bardziej czytelny i bezpieczny!

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. Jaka jest różnica między __str__ a __repr__?

  2. 2. Kiedy wywoływana jest metoda __len__?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w pionie

    Uporządkuj cykl życia obiektu:

  • Edytor kodu

    Dodaj metodę __str__ do klasy Animal zwracającą 'Animal: {name}'

  • Edytor kodu

    W klasie Animal(name, species) dodaj metodę __eq__, która porównuje zwierzęta po species (to samo species = równe)

  • Klikanie w kolejności

    Kliknij elementy w prawidłowej kolejności:

  • Klikanie w kolejności

    Kliknij elementy nagłówka metody, którą wywołuje print(obiekt):

  1. Ułóż w kolejnościCykl życia obiektu
  2. Pytanie__str__ vs __repr__
  3. Pytanie__len__
  4. Pytanie__eq__
  5. Zadanie z kodemMetoda __str__
  6. Zadanie z kodemMetoda __eq__
  7. Kliknij w kolejnościBudowanie isinstance()
  8. Kliknij w kolejnościMetoda magiczna

Przydatne artykuły