24_magic_methods_tutorial.py

# Магические методы (dunder methods) - специальные методы с двойным подчеркиванием
# Они вызываются автоматически при определенных операциях

# ========== ИНИЦИАЛИЗАЦИЯ И ПРЕДСТАВЛЕНИЕ ==========

# 1. __init__ - конструктор
class Person:
    def __init__(self, name, age):
        print("__init__ вызван")
        self.name = name
        self.age = age

person = Person("Pavel", 25)

# 2. __str__ и __repr__ - строковое представление
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # Для конечных пользователей (читаемое)
    def __str__(self):
        return f"{self.name}, {self.age} лет"

    # Для разработчиков (должно быть валидным Python кодом)
    def __repr__(self):
        return f"Person('{self.name}', {self.age})"

person = Person("Pavel", 25)
print(str(person))   # __str__
print(repr(person))  # __repr__
print(person)        # Использует __str__, если есть

# ========== АРИФМЕТИЧЕСКИЕ ОПЕРАЦИИ ==========

# 3. Перегрузка арифметических операторов
class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        # + оператор
        return Vector(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        # - оператор
        return Vector(self.x - other.x, self.y - other.y)

    def __mul__(self, scalar):
        # * оператор
        return Vector(self.x * scalar, self.y * scalar)

    def __truediv__(self, scalar):
        # / оператор
        return Vector(self.x / scalar, self.y / scalar)

    def __str__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(2, 3)
v2 = Vector(1, 1)

print(f"v1 + v2 = {v1 + v2}")
print(f"v1 - v2 = {v1 - v2}")
print(f"v1 * 3 = {v1 * 3}")
print(f"v1 / 2 = {v1 / 2}")

# ========== ОПЕРАЦИИ СРАВНЕНИЯ ==========

# 4. Перегрузка операторов сравнения
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __eq__(self, other):
        # == оператор
        return self.age == other.age

    def __ne__(self, other):
        # != оператор
        return self.age != other.age

    def __lt__(self, other):
        # < оператор
        return self.age < other.age

    def __le__(self, other):
        # <= оператор
        return self.age <= other.age

    def __gt__(self, other):
        # > оператор
        return self.age > other.age

    def __ge__(self, other):
        # >= оператор
        return self.age >= other.age

p1 = Person("Pavel", 25)
p2 = Person("Ivan", 30)

print(f"p1 == p2: {p1 == p2}")
print(f"p1 < p2: {p1 < p2}")
print(f"p1 > p2: {p1 > p2}")

# ========== КОНТЕЙНЕРНЫЕ МЕТОДЫ ==========

# 5. __len__, __getitem__, __setitem__
class CustomList:
    def __init__(self):
        self.items = []

    def __len__(self):
        # len(obj)
        return len(self.items)

    def __getitem__(self, index):
        # obj[index]
        return self.items[index]

    def __setitem__(self, index, value):
        # obj[index] = value
        self.items[index] = value

    def append(self, item):
        self.items.append(item)

my_list = CustomList()
my_list.append(1)
my_list.append(2)
my_list.append(3)

print(f"len(my_list): {len(my_list)}")
print(f"my_list[0]: {my_list[0]}")

my_list[1] = 99
print(f"my_list[1] после изменения: {my_list[1]}")

# 6. __contains__ - оператор in
class CustomList:
    def __init__(self, items):
        self.items = items

    def __contains__(self, item):
        # item in obj
        return item in self.items

my_list = CustomList([1, 2, 3, 4, 5])
print(f"3 in my_list: {3 in my_list}")
print(f"10 in my_list: {10 in my_list}")

# 7. __iter__ и __next__ - итерация
class Counter:
    def __init__(self, max_value):
        self.max_value = max_value
        self.current = 0

    def __iter__(self):
        # Возвращает итератор (обычно self)
        return self

    def __next__(self):
        # Возвращает следующий элемент
        if self.current < self.max_value:
            self.current += 1
            return self.current
        else:
            raise StopIteration  # Конец итерации

counter = Counter(5)
for num in counter:
    print(num)  # 1, 2, 3, 4, 5

# ========== ВЫЗОВ ОБЪЕКТА КАК ФУНКЦИИ ==========

# 8. __call__ - делает объект вызываемым
class Multiplier:
    def __init__(self, factor):
        self.factor = factor

    def __call__(self, x):
        # Теперь объект можно вызывать как функцию
        return x * self.factor

double = Multiplier(2)
triple = Multiplier(3)

print(f"double(5) = {double(5)}")   # 10
print(f"triple(5) = {triple(5)}")   # 15

# ========== КОНТЕКСТНЫЕ МЕНЕДЖЕРЫ ==========

# 9. __enter__ и __exit__ - для with statement
class FileManager:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None

    def __enter__(self):
        print("Открываем файл...")
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Закрываем файл...")
        if self.file:
            self.file.close()
        # Возврат False означает, что исключение будет выброшено дальше
        return False

# Использование
with FileManager("test.txt", "w") as f:
    f.write("Hello, World!")

# ========== АТРИБУТЫ ==========

# 10. __getattr__, __setattr__, __delattr__
class AttributeTracker:
    def __getattr__(self, name):
        # Вызывается, когда атрибут НЕ найден
        print(f"__getattr__: {name}")
        return f"Атрибут '{name}' не существует"

    def __setattr__(self, name, value):
        # Вызывается при установке атрибута
        print(f"__setattr__: {name} = {value}")
        super().__setattr__(name, value)

    def __delattr__(self, name):
        # Вызывается при удалении атрибута
        print(f"__delattr__: {name}")
        super().__delattr__(name)

obj = AttributeTracker()
obj.x = 10          # __setattr__
print(obj.x)        # 10
print(obj.unknown)  # __getattr__
del obj.x           # __delattr__

# ========== ДРУГИЕ ПОЛЕЗНЫЕ МЕТОДЫ ==========

# 11. __bool__ - приведение к bool
class EmptyChecker:
    def __init__(self, items):
        self.items = items

    def __bool__(self):
        # Определяет поведение в булевом контексте
        return len(self.items) > 0

empty = EmptyChecker([])
not_empty = EmptyChecker([1, 2, 3])

print(f"bool(empty): {bool(empty)}")          # False
print(f"bool(not_empty): {bool(not_empty)}")  # True

if not_empty:
    print("Не пустой!")

# 12. __hash__ - для использования в set и dict
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

    def __hash__(self):
        # Должен возвращать одинаковое значение для равных объектов
        return hash((self.x, self.y))

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

p1 = Point(1, 2)
p2 = Point(1, 2)
p3 = Point(3, 4)

# Можно использовать в множестве
points = {p1, p2, p3}  # p1 и p2 считаются одинаковыми
print(f"Множество точек: {[str(p) for p in points]}")

# Можно использовать как ключи словаря
point_names = {p1: "A", p3: "B"}
print(f"Имя точки p2: {point_names[p2]}")  # A (p1 == p2)

# 13. __del__ - деструктор (вызывается при удалении объекта)
class Resource:
    def __init__(self, name):
        self.name = name
        print(f"Ресурс '{name}' создан")

    def __del__(self):
        print(f"Ресурс '{self.name}' удален")

r = Resource("File")
del r  # __del__ вызван

# ========== ПОЛНЫЙ СПИСОК ПОПУЛЯРНЫХ МАГИЧЕСКИХ МЕТОДОВ ==========

# Инициализация:
# __init__, __new__, __del__

# Представление:
# __str__, __repr__, __format__

# Арифметика:
# __add__, __sub__, __mul__, __truediv__, __floordiv__, __mod__, __pow__

# Сравнение:
# __eq__, __ne__, __lt__, __le__, __gt__, __ge__

# Контейнеры:
# __len__, __getitem__, __setitem__, __delitem__, __contains__, __iter__, __next__

# Атрибуты:
# __getattr__, __setattr__, __delattr__, __getattribute__

# Вызов:
# __call__

# Контекстные менеджеры:
# __enter__, __exit__

# Преобразования:
# __int__, __float__, __bool__, __str__, __bytes__

# Другие:
# __hash__, __dir__, __sizeof__