Skip to content

Abstract base class - Абстрактные классы ​

abc.ABC + @abstractmethod — механизм контракта: базовый класс описывает интерфейс (какие методы обязан реализовать наследник), а создание экземпляра без реализации падает с TypeError. Это «компиляторная» проверка полиморфизма (принцип подстановки Лискова, LSP) до рантайма.

Минимальный пример ​

python
from abc import ABC, abstractmethod


class Shape(ABC):
    @abstractmethod
    def area(self) -> float:
        raise NotImplementedError


    @abstractmethod
    def perimeter(self) -> float:
        raise NotImplementedError


class Circle(Shape):
    def __init__(self, r):
        self.r = r

    def area(self):
        import math
        return math.pi * self.r ** 2

    def perimeter(self):
        import math
        return 2 * math.pi * self.r


class Broken(Shape):
    def area(self):
        return 0


s = Circle(2)
print(s.area(), round(s.perimeter(), 2))   # 12.566... 12.57

# b = Broken()
# TypeError: Can't instantiate abstract class Broken
# with abstract method 'perimeter'

Правила:

  • ABC — маркер «это базовый контракт»; без него @abstractmethod работает только «на совет» (в Python ≥ 3.12 abc без ABC всё равно ругается на незаполненные абстракты);
  • @abstractmethod не имеет тела с логикой — только сигнатура (но может содержать docstring и raise NotImplementedError);
  • наследник обязан переопределить каждый абстрактный метод;
  • класс может быть «частично» абстрактным: унаследовался, реализовал часть — остаётся абстрактным.

Контракт + общая логика ​

Абстрактный класс — не «пустая оболочка»: он держит общую реализацию и «необязательные» методы рядом с обязательными:

python
from abc import ABC, abstractmethod


class Repository(ABC):
    def __init__(self, connection):
        self.connection = connection

    def save(self, obj):
        self._validate(obj)
        self.insert(obj)

    def _validate(self, obj):
        if not hasattr(obj, 'id'):
            raise ValueError('object must have .id')

    @abstractmethod
    def insert(self, obj):
        ...

    def find_by_id(self, obj_id):
        for row in self.all():
            if row.id == obj_id:
                return row
        return None

    @abstractmethod
    def all(self):
        ...


class InMemoryRepository(Repository):
    def __init__(self, connection=None):
        super().__init__(connection)
        self._rows = []

    def insert(self, obj):
        self._rows.append(obj)
        return obj

    def all(self):
        return list(self._rows)

Клиент кода «пишет» под Repository, не зная про InMemory/Sql/Redis — это и есть полиморфизм, зафиксированный контрактом.

Когда ABC, когда «обычный» класс ​

ЗадачаПодход
«Интерфейс» с обязательными методамиABC + @abstractmethod
Общие миксины без контрактаобычный класс + кооперация методов
«Проверка, что у объекта есть метод X» (Duck typing)hasattr / Protocol (typing)
Фреймворк/публичная библиотека, где контракт — часть APIABC — явная гарантия

typing.Protocol — структурная проверка (без наследования), ABC — именованный контракт (через isinstance). Они дополняют, а не заменяют друг друга.

Абстрактные Базовые Классы (ABC) ​

При проектировании крупных программных систем и фреймворков архитектору важно контролировать код, который будут писать другие разработчики. Представьте, что вы создаете единую систему управления доставкой, в которой будут разные виды почтовых коробок (StandardBox, ExpressBox, ColdStorageBox). Все они должны иметь метод расчета стоимости calculate_delivery_cost().

Если один из программистов забудет написать этот метод в своем подклассе или случайно назовет его get_cost(), вся автоматическая система сортировки на складе сломается. Чтобы защитить архитектуру приложения от подобных ошибок, в Python используются Абстрактные Базовые Классы (ABC).

На этом уроке мы разберем, как создавать жесткие архитектурные контракты, почему нельзя создавать экземпляры абстрактных классов и как декоратор @abstractmethod контролирует разработчиков подсемейств нашей Почтовой Коробки.

1. Концепция ABC и декоратор @abstractmethod ​

Что такое Абстрактный Класс?

Абстрактный класс — это класс-шаблон, который содержит общее описание интерфейса, но не предназначен для создания самостоятельных объектов. Его единственная цель — быть родителем для других подклассов и гарантировать, что они реализуют строго определенный набор методов.

В Python абстрактные классы создаются путем наследования от специального класса ABC из встроенного модуля abc. На методы, переопределение которых строго обязательно для всех будущих наследников, вешается декоратор @abstractmethod.

  • Если класс унаследован от ABC и в нем есть хотя бы один @abstractmethod, Python заблокирует возможность создать объект этого класса напрямую: вызов BaseParcel() выбросит ошибку TypeError.
  • Если подкласс унаследует этот шаблон, но разработчик «забудет» написать реализацию для абстрактного метода, Python заблокирует создание объекта подкласса на этапе выполнения программы.

2. Реализация Абстрактного Шаблона для Почтовой Коробки ​

Давайте спроектируем строгий базовый контракт для всех типов отправлений на нашем складе.

python
from abc import ABC, abstractmethod

class BaseParcel(ABC):
    """Абстрактный базовый класс (архитектурный контракт) для всех посылок."""

    def __init__(self, tracking_number: str, weight: float) -> None:
        self.tracking_number: str = tracking_number
        self.weight: float = weight

    @abstractmethod
    def calculate_shipping_price(self) -> float:
        """Абстрактный метод: рассчитывает стоимость доставки посылки.
        
        Каждый дочерний класс ОБЯЗАН переопределить этот метод под свою логику.
        """
        pass


class StandardParcel(BaseParcel):
    """Реальный подкласс: Обычная посылка."""
    
    # Успешно выполняем контракт архитектора — переопределяем метод
    def calculate_shipping_price(self) -> float:
        # Базовая цена: 5 рублей за килограмм веса
        return self.weight * 5.0


class HeavyCargoParcel(BaseParcel):
    """Реальный подкласс: Тяжелый крупногабаритный груз."""
    
    # Успешно выполняем контракт — переопределяем метод под свои спецтарифы
    def calculate_shipping_price(self) -> float:
        # Повышенный тариф + фиксированная пошлина за крупногабарит
        return (self.weight * 12.0) + 50.0


# === Тестирование архитектурной защиты ABC ===
if __name__ == "__main__":
    # 1. Попытка создать объект от самого абстрактного класса (Заблокировано!)
    try:
        abstract_box = BaseParcel("RU-000", 1.0)
    except TypeError as e:
        print(f"[ЗАЩИТА ABC] Нельзя создать объект абстрактного класса: {e}")
        # Выведет: TypeError: Can't instantiate abstract class BaseParcel...

    # 2. Создаем объекты корректных подклассов (Разрешено!)
    p1 = StandardParcel("RU-100", 2.5)
    p2 = HeavyCargoParcel("RU-555", 60.0)

    print(f"\nСтоимость доставки обычной посылки: {p1.calculate_shipping_price()} руб.")
    print(f"Стоимость доставки тяжелого груза: {p2.calculate_shipping_price()} руб.")

Чек-лист готовности ​

Перед тем как перейти к выполнению практических упражнений, убедитесь, что вы:

  • [ ] Помните: чтобы сделать класс абстрактным, его нужно наследовать от встроенного класса from abc import ABC.
  • [ ] Твердо усвоили: декоратор @abstractmethod ставится только над описанием (сигнатурой) метода, а тело самого метода в абстрактном классе обычно оставляют пустым через ключевое слово pass.
  • [ ] Понимаете, что абстрактный класс может содержать и обычные, уже готовые методы (например, конструктор __init__), которые будут автоматически унаследованы всеми дочерними подклассами.

Проверьте себя ​

❓Что такое абстрактный класс (ABC)?
❓Как создать абстрактный класс в Python?
❓Что случится при попытке создать объект класса, который не реализовал абстрактный метод?
❓Может ли абстрактный класс содержать обычные (уже готовые) методы?
❓Дочерний класс реализовал ЧАСТЬ абстрактных методов — он уже конкретный?
❓Когда выбирать ABC, а не обычный класс?

Упражнения: ​

  1. Создайте Payment(ABC) с @abstractmethod charge(amount) и refund(tx); убедитесь, что Payment() нельзя создать.
  2. Реализуйте CashPayment и CardPayment, переназначьте charge под каждый; проверьте isinstance(obj, Payment).
  3. Добавьте в Repository метод count() (не абстрактный), который использует all(); убедитесь, что InMemoryRepository работает без доработки.
  4. Объясните разницу между ABC и typing.Protocol на примере «объект с методом close()».

Практические упражнения для Production-кода ​

Выполните эти 5 практических заданий, чтобы научиться проектировать жесткие и отказоустойчивые программные интерфейсы, контролировать код в командах разработки и использовать возможности модуля abc.

Упражнение 1: Абстрактный контракт Римского Числа (AbstractRomanTransformer) ​

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

Задание:

  1. Создайте абстрактный класс AbstractRomanConverter(ABC).
  2. Объявите в нем один абстрактный метод to_arabic(self, roman_str: str) -> int, пометив его декоратором @abstractmethod.
  3. Создайте реальный подкласс SimpleRomanConverter, успешно реализуйте в нем этот метод (внутри тела метода можно просто вернуть заглушку return 5).
  4. Попробуйте запустить код. Проверьте в консоли, что создание объекта SimpleRomanConverter проходит успешно.

Упражнение 2: Поиск ошибки нарушенного контракта (BrokenContractError) ​

Давайте наглядно увидим, как Python защищает архитектуру проекта, если рядовой разработчик невнимательно прочитал ТЗ и забыл переопределить обязательный метод абстрактного класса-родителя.

Задание: Перед вами код структуры для управления курьерами, написанный с ошибкой. Скопируйте его в файл и запустите.

python
from abc import ABC, abstractmethod

class BaseCourier(ABC):
    @abstractmethod
    def take_order(self, order_id: int) -> None:
        pass

class BikeCourier(BaseCourier):
    # Ошибка разработчика: он случайно назвал метод по-своему!
    def accept_delivery(self, order_id: int) -> None:
        print(f"Курьер на велосипеде принял заказ {order_id}")
  1. Попытайтесь создать объект: courier = BikeCourier().
  2. Посмотрите на ошибку TypeError, которую выбросит Python. Объясните её смысл.
  3. Исправьте код класса BikeCourier, чтобы контракт абстрактного родителя выполнился успешно и объект смог создаться в памяти.

Упражнение 3: Абстрактный класс Хранилища Склада (AbstractWarehouseStorage) ​

Нам нужно спроектировать единый интерфейс для всех типов складских зон (зона штучного хранения, зона паллетного хранения, сейфовая зона). Все они обязаны поддерживать две операции: резервирование места и освобождение места.

Задание:

  1. Создайте абстрактный базовый класс AbstractStorage(ABC).
  2. Объявите два абстрактных метода: reserve_space(self, weight: float) -> bool и release_space(self, weight: float) -> None.
  3. Создайте реальный подкласс SafeZoneStorage. Реализуйте в нем оба метода.
  4. Убедитесь, что класс успешно проходит проверку интерпретатора и позволяет создавать экземпляры.

Упражнение 4: Абстрактные свойства через комбинацию декораторов (AbstractProperty) ​

В Python абстрактными можно делать не только обычные методы, но и свойства, созданные через @property. Это обязывает дочерние подклассы в обязательном порядке создавать у себя конкретные геттеры (или геттеры+сеттеры) для свойств.

Задание: Создайте абстрактный класс BaseOrder(ABC):

  1. Объявите абстрактное свойство стоимости, скомбинировав декораторы (в современном Python @abstractmethod пишется строго под @property):
python
@property
@abstractmethod
def final_cost(self) -> float:
    pass
  1. Создайте дочерний класс ExpressOrder. Реализуйте в нем конкретное свойство @property def final_cost(self), возвращающее фиксированное число 250.0.
  2. Проверьте, что без переопределения свойства дочерний класс не сможет создать объект.

Упражнение 5: Проверка подклассов через issubclass и isinstance (ABCTypeChecking) ​

Важным преимуществом использования модуля abc является то, что встроенные функции проверки типов в Python (isinstance и issubclass) начинают работать на уровне единого абстрактного интерфейса, обеспечивая полиморфизм.

Задание: Используйте абстрактный класс BaseParcel и его подклассы StandardParcel и HeavyCargoParcel из теоретической части урока (Блок 1).

  1. Создайте объект p = StandardParcel("RU-100", 2.0).
  2. Выведите в консоль результат проверки: isinstance(p, BaseParcel). Убедитесь, что Python возвращает True, понимая, что любая конкретная посылка является наследником общего абстрактного контракта.
  3. Выведите результат проверки: issubclass(HeavyCargoParcel, BaseParcel).
  4. Напишите функцию process_any_parcel(parcel: BaseParcel), которая принимает любой объект, проверяет его через isinstance(parcel, BaseParcel) и, если проверка пройдена, вызывает у него метод расчетов parcel.calculate_shipping_price(). Протестируйте её работу на разных типах посылок.

Решения для самопроверки ​

Посмотреть решение Упражнения 1 (AbstractRomanTransformer)
python
from abc import ABC, abstractmethod

class AbstractRomanConverter(ABC):
    @abstractmethod
    def to_arabic(self, roman_str: str) -> int:
        pass

class SimpleRomanConverter(AbstractRomanConverter):
    def to_arabic(self, roman_str: str) -> int:
        return 5
Посмотреть решение Упражнения 2 (Исправление ошибки BikeCourier)
python
from abc import ABC, abstractmethod

class BaseCourier(ABC):
    @abstractmethod
    def take_order(self, order_id: int) -> None:
        pass

class BikeCourier(BaseCourier):
    # Исправление: переименовываем метод в строгое соответствие с контрактом родителя
    def take_order(self, order_id: int) -> None:
        print(f"Курьер на велосипеде принял заказ {order_id}")
Посмотреть решение Упражнения 3 (AbstractWarehouseStorage)
python
from abc import ABC, abstractmethod

class AbstractStorage(ABC):
    @abstractmethod
    def reserve_space(self, weight: float) -> bool:
        pass

    @abstractmethod
    def release_space(self, weight: float) -> None:
        pass

class SafeZoneStorage(AbstractStorage):
    def reserve_space(self, weight: float) -> bool:
        print(f"В сейфе забронировано место под {weight} кг.")
        return True

    def release_space(self, weight: float) -> None:
        print(f"Из сейфа извлечено {weight} кг.")
Посмотреть решение Упражнения 4 (AbstractProperty)
python
from abc import ABC, abstractmethod

class BaseOrder(ABC):
    @property
    @abstractmethod
    def final_cost(self) -> float:
        pass

class ExpressOrder(BaseOrder):
    @property
    def final_cost(self) -> float:
        return 250.0
Посмотреть решение Упражнения 5 (ABCTypeChecking и Полиморфизм)
python
# Предполагается, что классы BaseParcel, StandardParcel, HeavyCargoParcel импортированы из Блока 1

def process_any_parcel(parcel: BaseParcel) -> None:
    # Защитная проверка на полиморфизм интерфейса
    if not isinstance(parcel, BaseParcel):
        raise TypeError("Переданный объект не соответствует контракту BaseParcel!")
    
    price = parcel.calculate_shipping_price()
    print(f"[КОНВЕЙЕР] Посылка {parcel.tracking_number} обработана. Стоимость: {price} руб.")

Упражнения ​

  1. Создайте интерфейс BaseNotificationService(ABC) с методом send(user_id, message); убедитесь, что его экземпляр нельзя создать.
  2. Реализуйте TelegramService, сохранив сигнатуру типов; проверьте, как IDE подсказывает документацию при реализации.
  3. Добавьте в интерфейс авторизации BaseAuthService готовый шаблонный метод login(), вызывающий абстрактную скрытую проверку.
  4. Исправьте ошибку джуниора в подклассе облачного хранилища, где нарушены типы данных и потерян вызов super().

Практические упражнения для Production-кода ​

Выполните эти 5 практических заданий, чтобы научиться проектировать чистые корпоративные интерфейсы (ТЗ в коде), контролировать типы данных с помощью линтеров и защищать бизнес-логику от случайного изменения сигнатур методов в командах разработки.

Упражнение 1: Интерфейс Уведомлений (BaseNotificationService) ​

В промышленной разработке каналы связи (SMS, Email, Telegram) постоянно меняются или добавляются. Задача архитектора — зафиксировать единый формат взаимодействия, чтобы остальной код приложения не зависел от деталей реализации конкретного мессенджера.

Задание:

  1. Создайте абстрактный класс BaseNotificationService(ABC).
  2. В充онструкторе __init__ он должен принимать и сохранять sender_name: str (имя отправителя/название сервиса).
  3. Объявите абстрактный метод send(self, user_id: int, message: str) -> bool. Обязательно добавьте к нему docstring с описанием типов и ожидаемого поведения. Метод должен возвращать True при успешной отправке.
  4. Создайте реальный подкласс TelegramNotificationService. Реализуйте метод send, чтобы он выводил в консоль сообщение: "[Telegram от {sender_name}] Отправлено пользователю {user_id}: {message}" и возвращал True.
  5. Попробуйте создать экземпляр класса BaseNotificationService напрямую и убедитесь, что Python блокирует это действие с ошибкой TypeError.

Упражнение 2: Шаблонный метод для сервиса авторизации (BaseAuthService) ​

Интерфейс — это не всегда «пустая оболочка». Часто архитектор пишет внутри интерфейса общую бизнес-логику (например, предварительную валидацию), а детальную проверку оставляет дочерним классам. Это паттерн «Шаблонный метод».

Задание:

  1. Создайте абстрактный класс BaseAuthService(ABC).
  2. Напишите в нем готовый (не абстрактный) метод login(self, username: str, password: str) -> bool.
  3. Внутри метода login добавьте базовую проверку: если длина username меньше 4 символов или password меньше 6 символов, метод должен сразу возвращать False, не нагружая базу данных.
  4. Если валидация пройдена, метод login должен вызвать абстрактный внутренний метод self._verify_credentials(username, password).
  5. Объявите метод _verify_credentials как абстрактный.
  6. Напишите реальный класс InMemoryAuthService. Реализуйте в нем проверку: метод должен возвращать True, только если username == "admin" and password == "secret123".

Упражнение 3: Поиск ошибки нарушенного контракта (CloudStorageCodeReview) ​

Проведите Code Review кода джуниор-разработчика. Он попытался написать интеграцию Яндекс.Диска на основе абстрактного класса архитектора, но допустил несколько грубых ошибок, которые сломают приложение в продакшене.

Задание: Перед вами код структуры для работы с облачными хранилищами, написанный с ошибками. Скопируйте его в файл.

python
from abc import ABC, abstractmethod


class BaseCloudStorage(ABC):
    """Интерфейс для работы с облачными хранилищами картинок."""

    def __init__(self, bucket_name: str) -> None:
        self.bucket_name = bucket_name

    @abstractmethod
    def upload_file(self, file_name: str, data: bytes) -> str:
        """Загружает файл в облако и возвращает публичную ссылку (str)."""
        pass


# --- Код джуниора, который нужно исправить ---
class YandexDiskStorage(BaseCloudStorage):

    def __init__(self, bucket_name: str, token: str):
        self.token = token

    def upload_file(self, file_name: str) -> str:
        print(f"Файл {file_name} отправлен на Яндекс.Диск с токеном {self.token}")
        return 200  # Код ответа сервера
  1. Найдите 3 критические ошибки в классе YandexDiskStorage (подсказка: обратите внимание на вызов super(), состав аргументов метода upload_file и тип возвращаемого значения).
  2. Напишите исправленный вариант класса YandexDiskStorage, который полностью удовлетворяет контракту архитектора.

Упражнение 4: Проектирование Системы Кэширования (BaseCacheInterface) ​

Спроектируйте с нуля интерфейс для систем кэширования данных (BaseCacheInterface), который будет использоваться во всем вашем Enterprise-приложении для ускорения работы с БД.

Задание:

  1. Создайте абстрактный класс BaseCacheInterface(ABC).
  2. Интерфейс должен требовать обязательную реализацию трех методов со строгими аннотациями типов:
    • set_value(self, key: str, value: str, ttl_seconds: int) -> None (сохранить ключ на определенное время).
    • get_value(self, key: str) -> str | None (получить значение или вернуть None, если ключа нет).
    • clear_cache(self) -> None (полностью очистить хранилище).
  3. Напишите полную документацию (docstrings) для каждого абстрактного метода.
  4. Реализуйте простейший подкласс LocalMemoryCache, хранящий данные внутри обычного словаря Python self._storage = {} (реализовывать логику времени ttl_seconds в коде словаря необязательно, достаточно просто принять этот аргумент).

Упражнение 5: Контракт со сложными структурами данных (DTODeliveryContract) ​

Бизнес-интерфейсы редко работают с простыми строками или числами. Чаще всего в качестве аргументов передаются специальные объекты данных — DTO (Data Transfer Object). Напишите контракт, жестко завязанный на кастомный класс.

Задание:

  1. Создайте простой класс данных (можно использовать @dataclass):
python
from dataclasses import dataclass

@dataclass
class DeliveryManifest:
    tracking_number: str
    weight: float
  1. Создайте абстрактный класс BaseDeliveryProvider(ABC).
  2. Объявите абстрактный метод register_manifest(self, manifest: DeliveryManifest) -> str. Обратите внимание, что тип входящего аргумента — это созданный выше класс DeliveryManifest.
  3. Реализуйте подкласс CdekProvider. Внутри метода выведите вес посылки, обратившись к атрибуту переданного манифеста: manifest.weight, и верните строку "CDEK-OK".
  4. Напишите тестирующую функцию, которая создает манифест, передает его в провайдер и проверяет корректность типов.

Решения для самопроверки ​

Посмотреть решение Упражнения 1 (BaseNotificationService)
python
from abc import ABC, abstractmethod

class BaseNotificationService(ABC):
    def __init__(self, sender_name: str) -> None:
        self.sender_name = sender_name

    @abstractmethod
    def send(self, user_id: int, message: str) -> bool:
        """Отправляет уведомление пользователю.
        
        :param user_id: Уникальный ID пользователя.
        :param message: Текст сообщения.
        :return: True, если отправлено успешно, иначе False.
        """
        pass

class TelegramNotificationService(BaseNotificationService):
    def send(self, user_id: int, message: str) -> bool:
        print(f"[Telegram от {self.sender_name}] Отправлено пользователю {user_id}: {message}")
        return True
Посмотреть решение Упражнения 2 (BaseAuthService)
python
from abc import ABC, abstractmethod

class BaseAuthService(ABC):
    def login(self, username: str, password: str) -> bool:
        # Общая шаблонная валидация для всех подклассов
        if len(username) < 4 or len(password) < 6:
            print("[ВАЛИДАЦИЯ] Слишком короткий логин или пароль!")
            return False
        # Вызов скрытого абстрактного контракта
        return self._verify_credentials(username, password)

    @abstractmethod
    def _verify_credentials(self, username: str, password: str) -> bool:
        pass

class InMemoryAuthService(BaseAuthService):
    def _verify_credentials(self, username: str, password: str) -> bool:
        return username == "admin" and password == "secret123"
Посмотреть решение Упражнения 3 (Исправление CloudStorageCodeReview)
python
# Ошибки джуниора:
# 1. Потерян вызов super().__init__, из-за чего сотрется self.bucket_name.
# 2. Из сигнатуры метода upload_file пропал обязательный аргумент data: bytes.
# 3. Метод возвращает int (200) вместо обязательной по контракту строки str.

class YandexDiskStorage(BaseCloudStorage):
    def __init__(self, bucket_name: str, token: str):
        super().__init__(bucket_name)  # Исправлено: вызываем родительский конструктор
        self.token = token

    def upload_file(self, file_name: str, data: bytes) -> str:  # Исправлено: добавлен аргумент data
        print(f"Файл {file_name} ({len(data)} байт) отправлен на Яндекс.Диск")
        return f"https://yandex.disk{self.bucket_name}/{file_name}"  # Исправлено: возвращаем str
Посмотреть решение Упражнения 4 (BaseCacheInterface)
python
from abc import ABC, abstractmethod

class BaseCacheInterface(ABC):
    @abstractmethod
    def set_value(self, key: str, value: str, ttl_seconds: int) -> None:
        """Сохраняет значение по ключу с ограничением по времени."""
        pass

    @abstractmethod
    def get_value(self, key: str) -> str | None:
        """Возвращает значение или None, если ключ не найден/устарел."""
        pass

    @abstractmethod
    def clear_cache(self) -> None:
        """Полностью очищает кэш."""
        pass

class LocalMemoryCache(BaseCacheInterface):
    def __init__(self) -> None:
        self._storage: dict[str, str] = {}

    def set_value(self, key: str, value: str, ttl_seconds: int) -> None:
        self._storage[key] = value

    def get_value(self, key: str) -> str | None:
        return self._storage.get(key)

    def clear_cache(self) -> None:
        self._storage.clear()
Посмотреть решение Упражнения 5 (DTODeliveryContract)
python
from abc import ABC, abstractmethod
from dataclasses import dataclass

@dataclass
class DeliveryManifest:
    tracking_number: str
    weight: float

class BaseDeliveryProvider(ABC):
    @abstractmethod
    def register_manifest(self, manifest: DeliveryManifest) -> str:
        pass

class CdekProvider(BaseDeliveryProvider):
    def register_manifest(self, manifest: DeliveryManifest) -> str:
        print(f"[CDEK] Оформляем манифест. Вес груза: {manifest.weight} кг.")
        return "CDEK-OK"

# Тестирование контракта:
manifest = DeliveryManifest(tracking_number="RU-777", weight=12.4)
provider = CdekProvider()
result = provider.register_manifest(manifest)