📦 Репозиторий занятия 76

## Зачем нужны абстрактные классы и методы?

### 1. Обеспечивают единый интерфейс

Абстрактный класс задаёт «контракт» для всех наследников.

* Пример: если у нас есть разные виды животных (`Dog`, `Cat`, `Bird`), у всех есть метод `make_sound()`.
* Абстрактный класс `Animal` гарантирует, что любой новый класс-наследник тоже будет иметь метод `make_sound()`.

**Плюс:** мы можем обращаться к объектам через общий тип:

```python
animals = [Dog(), Cat()]
for animal in animals:
    animal.make_sound()  # Не важно, кто это — все обязаны иметь make_sound
```

---

### 2. Позволяют писать более гибкий и расширяемый код

* Мы создаём общую структуру один раз (абстрактный класс).
* Любой новый тип наследника может расширять или менять поведение, не ломая остальной код.

**Пример:** добавили новый класс `Bird`, он автоматически работает с кодом, который работает с `Animal`.

---

### 3. Защищают от неправильного использования

* Нельзя случайно создать объект абстрактного класса, где некоторые методы ещё не реализованы.
* Это предотвращает ошибки ещё на этапе написания кода.

---

### 4. Позволяют комбинировать реализацию и интерфейс

* Абстрактный класс может содержать 
  * и **частично готовый код** (обычные методы) 
  * и **обязательные методы для реализации** (абстрактные).
* Это экономит повторное написание кода и делает проект более поддерживаемым.

---

### Резюме

**Абстрактные классы нужны для того, чтобы:**

1. Обеспечить единый интерфейс для всех наследников.
2. Сделать код расширяемым и гибким.
3. Предотвратить создание «недопустимых» объектов.
4. Частично реализовать общую функциональность.

### 1. Абстрактный класс

**Абстрактный класс** — это класс, который **не предназначен для непосредственного создания объектов**,  
а служит как шаблон для других классов. 

Он может содержать:

* **Абстрактные методы** — методы без реализации (только сигнатура).
* **Обычные методы** — с реализацией, которые могут использовать наследники.

**Когда использовать:**

* Когда есть общая структура/поведение для группы классов, но конкретная реализация некоторых методов различается.

---

#### Пример

```python
from abc import ABC, abstractmethod

class Animal(ABC):  # Наследуемся от ABC, чтобы сделать класс абстрактным
    @abstractmethod
    def make_sound(self):  # Абстрактный метод
        pass

    def sleep(self):  # Обычный метод с реализацией
        print("Сплю...")

# Нельзя создать объект абстрактного класса
# a = Animal()  # Ошибка!
```

---

### 2. Абстрактный метод

**Абстрактный метод** — это метод, который объявлен, но **не имеет реализации**. 

Любой класс-наследник обязан **реализовать этот метод**, иначе он тоже станет абстрактным.

### Пример реализации

```python
class Dog(Animal):
    def make_sound(self):  # Реализация абстрактного метода
        print("Гав-гав!")

class Cat(Animal):
    def make_sound(self):
        print("Мяу!")

dog = Dog()
dog.make_sound()  # Выведет "Гав-гав!"
dog.sleep()       # Выведет "Сплю..."

cat = Cat()
cat.make_sound()  # Выведет "Мяу!"
```

…

### 1. Что такое пользовательские исключения?

**Пользовательские исключения** — это специальные ошибки,  
которые создаёт программист для обработки **конкретных ситуаций в программе**,  
которых нет среди стандартных исключений языка.

* Стандартные исключения: `ValueError`, `IndexError`, `KeyError` и т.д.
* Пользовательские: создаются для конкретной логики программы, 
  * например `InsufficientFundsError` в банковском приложении.

**Зачем нужны:**

1. Делают код более **понятным и читаемым** — сразу видно, что пошло не так.
2. Позволяют **точно ловить ошибки**, а не перехватывать всё подряд через `Exception`.
3. Поддерживают **расширяемость** — мы можем добавлять новые типы ошибок по мере роста проекта.

---

### 2. Как создавать пользовательские исключения?

В Python пользовательские исключения создаются через наследование от встроенного класса `Exception`(или его потомков):

```python
# Создание пользовательского исключения
class MyCustomError(Exception):
    """Ошибка, специфичная для моего приложения"""
    pass
```

* Обычно добавляют docstring, чтобы описать назначение исключения.
* Можно добавлять свои атрибуты и методы, если нужно передавать больше информации.

---

## 3. Использование пользовательских исключений

```python
class InsufficientFundsError(Exception):
    """Ошибка при недостатке средств на счете"""
    def __init__(self, balance, amount):
        super().__init__(f"Недостаточно средств: баланс {balance}, попытка снять {amount}")
        self.balance = balance
        self.amount = amount

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError(balance, amount)
    return balance - amount

# Пример использования
try:
    new_balance = withdraw(100, 150)
except InsufficientFundsError as e:
    print("Ошибка:", e)
```

**Вывод:**

```
Ошибка: Недостаточно средств: баланс 100, попытка снять 150
…

### 1. Что такое магические методы итерации

Основные магические методы для итерации:

#### 1.1. `__iter__()`

* Обычно **возвращает сам объект-итератор** (`return self`), если класс реализует и `__iter__`, и `__next__` одновременно.
* Инициализирует необходимые атрибуты для начала итерации, например указатель на текущий элемент.

#### 1.2. `__next__()`

Содержит основную логику итератора:

1. **Логика получения следующего элемента** — как определить, что возвращать на текущем шаге.
2. **Ссылка на коллекцию или данные**, по которым происходит итерация (или генерация элемента).
3. **Указатель на текущую позицию** — чтобы знать, какой элемент возвращать следующим.
4. **Вызов `StopIteration`** — когда элементы исчерпаны, чтобы остановить цикл `for` или другую итерацию.

---

#### Таким образом:

* `__iter__()` → подготовка и возврат итератора.
* `__next__()` → шаг итерации: вернуть элемент или остановить итерацию.

---

### 2. Зачем нужны магические методы итерации

1. Позволяют **создавать свои последовательности** и коллекции, по которым можно проходить в цикле `for`.
2. Делают объекты **совместимыми с Python-функциями**, которые работают с итерируемыми объектами (`sum()`, `list()`, `any()`, `all()`).
3. Упрощают **ленивые вычисления**, когда элементы создаются по мере необходимости (например, бесконечные генераторы).

---

### 3. Пример реализации итератора

Создадим класс, который итерируется по диапазону чисел:

```python
class MyRange:
    def __init__(self, start, end):
        self.start = start
        self.end = end

    def __iter__(self):
        # начинает сначала при повторном вызове iter()
        self.current = self.start
        return self

    def __next__(self):
        if self.current >= self.end:
            raise StopIteration  # Конец итерации
        value = self.current
        self.current += 1
        return value

# Использование
for number in MyRange(1, 5):
    print(number)
…

### 1. Недостатки предыдущего примера


```python
from typing import Iterable, Iterator

class MyRange:
    def __init__(self, start, end):
        self.start = start
        self.end = end

    def __iter__(self):
        # обновляет значение старта при перезапуске с помощью iter()
        self.current = self.start
        return self

    def __next__(self):
        if self.current >= self.end:
            raise StopIteration  # Конец итерации
        value = self.current
        self.current += 1
        return value


my_range = MyRange(1, 5)
print(isinstance(my_range, Iterable))
print(isinstance(my_range, Iterator))


for number in my_range:
    print(number)

```

Экземпляр класса `MaRange` является итератором, так как содержит методы `__iter__()` и `__next__()`.

Но это нарушает **принцип разделение ответственности**, когда объект одновременно представляет собой
* и набор данных 
  * (должен быть итерируемым и создавать новые итераторы)
* и процесс обхода 
  * (должен быть итератором и не должен перезапускаться)  



### 2. Улучшенный вариант итератора

Разделяем между собой `Iterator` и `Iterable`:

```python
from typing import Iterable, Iterator

class MyRange:
    def __init__(self, start, end):
        self.start = start
        self.end = end

    def __iter__(self):
        return MyRangeIterator(self.start, self.end)


…