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

В материале можно посмотреть, как изящно связать свойства  и абстрактные классы с реализацией принципа DRY .

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

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

Абстрактные методы - методы с декоратором @abstractmethod, которые обязаны быть реализованы в дочерних классах.

Абстрактный класс может содержать как обычные, так и абстрактные методы.

Свойство - реализуется через декораторы @property (для чтения) и @<name>.setter (для изменения и валидации) обеспечивая инкапсуляцию, делая API удобным, при этом позволяя менять внутреннюю реализацию без изменения внешнего кода.

Сервис уведомлений.

Давайте представим  что мы разрабатываем маленький сервис уведомлений, который отправляет сообщения по двум каналам: email и sms.

В самом начале наш код может выглядеть так:

class Notification(ABC):

    def __init__(self, message):
        self.message  = message

    @abstractmethod
    def send_message(self):
        pass


class EmailNotification(Notification):

    def __init__(self, message, email):
        super().__init__(message)
        self.email = email

    def send_message(self):
        print(f"Отправка Email на {self.email} с cообщения {self.message }")


class SMSNotification(Notification):
	
    def __init__(self, message, phone_number): 
        super().__init__(message)
        self.phone_number = phone_number

   def send_message(self):
        print(f"Отправка SMS на номер {self.phone_number}: {self.message} ")

Здесь мы видим, что в абстрактном классе присутствует  метод __init__ однако мы помним, что нельзя создать экземпляр абстрактного класса, и отсюда возникает вопрос: можем ли мы определять в абстрактном классе метод __init__ для выноски в него общего атрибута message? Ответ - да. И это будет хорошей практикой. Это позволяет избежать дублирования кода: вместо того чтобы инициализировать одни и те же поля в каждом дочернем классе, мы делаем это один раз в родителе. Пояснить этот момент будет скорее полезно начинающим программистам, ибо он может сбить с толку.

Требование к сервису.

Теперь в нашей бизнес-задаче стоит требование: через сервис sms уведомлений отправлять сообщение длиной не более 100 символов, однако на сервис отправки уведомлений по email такого ограничения нет, и при этом в наших двух сервисах сообщение обязательно должно быть строкой (str) и строка не должна быть пустой.

Реализация.

Из требований выше можно сделать вывод, что для реализации атрибут message необходимо сделать управляемым, для этого нам необходимо использовать декоратор @property, который обеспечивает интерфейс для атрибутов экземпляра класса и разрешает к нему доступ только через определенные методы. Естественно, в нашем случае это будет валидация, то есть предварительная проверка перед присвоением значения.

Подводный камень.

Здесь предлагаю начать с конца, так как это будет проще. Реализуем абстрактный класс Notification.

Наш исправленный код будет выглядеть так:

class Notification(ABC):

    def __init__(self, message):
        self.message  = message

    @property
    def message(self):
        return self._message

    @message.setter
    def message (self, value):
        if not value:
            raise ValueError("Message cannot be empty")
        if not isinstance(value, str):
            raise TypeError("Message must be type str")
        self._message = value

    @abstractmethod
    def send_message(self):
        pass

Некоторые читатели могут заметить странность в коде, почему в __init__  идет присвоение self.message  = message без нижнего подчеркивания,  однако в @property мы возвращаем self._message с нижним подчеркиванием.

Ведь типичный пример с @property выглядит так:

class Person:
    def __init__(self, name):
        self._name = name  # Используем _ для обозначения "приватного" атрибута

    @property
    def name(self):
        print("Get name...")
        return self._name

    @name.setter
    def name(self, value):
        if not isinstance(value, str):
            raise TypeError("Name must be type str")
        self._name = value

Это будет ясно ниже, когда мы начнем реализовывать требование на ограничение sms. В таких моментах очень важно не использовать конструктор при создании экземпляра класса, если мы используем управляемые атрибуты и  @property. Однако в классах наследниках мы используем конструктор. Мы вынуждены это делать. И здесь может нарушится наше бизнес-требование.

Давайте посмотрим на этот подводный камень более внимательно. Для этого сделаем небольшое отступление. Итак, сейчас возьмем наш типичный пример класса Person и создадим его экземпляр.

>>> person = Person(“Ivan”)
>>> person.name
Ivan
>>> person.name = “Alex”
>>> person.name 
Alex

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

>>> person = Person(3)
>>> person.name
3

Цифра 3 не может быть именем экземпляра Person, тем не менее мы видим, что объект создан. А это значит, что класс Person должен иметь следующий вид:

class Person:
    def __init__(self, name=None):
        self._name = name  # Используем _ для обозначения "приватного" атрибута

    @property
    def name(self):
        print("Get name...")
        return self._name

    @name.setter
    def name(self, value):
        if not isinstance(value, str):
            raise TypeError("Name must be type str")
        self._name = value

Экземпляр класса правильно создавать таким образом при использовании @property:

>>> person = Person()
>>> person.name = “Alex”

И присваивать атрибут name только после создания объекта. Здесь наглядно показывается правило “доступ только через разрешенный метод”.

Но что нам делать, ведь у нас используется __init__:

class EmailNotification(Notification):

    def __init__(self, message, email):
        super().__init__(message)
        self.email = email

    def send_message(self):
        print(f"Отправка на {self.email} cообщения: {self.message }")

И соответственно, если мы последуем хрестоматийный примеру:

class Notification(ABC):

    def __init__(self, message):
        self._message  = message

    @property
    def message(self):
        return self._message

    @message.setter
    def message (self, value):
        if not value:
            raise ValueError("Message cannot be empty")
        if not isinstance(value, str):
            raise TypeError("Message must be type str")
        self._message = value

    @abstractmethod
    def send_message(self):
        pass

и напишем в конструкторе self._message  = message, то наш setter просто не сработает, и мы сможем передать в сообщение пустую строку или числовой тип, а это нарушает одно из требований.

Чтобы это исправить, нам необходимо вызвать setter прямо в конструкторе.

Таким образом, наш конструктор абстрактного класса будет иметь вид:

class Notification(ABC):

    def __init__(self, message):
        self._message = self.message = message

Код выглядит избыточным, однако я показываю это специально для очевидности цепочки вызовов: сообщение -> вызов message.setter -> валидация -> присвоение.

Теперь сделаем как в начале, просто уберем избыточный self._message.

class Notification(ABC):

    def __init__(self, message):
        self.message  = message

    @property
    def message(self):
        return self._message

    @message.setter
    def message (self, value):
        if not value:
            raise ValueError("Message cannot be empty")
        if not isinstance(value, str):
            raise TypeError("Message must be type str")
        self._message = value

    @abstractmethod
    def send_message(self):
        pass

Условно приватный атрибут будет существовать, однако доступ к нему в конструкторе будет дан через @setter.

Принцип DRY.

Для реализации одного из главных принципов разработки Don't Repeat Yourself (не повторяйся) или сокращенно DRY предлагаю воспользоваться переопределением сеттера в родителе.

Для этого воспользуемся изящным приемом, который нам предоставляет python.

class SMSNotification(Notification):

    def __init__(self, message, phone_number): 
        super().__init__(message)
        self.phone_number = phone_number

    @Notification.message.setter               # Переопределяем сеттер родителя
    def message(self, value):
        Notification.message.fset(self, value) # Выполняем базовую проверку в родителе
        if len(value) > 100:
            raise ValueError("Ошибка: Текст SMS слишком длинный (макс. 100)!")
        self._message = value

    def send_message(self):
        print(f"Отправка SMS на номер {self.phone_number}: {self.message} ")


class EmailNotification(Notification):

    def __init__(self, message, email):
        super().__init__(message)
        self.email = email

    def send_message(self):
        print(f"Отправка Email на {self.email} с cообщения {self.message }")

Как видно из кода выше, мы добавили @Notification.message.setter к методу присваивания значения к атрибуту _message. С помощью функции fset мы извлекли из этого свойства ту самую функцию, которую определили в родителе как валидатор и вызвали ее, чтобы базовый класс сделал свою часть работы. Теперь класс, реализующий сервис sms-уведомлений, имеет ограничение на длину сообщения, однако класс email-уведомлений такого ограничения не имеет. При этом в двух классах будет проверка типа и проверка на пустую строку. Что и требовалось.

Благодаря такой конструкции нам не нужно заново писать проверки if not isinstance(value, str), которые уже есть в Notification.

Это можно увидеть на тесте:

if __name__ == "__main__":
    print("\n--- ТЕСТ 1: Проверка __init__ ---")
    try:
        # Создаем SMS длиннее 100 символов
        long_text = "Это очень длинное сообщение, которое должно вызвать ошибку, " * 5
        print(f"Длина текста: {len(long_text)} символов.")

        bad_sms = SMSNotification(message =long_text, phone_number="+79911234567")

        print("Результат: Объект создан (К сожалению, проверка в __init__ не сработала ❌)")
        print(f"Содержимое в памяти: {bad_sms._message[:50]}...")

    except ValueError as e:
        print(f"Результат: Ошибка поймана! ✅ ({e})")

    print("\n--- ТЕСТ 2: Проверка валидации при изменении (setter) ---")
    try:
        # Создаем нормальное SMS
        ok_sms = SMSNotification(message ="Привет!", phone_number="+79911234567")

        # Пытаемся изменить его на слишком длинное через свойство .message
        print("Пытаемся изменить текст через ok_sms.message = ...")
        ok_sms.message = "А" * 151

    except ValueError as e:
        print(f"Результат: Ошибка поймана сеттером! ✅ ({e})")
    print("\n--- ТЕСТ 3: Проверка валидации при изменении (setter) ---")
    try:
        print("Пытаемся передать ok_email.message = [1, 2, 3]")
        ok_email = EmailNotification(message=[1, 2, 3], email='asdfsd2343245534vsdfsd@bk.com')
    except (ValueError, TypeError) as e:
        print(f"Результат: Ошибка поймана сеттером! ✅ ({e})")
    print("\n--- ТЕСТ 4: Проверка валидации при изменении (setter) ---")
    try:
        print("Пытаемся передать ok_sms.message = [1, 2, 3]")
        ok_email = SMSNotification(message=[1, 2, 3], phone_number="+79911234567")
    except (ValueError, TypeError) as e:
        print(f"Результат: Ошибка поймана сеттером! ✅ ({e})")

Лог теста покажет нам следующее:

--- ТЕСТ 1: Проверка __init__ ---
Длина текста: 300 символов.
Результат: Ошибка поймана! ✅ (Ошибка: Текст SMS слишком длинный (макс. 100)!)

--- ТЕСТ 2: Проверка валидации при изменении (setter) ---
Пытаемся изменить текст через ok_sms.message = ...
Результат: Ошибка поймана сеттером! ✅ (Ошибка: Текст SMS слишком длинный (макс. 100)!)

--- ТЕСТ 3: Проверка валидации при изменении (setter) ---
Пытаемся передать ok_email.message = [1, 2, 3]
Результат: Ошибка поймана сеттером! ✅ (Message must be type str)

--- ТЕСТ 4: Проверка валидации при изменении (setter) ---
Пытаемся передать ok_sms.message = [1, 2, 3]
Результат: Ошибка поймана сеттером! ✅ (Message must be type str)

Полный код примера можно посмотреть здесь.

Ради интереса предлагаю читателю самостоятельно посмотреть, что будет, если в конструкторе класса Notification  написать self._message = message.

Заключение

В данной публикации хотелось поделиться своим опытом связывания управляемых атрибутов в абстрактных классах и реализации принципа DRY. Показать подводные камни, которые могут привести к неправильной работе кода программы.

Комментарии (14)


  1. A-V-tor
    22.02.2026 20:45

    Может хватит уже называть def init конструктором?


    1. WLMike
      22.02.2026 20:45

      А как надо назвать?


      1. A-V-tor
        22.02.2026 20:45

        Ну может быть так как он и называется? Инициализатор?
        Хоть мини статью делай про new и init и кто из них кто и что делает.


        1. WLMike
          22.02.2026 20:45

          Не вижу смысла в статье - есть документация. ИМХО это вкусовщина. Если глянуть на другие языки, то init гораздо больше похож на конструктор (нет явного возвращаемого значение и есть this/self), но функционал создания объектов размазан в питоне по куче методов и не только по этим двум


          1. A-V-tor
            22.02.2026 20:45

            По каким например? Именно же new возвращает экземпляр, почему init упорно называют конструктором некоторая часть разработчиков, если этот метод буквально навешивает (инициализирует) переменные на экземпляр класса, который уже создан и передан как первый аргумент (тот самый self - это уже готовый экземпляр) в метод?


            1. WLMike
              22.02.2026 20:45

              Еще раз посмотрите на С++, Java, C#, где понятие конструктора явно существует и что он делает


            1. ASurr Автор
              22.02.2026 20:45

              Ну что вы прям переживаете, так сложилось исторически :-)
              Если многие могут сразу и быстро понять про что речь, то почему бы и нет...

              Здесь скорее языковой момент: мы говорим "едем на машине", однако мы ведь тоже не на крыше едем, вроде правильнее сказать "в машине" :-)


        1. AndPronin
          22.02.2026 20:45

          Рамальо и Лутц вас опередили, и всё уже написали. "Python, к вершинам мастерства", 779 страница. И у Лутца во 2м томе где- то.
          Кстати и он и Лутц вполне называют init конструктором, хоть и оговорками. Думается, в данном случае инициализатор и конструктор могут быть синонимами.


  1. WLMike
    22.02.2026 20:45

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

    2. Кажется вы решаете не существующую проблему страшно сложными методами. Гораздо проще определить валидаторы отдельно и дергать их напрямую в нужных местах, а не продираться сквозь нижележащий слои абстракции, нарушая инкапсуляцию

    3. Ну и следствие этого. Вообще наследованное самая бесполезная штука в ООП а-ля Джава - ее не было у Алана Кэя и во многих более современных языках от нее успешно отказались. Собственно ваш пример показывает почему это частенько вредная штука


    1. ASurr Автор
      22.02.2026 20:45

      С конца наверное пойду:

      по п.3 не соглашусь, и даже не особо вникая в глубины программирования, можно сделать вывод: если наследование самая бесполезная штука в ООП, от нее бы отказались в принципе. Я активно использую наследование в разработке, и многие тоже. Наследование это управления повторным использованием кода.
      по п.2 хм...ну мысль тоже интересная..., однако плюс реализации через ABC, в том, что она гарантирует: валидация обязательно произойдет в строго определенный момент жизненного цикла объекта. Не вижу здесь нарушение инкапсуляции. Да и если определять валидаторы отдельно, их придется дергать в каждом классе, с другой стороны зачем их дергать если есть общая логика предварительной проверки. Например, вEmailNotification вообще нет необходимости прописывать валидацию.
      по п.1 Протоколы хороши для описания поведения, абстрактные классы необходимы, когда нужно передать общую реализацию или состояние. Если несколько классов не просто имеют одинаковый интерфейс, но и разделяют общую логику, ABC избавляет от дублирования.

      Если я делаю большой backend я предпочитаю протоколы, с ними легче реализовать чистую архитектуру. Однако если у меня маленький сервис, типа сервиса уведомлений, где разделяется общая реализация, я бы использовал ABC, .


      1. WLMike
        22.02.2026 20:45

        по п.3

        "от нее бы отказались в принципе" - и от нее оказались в Go, Rust...

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

        по п.2

        если вы используете протоколы и проверку типов, то вам прийдется написать соотвествующий метод. Где надо вы явно вызовите валидатор, а не будете полагаться на неявную реализацию и цепочку переопределения методов в иерархии наследованная. Явное лучше не явного. И EmailNotification вы просто его не вызовете или используете NoOps валидатор и будет понятно, что тут проверка не делается

        по п.1

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

        Но это все ИМХО - на вкус и цвет товарищей нет


        1. ASurr Автор
          22.02.2026 20:45

          Go для быстрого обмена json-ками.
          Если вы пользуетесь чистой архитектурой, то валидацию вы проводите на уровне презентации, а не на уровне приложения, в то время как я использую протокол для описания интерфейсов (т.е. поведения) на уровне приложения.
          В библиотеках да, но в таких сервисах тоже да (ИМХО). Если у меня количество каналов уведомлений может расширятся, думаю ABC вполне уместен, с ним как бы даже попроще будет чем с композицией.


  1. Stasya17
    22.02.2026 20:45

    Полезная и понятная статья, спасибо


  1. hardtop
    22.02.2026 20:45

    1. Протокол всё же как-то более питонячий подход, чем абстрактный класс.

    2. Пихать в абстрактный класс проверку выглядит контр-интуитивно.