Что такое ООП и зачем оно нужно
Объектно-ориентированное программирование (ООП) - это способ организовать код вокруг объектов. Объект объединяет данные (что о нём известно) и действия (что он умеет). Вместо россыпи переменных и функций вы описываете понятия из задачи: счёт в банке, игрока, заказ, письмо.
Идея простая: программа - это набор объектов, которые общаются друг с другом. Каждый отвечает за свою часть работы, поэтому код проще читать, менять и тестировать. Это один из главных подходов в Python, Java, C#, C++, PHP и других языках.
Для начала достаточно трёх слов. Класс - чертёж, по которому создают объекты. Объект (экземпляр) - конкретная вещь, созданная по чертежу. Атрибут - данные объекта, метод - его функция.
Класс и объект на примере Python
Опишем класс собаки и создадим два объекта. Метод __init__ вызывается при создании объекта и задаёт начальные значения, а self - ссылка на сам объект.
class Dog:
def __init__(self, name, age):
self.name = name # атрибут: кличка
self.age = age # атрибут: возраст
def bark(self): # метод: действие
return f"{self.name}: гав!"
rex = Dog("Рекс", 3)
bim = Dog("Бим", 5)
print(rex.bark())
print(bim.age)
Программа выведет Рекс: гав! и 5. Класс Dog один, а объектов из него можно создать сколько угодно, и у каждого свои данные.
Если функции и аргументы вам ещё не знакомы, сначала посмотрите разбор функций в Python: методы устроены так же, только первым параметром идёт self.

Четыре принципа ООП
Когда говорят про принципы ООП, имеют в виду четыре идеи: инкапсуляцию, наследование, полиморфизм и абстракцию. Их можно запомнить по одной фразе: спрятать лишнее, не повторяться, работать единообразно, описать главное.
| Принцип | Простыми словами | Зачем |
|---|---|---|
| Инкапсуляция | Данные и методы живут вместе, внутренности скрыты | Нельзя случайно испортить состояние объекта |
| Наследование | Новый класс берёт всё от старого и добавляет своё | Не копировать одинаковый код |
| Полиморфизм | Один вызов работает с разными объектами по-разному | Код не зависит от конкретного типа |
| Абстракция | Описываем только существенное, детали прячем | Проще мыслить и проектировать |
Инкапсуляция: спрятать детали
Представьте банкомат: вы нажимаете кнопки, а как он считает остаток, вас не касается. Инкапсуляция делает то же в коде: состояние объекта меняют только через его методы, а не напрямую.
В Python нет жёстких запретов, действует соглашение. Имя с одним подчёркиванием (_balance) означает "внутреннее, не трогай". Имя с двумя (__balance) интерпретатор дополнительно переименовывает, чтобы снаружи его было сложнее задеть случайно.
class Account:
def __init__(self, balance=0):
self._balance = balance
@property
def balance(self): # чтение баланса
return self._balance
def deposit(self, amount):
if amount <= 0:
raise ValueError("Сумма должна быть положительной")
self._balance += amount
def withdraw(self, amount):
if amount > self._balance:
raise ValueError("Недостаточно средств")
self._balance -= amount
acc = Account(100)
acc.deposit(50)
acc.withdraw(30)
print(acc.balance) # 120
Баланс читается через свойство balance, а менять его можно только через deposit и withdraw, где есть проверки. Попытка написать acc.balance = 5 вызовет ошибку, потому что у свойства нет сеттера.
Частая ошибка новичков: считать, что _balance защищено от записи. Это только договорённость между программистами, обойти её технически можно. Защита здесь в дисциплине, а не в языке.
Наследование: не повторять код
Если у двух классов много общего, общее выносят в родительский класс, а различия описывают в дочерних. Дочерний класс получает все атрибуты и методы родителя и может их переопределить.
class Animal:
def __init__(self, name):
self.name = name
def eat(self):
return f"{self.name} ест"
def speak(self):
return "..."
class Cat(Animal): # Cat наследует Animal
def speak(self): # переопределяем метод
return f"{self.name}: мяу"
class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name) # вызываем конструктор родителя
self.breed = breed
def speak(self):
return f"{self.name}: гав"
tom = Cat("Том")
print(tom.eat()) # Том ест
print(tom.speak()) # Том: мяу
Метод eat написан один раз, а работает у обоих животных. Функция super() позволяет обратиться к родителю, чтобы не дублировать его инициализацию.
Не злоупотребляйте цепочками наследования. Если связь "является" не очевидна (кошка является животным - да, двигатель является машиной - нет), лучше использовать композицию: объект просто хранит другой объект внутри себя, как двигатель хранится в машине.
Полиморфизм: один интерфейс, разное поведение
Полиморфизм означает, что одну и ту же операцию можно вызвать у разных объектов, и каждый выполнит её по-своему. Вызывающему коду не нужно знать точный тип.
animals = [Cat("Том"), Dog("Рекс", "овчарка"), Animal("Нечто")]
for a in animals:
print(a.speak())
Цикл вызывает speak() у каждого элемента и получит три разных ответа: "Том: мяу", "Рекс: гав" и "...". Если завтра появится класс Cow со своим speak, цикл менять не придётся.
В Python работает и так называемая утиная типизация: если у объекта есть нужный метод, его можно использовать, даже если он не связан наследованием. Встроенная функция len() одинаково работает со строками, списками и словарями именно поэтому.
Абстракция: описать только главное
Абстракция - это выбор существенного. Для программы учёта сотрудников у человека важны имя и оклад, а цвет глаз нет. Класс описывает именно нужное, а остальное остаётся за кадром.
Для строгой абстракции в Python есть модуль abc. Абстрактный класс задаёт, какие методы обязаны быть у наследников, но сам не позволяет создать объект.
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self):
"""Площадь фигуры"""
class Rectangle(Shape):
def __init__(self, w, h):
self.w, self.h = w, h
def area(self):
return self.w * self.h
class Circle(Shape):
def __init__(self, r):
self.r = r
def area(self):
return 3.14159 * self.r ** 2
shapes = [Rectangle(2, 3), Circle(1)]
print([round(s.area(), 2) for s in shapes]) # [6, 3.14]
# Shape() -> TypeError: нельзя создать абстрактный класс
Здесь абстракция и полиморфизм работают вместе: все фигуры обязаны уметь считать площадь, а вызывающий код просто зовёт area(). Аналогичные идеи есть в других языках, например в абстрактных классах и интерфейсах Kotlin.
Когда ООП помогает, а когда мешает
ООП хорошо подходит для программ с множеством однотипных сущностей и сложным состоянием: игры, интерфейсы, бизнес-системы, библиотеки. Там объекты естественно отражают предметную область.
Для коротких скриптов, обработки таблиц или одноразовых вычислений класс часто лишний. Обычных функций и структур данных хватает, и код получается короче. Хорошее правило: заводите класс, когда у вас есть данные и несколько функций, которые всё время работают именно с ними.
- Называйте классы существительными с большой буквы (
Order,UserProfile), методы - глаголами (save,calculate_total). - Держите класс небольшим: одна понятная ответственность.
- Выбирайте композицию, если наследование выглядит натянуто.
- Выбор структуры хранения данных внутри объектов описан в статье про структуры данных.
Общий обзор идей есть в статье про ключевые концепции объектно-ориентированного программирования, а закрепить синтаксис помогут задачи на Python для начинающих. Ещё один пример применения классов - шаблон фабричного метода в Python.
