Kurs Python · Moduł 3: Programowanie obiektowe
Metody magiczne - ukryte zachowania zwierząt
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 samo3. __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 wagaTip: 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)- odczytobj[key]__setitem__(self, key, value)- zapisobj[key] = value__delitem__(self, key)- usunięciedel obj[key]__contains__(self, item)- członkostwoitem in obj__iter__(self)- iteratorfor x in obj__next__(self)- następny element
Callable i Context Manager
__call__(self, ...)- wywołanieobj()__enter__(self)- wejście dowith__exit__(self, ...)- wyjście zwith
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. Jaka jest różnica między __str__ a __repr__?
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):