ООП в Python для начинающих: классы, объекты и зачем это backend-разработчику

ООП в python для начинающих — мост между «пишу скрипты» и «работаю в Django/FastAPI». Без объектов сложно понимать чужой код в команде, проходить code review и проектировать backend. Ниже — основы ООП, примеры наследования и @property, связь с Django и FastAPI.

Класс и объект

• Класс — шаблон с полями и методами.
• Объект — конкретный экземпляр по шаблону.

class User:
    def __init__(self, name: str, email: str):
        self.name = name
        self.email = email

    def greet(self) -> str:
        return f"Hello, {self.name}"

__init__ — конструктор, self — ссылка на экземпляр.

Три идеи ООП

1. Инкапсуляция

Данные и методы внутри класса. _single_underscore — «внутреннее, не трогай снаружи».

class BankAccount:
    def __init__(self, owner: str, balance: float = 0.0):
        self.owner = owner
        self._balance = balance

    def deposit(self, amount: float) -> None:
        if amount <= 0:
            raise ValueError("Сумма должна быть положительной")
        self._balance += amount

    @property
    def balance(self) -> float:
        return self._balance

2. Наследование

Дочерний класс берёт поля и методы родителя, добавляет или переопределяет своё.

class Animal:
    def __init__(self, name: str):
        self.name = name

    def speak(self) -> str:
        raise NotImplementedError


class Dog(Animal):
    def speak(self) -> str:
        return f"{self.name}: Гав!"


class Cat(Animal):
    def speak(self) -> str:
        return f"{self.name}: Мяу!"

super().__init__() вызывает конструктор родителя. В backend наследование переиспользует общую логику:

class BaseRepository:
    def __init__(self, db_session):
        self.db = db_session

    def get_by_id(self, model, entity_id: int):
        return self.db.query(model).filter(model.id == entity_id).first()


class UserRepository(BaseRepository):
    def find_by_email(self, email: str):
        return self.db.query(User).filter(User.email == email).first()

3. Полиморфизм

Разные классы с одним интерфейсом: for pet in pets: pet.speak() без проверки типа. В backend — стратегии оплаты, каналы уведомлений, сериализаторы.

@property: вычисляемые атрибуты

Метод, доступный как атрибут — с логикой и валидацией внутри.

class Rectangle:
    def __init__(self, width: float, height: float):
        self.width = width
        self.height = height

    @property
    def area(self) -> float:
        return self.width * self.height

Property с setter

class Product:
    def __init__(self, name: str, price: float):
        self._price = price

    @property
    def price(self) -> float:
        return self._price

    @price.setter
    def price(self, value: float) -> None:
        if value < 0:
            raise ValueError("Цена не может быть отрицательной")
        self._price = value

На Middle @property — стандарт: order.final_amount вместо дублирования формул в десяти местах.

ООП в Django

Каждая model = класс, строка в БД = объект.

class User(models.Model):
    email = models.EmailField(unique=True)
    is_active = models.BooleanField(default=True)

    def deactivate(self) -> None:
        self.is_active = False
        self.save()

    @property
    def domain(self) -> str:
        return self.email.split("@")[1]

• User наследует models.Model — ORM, миграции, admin из коробки.
• user.deactivate() — метод экземпляра; User.objects.filter(...) — менеджер.

Абстрактные базовые модели переиспользуют поля:

class TimeStampedModel(models.Model):
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        abstract = True


class Article(TimeStampedModel):
    title = models.CharField(max_length=200)

abstract = True — наследование без отдельной таблицы. Бизнес-логику выносят в сервисы:

class OrderService:
    def __init__(self, payment_gateway, notification_service):
        self.payment = payment_gateway
        self.notifications = notification_service

    def checkout(self, user, cart_items) -> Order:
        order = Order.objects.create(user=user, status="pending")
        self.payment.charge(order)
        self.notifications.send_confirmation(user, order)
        return order

Зависимости в __init__ упрощают тестирование с mock-объектами.

ООП в FastAPI и Pydantic

Схемы запросов и ответов — классы с автовалидацией:

class UserCreate(BaseModel):
    email: EmailStr
    password: str = Field(min_length=8)


class UserResponse(BaseModel):
    id: int
    email: EmailStr
    is_active: bool

    class Config:
        from_attributes = True  # маппинг из ORM

FastAPI создаёт объект UserCreate из тела запроса, возвращает UserResponse как JSON. Ошибки валидации — 422 автоматически.

Наследование схем убирает дублирование:

class UserBase(BaseModel):
    email: EmailStr


class UserCreate(UserBase):
    password: str = Field(min_length=8)


class UserUpdate(UserBase):
    password: str | None = None

Валидаторы — методы класса с @field_validator. Django Model отвечает за БД (save(), миграции), Pydantic — за валидацию API. В FastAPI-проектах два слоя классов: ORM-модель и Pydantic-схема; маппинг между ними — ежедневная задача backend-разработчика.

Когда класс, когда функция

Утилиты без состояния — функции (format_price). Сущности с состоянием и операциями — классы. Django и FastAPI требуют классы по определению фреймворка.

Типичные ошибки новичков

• всё в одном файле без классов там, где нужна структура;
• «наследование ради наследования» вместо композиции;
• игнор @property и dunder-методов (__repr__, __eq__) на Middle;
• путаница атрибута класса и экземпляра;
• забытый self в методах.

Дальше по программе

ООП — блок первых недель курса Python IT Mentor, затем SQL, Django и проект. Полный порядок — roadmap backend.

Читайте также

• Как стать Python-разработчиком с нуля
• Что должен знать Python-разработчик