Код, который вчера работал, сегодня ломается от одной правки в соседнем файле. Хотели поменять текст письма клиенту, а упал расчёт скидки. Знакомо каждому, кто писал программу дольше пары недель.
Принципы SOLID придумали ровно против этой беды. Это пять правил объектно-ориентированного программирования, которые помогают раскладывать код по классам так, чтобы правка в одном месте не тянула за собой десять других. Ниже разберём каждое правило на примере из жизни и на коротком коде на Python, покажем, как заметить нарушение, и разберём, в каких случаях SOLID только мешает.
Если вы видите SOLID впервые рядом с KISS, DRY и YAGNI, сначала загляните в наш обзор принципов программирования: там все четыре правила стоят рядом, и видно, где они друг с другом спорят.
Статья рассчитана на тех, кто уже знает, что такое класс и метод. Если эти слова пока звучат туманно, начните с материала про классы и объекты в Python и с разбора четырёх принципов ООП: SOLID стоит на них сверху.
Если хочется учиться с наставником и проверкой домашних заданий, посмотрите курсы по Python: в большинстве программ для начинающих SOLID разбирают в блоке про ООП.
SkillboxПрофессия «Python-разработчик»157 335 ₽10 месяцев
НетологияFullstack-разработчик на Python137 000 ₽21 месяц
GeekBrainsДО Профессия Python-разработчик149 001 ₽10 месяцев
SkillFactoryПрофессия Python-разработчик140 040 ₽10 месяцев
Академия СинергияPython-разработчик + ИИ77 900 ₽6 месяцев
ЭдюсонPython-разработчик89 919 ₽9 месяцев
Что такое SOLID и откуда он взялся

SOLID (по-русски часто пишут «солид») складывается из первых букв пяти английских названий. Каждое из них описывает одно правило проектирования классов. Если простыми словами, принципы SOLID в ООП подсказывают, какой класс за что отвечает и кто от кого зависит.
| Буква | Название | Смысл в одной фразе | Что ломается без него |
|---|---|---|---|
| S | Single Responsibility, принцип единственной ответственности | У класса одна причина меняться | Правка одной функции роняет другую |
| O | Open/Closed, принцип открытости и закрытости | Новое поведение добавляем новым кодом, старый не трогаем | Каждая новинка требует лезть в рабочий класс |
| L | Liskov Substitution, принцип подстановки Лисков | Наследник подставляется вместо родителя без сюрпризов | Программа ведёт себя странно на «правильных» объектах |
| I | Interface Segregation, принцип разделения интерфейсов | Маленькие интерфейсы под конкретную задачу | Классы реализуют методы, которые им не нужны |
| D | Dependency Inversion, принцип инверсии зависимостей | Важная логика зависит от абстракций, а детали подстраиваются | Нельзя заменить базу или почту, не переписав бизнес-логику |
Сами правила собрал американский программист Роберт Мартин, его в сообществе зовут Дядя Боб. В заметке о принципах объектного проектирования он пишет, что первые наброски опубликовал в марте 1995 года в группе обсуждений comp.object, а затем много раз возвращался к ним в книгах и статьях (заметка Мартина на butunclebob.com, на английском).
В той же заметке видно то, о чём обычно молчат: у Мартина правил одиннадцать. Первые пять относятся к проектированию классов, ещё шесть касаются пакетов, то есть крупных частей программы вроде библиотек. В народ ушли только первые пять, а аббревиатуру SOLID из их первых букв позже сложил коллега Мартина Майкл Фэзерс.
Главную мысль автор формулирует так: принципы нужны, чтобы управлять зависимостями между частями кода. Когда зависимости запутаны, код по его словам становится трудным для изменений, хрупким и непригодным для повторного использования. Звучит сухо, но за этим стоит бытовая проблема: страх трогать собственную программу.
Коротко. Программа работает и без SOLID. Принципы нужны для другого: чтобы через полгода её можно было менять без страха.
S: принцип единственной ответственности
В ранней формулировке Мартина звучит так: у класса должна быть одна и только одна причина для изменения. Через двадцать лет он уточнил, что под «причиной» имеются в виду люди. В статье 2014 года Мартин советует собирать вместе то, что меняется по одним и тем же причинам, и разделять то, что меняется по разным, а дальше прямо пишет, что причины изменений связаны с людьми: именно люди просят что-то поменять (статья Мартина о SRP, на английском).
Пример из жизни. Допустим, вы пишете скрипт для небольшого интернет-магазина, который считает выручку за день, превращает её в текст и сохраняет в файл. Первая версия обычно выглядит так:
class SalesReport:
def __init__(self, sales):
self.sales = sales
def total(self):
return sum(self.sales)
def to_text(self):
return f"Выручка: {self.total()} ₽"
def save(self, path):
with open(path, "w", encoding="utf-8") as f:
f.write(self.to_text())
Работает. Но у этого класса три заказчика. Бухгалтер попросит считать выручку без возвратов. Руководитель захочет отчёт в таблице вместо текста. Администратор сервера скажет, что файлы теперь надо класть в облако. Все трое придут менять один и тот же класс, и каждая правка рискует задеть чужую часть.
Решение: разнести обязанности по трём маленьким классам.
class SalesStats:
def __init__(self, sales):
self.sales = sales
def total(self):
return sum(self.sales)
class TextFormatter:
def format(self, stats):
return f"Выручка: {stats.total()} ₽"
class FileSaver:
def save(self, text, path):
with open(path, "w", encoding="utf-8") as f:
f.write(text)
stats = SalesStats([1200, 800, 500])
text = TextFormatter().format(stats)
FileSaver().save(text, "report.txt")
print(text) # Выручка: 2500 ₽
Теперь запрос бухгалтера трогает только SalesStats, а переезд в облако касается только FileSaver. Простая проверка на нарушение: опишите класс одним предложением. Если в описании появляется союз «и» («считает выручку и сохраняет файл»), обязанностей, скорее всего, больше одной. Как такие решения складываются в целую программу, мы разбирали в статье про архитектуру приложения.
O: принцип открытости и закрытости
Формулировка Мартина: модуль (отдельная часть программы, например класс или файл) должен быть открыт для расширения и закрыт для изменения. Проще говоря, новую возможность добавляем новым кодом, а проверенный и работающий код не переписываем.
Представьте функцию, которая считает цену со скидкой для разных покупателей:
def price_with_discount(price, customer_type):
if customer_type == "regular":
return price
elif customer_type == "student":
return price * 0.8
elif customer_type == "vip":
return price * 0.7
Маркетолог придумал скидку для пенсионеров, и вы снова открываете функцию, дописываете ветку elif и надеетесь ничего не задеть. Через год веток двадцать, и каждая правка требует перепроверять все остальные.
Решение: сделать каждую скидку отдельным классом с одинаковым методом apply.
class NoDiscount:
def apply(self, price):
return price
class StudentDiscount:
def apply(self, price):
return price * 0.8
def final_price(price, discount):
return discount.apply(price)
class PensionerDiscount: # новая скидка, старый код не тронут
def apply(self, price):
return price * 0.85
print(final_price(1000, StudentDiscount())) # 800.0
print(final_price(1000, PensionerDiscount())) # 850.0
Функция final_price больше не знает, какие скидки бывают. Ей важно только одно: у объекта есть метод apply. Такой приём держится на полиморфизме (способности разных объектов отвечать на один и тот же вызов по-своему), а в книгах по паттернам проектирования он называется «стратегия».
Признак нарушения легко увидеть глазами: длинная цепочка if/elif по типу объекта, которая растёт с каждой новой задачей.
L: принцип подстановки Лисков
Этот принцип назван в честь Барбары Лисков, профессора MIT и лауреата премии Тьюринга. В статье, написанной вместе с Жаннет Уинг и опубликованной в ноябре 1994 года, мысль звучит так: объекты подтипа должны вести себя так же, как объекты исходного типа, насколько это может заметить любой человек или программа, которые с ними работают (статья Лисков и Уинг, PDF, на английском).
По-простому: если ваш код умеет работать с родительским классом, он должен так же спокойно работать с любым наследником. Никаких сюрпризов.
Классический пример нарушения: квадрат, унаследованный от прямоугольника. С точки зрения геометрии квадрат и правда частный случай прямоугольника. С точки зрения кода всё хуже.
class Rectangle:
def __init__(self, width, height):
self.width = width
self.height = height
def set_width(self, width):
self.width = width
def set_height(self, height):
self.height = height
def area(self):
return self.width * self.height
class Square(Rectangle):
def __init__(self, side):
super().__init__(side, side)
def set_width(self, width):
self.width = width
self.height = width
def set_height(self, height):
self.width = height
self.height = height
def stretch(rect):
rect.set_width(5)
rect.set_height(10)
return rect.area()
print(stretch(Rectangle(2, 3))) # 50
print(stretch(Square(2))) # 100
Функция stretch рассчитывает на прямоугольник 5 на 10 и площадь 50. Квадрат тихо подменяет ширину и возвращает 100. Ошибки нет, программа не падает, просто считает неправильно. Именно такие баги ищут дольше всего.
Решение: не наследовать квадрат от прямоугольника. Наследование (когда класс берёт поля и методы родителя) мы подробно разбирали в статье о принципах ООП. Здесь важно одно: наследника выбирают по поведению, и похожее название ничего не гарантирует. Лучше сделать для них общего родителя «фигура» с методом area, а изменение размеров оставить каждому классу своё.
Та же история с птицами: если у класса «птица» есть метод «летать», пингвин в наследники не годится. Летающих и нелетающих птиц разводят по разным типам.
В статье 2020 года Мартин признаёт, что и сам когда-то ошибочно считал этот принцип правилом про наследование. По его словам, принцип про подтипы, то есть про любые реализации одного интерфейса, в том числе при утиной типизации (статья Мартина «Solid Relevance», на английском).
Как заметить нарушение. В коде появились проверки вида
isinstance(obj, Square), или наследник бросаетNotImplementedErrorв методе родителя. Оба признака говорят, что подставлять наследника вместо родителя уже нельзя.
I: принцип разделения интерфейсов
Интерфейс (набор методов, который класс обещает реализовать) лучше делать маленьким. В статье 2020 года Мартин формулирует принцип так: держите интерфейсы небольшими, чтобы пользователи не зависели от того, что им не нужно.
Пример. В офисе есть простой принтер и многофункциональное устройство, которое печатает и сканирует. Если завести один общий интерфейс «офисная техника» с методами «печатать», «сканировать» и «отправить факс», простому принтеру придётся реализовать сканирование и факс, которых у него нет. Обычно это заканчивается заглушками, которые бросают ошибку.
Решение: два маленьких интерфейса вместо одного большого. В Python для этого есть typing.Protocol (способ описать, какие методы ждём от объекта, без обязательного наследования; появился в Python 3.8, PEP 544):
from typing import Protocol
class Printer(Protocol):
def print_doc(self, text: str) -> None: ...
class Scanner(Protocol):
def scan(self) -> str: ...
class SimplePrinter:
def print_doc(self, text: str) -> None:
print(f"Печатаю: {text}")
class OfficeMachine:
def print_doc(self, text: str) -> None:
print(f"МФУ печатает: {text}")
def scan(self) -> str:
return "скан договора"
def print_invoice(device: Printer) -> None:
device.print_doc("счёт № 15")
print_invoice(SimplePrinter()) # Печатаю: счёт № 15
print_invoice(OfficeMachine()) # МФУ печатает: счёт № 15
Функции печати счёта нужен только принтер, и она просит только принтер. МФУ подходит сразу под оба протокола, простой принтер реализует один.
Мартин отдельно оговаривает, что острее всего проблема стоит в языках со статической типизацией вроде Java, C# или Go: там лишняя зависимость заставляет пересобирать модули. В динамических языках вроде Python эффект слабее, но, по его словам, иммунитета нет.
D: принцип инверсии зависимостей
Формулировка из статьи Мартина 2020 года: зависьте в сторону абстракций, модули верхнего уровня не должны зависеть от деталей нижнего уровня. Верхний уровень здесь означает бизнес-логику (то, ради чего программа написана: оформить заказ, посчитать зарплату). Нижний уровень означает технические детали: база данных, почта, формат файлов. Абстракция здесь означает описание того, что объект умеет делать, без подробностей, как именно: «умеет отправить сообщение» вместо «шлёт письмо через такой-то почтовый сервер».
Типичное нарушение выглядит безобидно:
class EmailSender:
def send(self, to, text):
print(f"Письмо для {to}: {text}")
class OrderServiceBefore:
def __init__(self):
self.sender = EmailSender() # жёстко прибито к почте
def place(self, customer):
self.sender.send(customer, "Заказ принят")
Оформление заказа намертво связано с отправкой писем. Захотели уведомлять клиентов в Telegram, и придётся переписывать класс заказа. Захотели проверить логику заказа автотестом, и тест начнёт слать настоящие письма.
Решение: класс заказа получает «отправителя» снаружи и знает о нём только одно: у него есть метод send.
class TelegramSender:
def send(self, to, text):
print(f"Сообщение в Telegram для {to}: {text}")
class FakeSender: # подделка для тестов
def __init__(self):
self.sent = []
def send(self, to, text):
self.sent.append((to, text))
class OrderService:
def __init__(self, sender):
self.sender = sender
def place(self, customer):
self.sender.send(customer, "Заказ принят")
OrderService(EmailSender()).place("anna@example.com")
OrderService(TelegramSender()).place("@anna")
fake = FakeSender()
OrderService(fake).place("test")
print(fake.sent) # [('test', 'Заказ принят')]
Теперь заменить почту на мессенджер можно одной строкой, а в тестах подставить подделку, которая ничего никуда не шлёт. На этом приёме держится почти любая серверная разработка, поэтому в программах по backend-разработке его разбирают одним из первых.
Частая путаница: инверсия зависимостей (принцип) и внедрение зависимостей, по-английски dependency injection (приём). Принцип говорит, куда должны смотреть зависимости. Внедрение зависимостей помогает этого добиться: передать нужный объект в конструктор, как мы сделали выше.
Как распознать нарушение SOLID в своём коде

Определения легко выучить и трудно применить. Ниже симптомы, которые новичок может заметить сам, ещё до код-ревью (проверки кода коллегой перед тем, как он попадёт в общий проект).
| Симптом в коде | Какой принцип нарушен | Что попробовать |
|---|---|---|
| Класс на 500 строк, описание звучит через «и» | S | Разделить по заказчикам изменений |
| Правка текста письма ломает расчёт | S | Вынести форматирование в отдельный класс |
Цепочка if/elif по типу растёт с каждой задачей |
O | Отдельный класс на каждый вариант с общим методом |
Проверки isinstance перед вызовом метода |
L | Пересмотреть иерархию наследования |
Наследник бросает NotImplementedError |
L или I | Разбить родителя или интерфейс на части |
| Методы-заглушки, которые никто не вызывает | I | Несколько маленьких протоколов вместо одного |
| Внутри бизнес-логики создаются подключение к базе и почтовый клиент | D | Передавать зависимости через конструктор |
| Автотест не написать без настоящей базы или интернета | D | Подставлять подделки вместо настоящих сервисов |
Хорошая привычка: перед тем как дописать очередную ветку elif или ещё один метод в большой класс, остановиться на минуту и посмотреть на эту таблицу. Рефакторинг (переделка кода без изменения его поведения) маленького класса занимает десять минут. Рефакторинг класса, в который полгода дописывали всё подряд, занимает неделю.
SOLID в Python, Java и C#: есть ли разница
Принципы одни и те же для любого объектно-ориентированного языка. Меняются только инструменты.
В Java и C# есть ключевое слово interface, и компилятор сам проверяет, что класс реализовал все обещанные методы. Поэтому примеры SOLID в учебниках часто пишут на этих языках: нарушения видны ещё до запуска. Если вас тянет в эту сторону, посмотрите курсы по Java-разработке.
В Python отдельного слова для интерфейсов нет, зато есть три способа описать ожидания:
- Утиная типизация. «Если объект умеет крякать, считаем его уткой»: функции важно, есть ли у объекта нужный метод. От какого класса он произошёл, её не интересует. Так работают все примеры выше.
- Абстрактные классы из модуля abc. Если унаследовать класс от
ABCи пометить методы декоратором@abstractmethod, объект нельзя создать, пока наследник не переопределит все отмеченные методы (документация модуля abc). - Протоколы typing.Protocol. Описывают нужные методы без наследования, а ошибки ловит проверка типов вроде mypy (программа, которая ещё до запуска проверяет, что в функции передают объекты нужного вида).
Если только начинаете, хватит утиной типизации и понятных имён методов. Протоколы и абстрактные классы пригодятся, когда проект вырастет и в нём появятся коллеги. Поставить Python и редактор, в котором удобно пробовать примеры из этой статьи, поможет наша инструкция по настройке VS Code для Python.
Когда SOLID только мешает
У принципов есть заметные критики. В 2016 году разработчик Дэн Норт выступил на конференции PubConf в Лондоне с пятиминутным докладом «Why Every Element of SOLID is Wrong». На каждом слайде он разбирает один принцип и приходит к одному выводу: пишите простой код (слайды доклада, на английском).
Мартин ответил в той же статье 2020 года. Совет писать просто он называет хорошим, но добавляет, что простота требует дисциплины, а дисциплину направляют принципы. Лучший способ устроить сложный беспорядок, по его словам, сказать всем «просто пишите просто» и не дать никаких ориентиров.
Мы в редакции думаем, что правы оба. На практике SOLID вредит в трёх случаях:
- Скрипт на один раз. Выгрузить таблицу и забыть: три класса вместо одной функции только отнимут время.
- Маленький проект без перспектив роста. Telegram-бот на 200 строк для себя читается проще одним файлом.
- Абстракции «про запас». Интерфейс с одной-единственной реализацией и фабрика, которая создаёт один класс, выглядят солидно, но читать такой код тяжело. Это называется оверинжиниринг, и против него есть отдельное правило YAGNI: не писать то, что пока не нужно.
Практическое правило. Применяйте принцип тогда, когда почувствовали боль, которую он лечит: вторую ветку
elif, второго заказчика правок, первый тест, который невозможно написать. До этого момента простая функция почти всегда лучше.
Когда программа разрастается до десятков модулей и нескольких команд, одних SOLID уже мало: в игру вступают подходы к проектированию целых систем вроде DDD (предметно-ориентированного проектирования). SOLID при этом никуда не уходит, он работает уровнем ниже, внутри каждого модуля.
Как отвечать про SOLID на собеседовании
Про SOLID спрашивают почти на любом собеседовании на позицию джуна в бэкенде, мобильной разработке и на Java или C#. Перечислить пять названий умеет каждый, поэтому интервьюер обычно копает глубже. Вот вопросы, которые встречаются чаще других, и как на них отвечать коротко.
Что такое SOLID и зачем он нужен
Пять принципов проектирования классов от Роберта Мартина. Нужны, чтобы код было легко менять и тестировать: правка в одном месте не ломает другие.
Приведите пример нарушения принципа единственной ответственности
Класс заказа, который сам считает сумму, сам сохраняет себя в базу и сам шлёт письмо. У него три причины меняться.
Почему квадрат не стоит наследовать от прямоугольника
Код, который меняет ширину и высоту прямоугольника по отдельности, получит неверную площадь для квадрата. Наследника нельзя подставить вместо родителя, значит нарушен принцип Лисков.
Чем инверсия зависимостей отличается от внедрения зависимостей
Инверсия зависимостей описывает правило: бизнес-логика зависит от абстракций. Внедрение зависимостей описывает приём: передать нужный объект снаружи, например через конструктор.
Всегда ли надо следовать SOLID
Нет. В одноразовых скриптах и маленьких проектах принципы добавляют лишнюю сложность. Сильный ответ звучит так: «применяю, когда вижу, что код будет меняться».
Главный совет: готовьте пример из своего кода. Фраза «в учебном проекте у меня был класс на 400 строк, я разнёс его на три и смог написать тесты» даёт интервьюеру повод для живого разговора, после которого заученные определения уже не нужны. Другие частые ошибки на интервью разбирали в статье о том, как пройти собеседование разработчику.
Как научиться применять SOLID на практике

Прочитать про принципы можно за вечер. Научиться видеть, где они нужны, получается только на своём коде. Вот порядок, который работает для новичка:
- Возьмите свой учебный проект или напишите маленький, например Telegram-бота на Python с напоминаниями.
- Найдите самый большой класс и опишите его одним предложением. Нашлось «и»? Разделите.
- Попробуйте написать тест на главную функцию. Если мешает настоящая база или отправка сообщений, передайте их через конструктор.
- Добавьте новую возможность: ещё один тип уведомлений или скидки. Посчитайте, сколько старых файлов пришлось открыть.
- Покажите код другому человеку. Свежий взгляд замечает класс-комбайн, к которому автор уже привык.
Через две-три такие итерации принципы перестают быть списком из учебника. Вы начинаете замечать лишнюю ответственность класса ещё до того, как он вырос.
Где научиться проектировать код
Разобраться в SOLID можно и самому, но за полгода самостоятельных попыток легко закрепить ошибки, которые наставник заметил бы на первом ревью. Он посмотрит ваш код и покажет, где класс берёт на себя лишнее. В хороших курсах по Python проектирование классов разбирают на домашних заданиях с ревью. В подборке ниже программы с ценами, длительностью и отзывами выпускников:
| Курс | Школа | Стоимость со скидкой | В рассрочку | Длительность | Обзор курса от Checkroi |
|---|---|---|---|---|---|
| Профессия «Python-разработчик» Перейти на сайт курса | 157 335 ₽ | 5987 ₽/мес. | 10 месяцев | Обзор курса | |
| Fullstack-разработчик на Python Перейти на сайт курса | 137 000 ₽ | 7125 ₽/мес. | 21 месяц | Обзор курса | |
| ДО Профессия Python-разработчик Перейти на сайт курса | 149 001 ₽ | 3167 ₽/мес. | 10 месяцев | Обзор курса | |
| Автоматизированное тестирование на Python Перейти на сайт курса | 118 754 ₽ | 4108 ₽/мес. | 9 месяцев | Обзор курса | |
| Профессия Python-разработчик Перейти на сайт курса | 140 040 ₽ | 3890 ₽/мес. | 10 месяцев | Обзор курса | |
| Разработчик на Python Перейти на сайт курса | 175 000 ₽ | 5500 ₽/мес. | 6 месяцев | Обзор курса | |
| Профессия «Python-разработчик с нуля до трудоустройства» Перейти на сайт курса | 81 800 ₽ | 5500 ₽/мес. | 6 месяцев | Обзор курса | |
| Профессия Fullstack-разработчик на Python Перейти на сайт курса | 158 040 ₽ | 4390 ₽/мес. | 16 месяцев | Обзор курса | |
| Python-разработчик + ИИ Перейти на сайт курса | 77 900 ₽ | 3246 ₽/мес. | 6 месяцев | Обзор курса | |
| Python-фреймворк Django Перейти на сайт курса | 58 396 ₽ | 5128 ₽/мес. | 3 месяца | Обзор курса |
Больше программ — в полном каталоге курсов по Python




