Основы Python

Объектно-ориентированное программирование в Python

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

  • Начальный
  • Чтение: 4 мин
  • Примеров для запуска: 1

Что такое объектно-ориентированное программирование в Python?

Какую задачу это решает

По мере роста программы многим её частям нужны объекты одного вида с небольшими различиями: обычный счёт и сберегательный, кошка и собака. Копирование классов с правкой нескольких строк ведёт к дублированию кода, а проверки типа через if повсюду превращают каждый новый вид в большое изменение.

Пример из жизни

Объектно-ориентированное программирование устроено как счета в одном банке. Каждый счёт хранит свой баланс за стойкой, и напрямую его не тронуть (инкапсуляция). Сберегательный счёт - это обычный счёт с одной дополнительной возможностью (наследование). Когда банк объявляет всем счетам 'конец месяца', каждый счёт делает это по-своему (полиморфизм).

От банка к коду
self._balance🔒 Деньги за стойкой: менять только через deposit()
class SavingsAccount(BankAccount):🏦 Сберегательный счёт - это счёт плюс проценты
super().__init__(owner, balance)📋 Сначала заполнить бланк обычного счёта
account.month_end()📅 Одна и та же просьба, каждый счёт отвечает по-своему
Общие правила в базовом классе, различия в подклассе.
Одним предложением

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

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

Четыре основных принципа ООП

  • Инкапсуляция объединяет состояние и поведение и контролирует доступ.
  • Абстракция показывает полезный интерфейс и скрывает лишние детали.
  • Наследование специализирует класс только при настоящем отношении «является».
  • Полиморфизм применяет одну операцию к разным объектам с подходящим поведением.

Устройство примера

  1. BankAccount хранит баланс и проверяет пополнение.
  2. SavingsAccount повторно использует базовый контракт.
  3. SavingsAccount переопределяет month_end для начисления процентов.
  4. Цикл использует единый интерфейс для всех счетов.
Совет: Предпочитайте композицию, если объект лишь использует другой; наследуйте только при корректной взаимозаменяемости.

Когда это нужно?

  • Несколько видов объектов с почти общим поведением: типы счетов, фигуры, игровые персонажи.
  • Код, который должен работать с будущими видами без переписывания.
  • Защита данных, которые должны оставаться корректными, например баланса, который не может стать отрицательным.

Когда это не нужно

  • Небольшие скрипты с несколькими функциями: классы и наследование добавляют ненужную структуру.
  • Глубокие цепочки наследования (A от B от C от D): за ними трудно следить; предпочитайте композицию.

Базовый пример

Запустить код →
main.py
class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = float(balance)

    @property
    def balance(self):
        return self._balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Deposit must be positive")
        self._balance += amount

    def month_end(self):
        return "No interest"


class SavingsAccount(BankAccount):
    def __init__(self, owner, balance, interest_rate):
        super().__init__(owner, balance)
        self.interest_rate = interest_rate

    def month_end(self):
        self._balance *= 1 + self.interest_rate
        return "Interest applied"


accounts = [
    BankAccount("Ada", 100),
    SavingsAccount("Lin", 200, 0.05),
]
accounts[0].deposit(50)

for account in accounts:
    status = account.month_end()
    print(f"{account.owner}: {account.balance:.2f} ({status})")
Получить кнопку запуска для этого примера

Результат выполнения

Ada: 150.00 (No interest)
Lin: 210.00 (Interest applied)

Четыре принципа ООП на практике

Эти примеры показывают, как Python реализует инкапсуляцию, абстракцию, наследование и полиморфизм в повседневном коде.

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

Запустить код →

Инкапсуляция объединяет состояние и поведение и контролирует доступ.

encapsulation.py
class BankAccount:
    def __init__(self, balance=0):
        # Double underscores prevent accidental direct access.
        self.__balance = balance

    @property
    def balance(self):
        # Expose read access without exposing mutation.
        return self.__balance

    def deposit(self, amount):
        # Keep validation next to the state it protects.
        if amount <= 0:
            raise ValueError("Amount must be positive")
        self.__balance += amount


account = BankAccount(100)
account.deposit(50)
print(account.balance)  # 150

Абстракция

Запустить код →

Абстракция показывает полезный интерфейс и скрывает лишние детали.

abstraction.py
from abc import ABC, abstractmethod


class PaymentMethod(ABC):
    @abstractmethod
    def pay(self, amount):
        # Callers know what pay does, not how each provider does it.
        pass


class CreditCard(PaymentMethod):
    def pay(self, amount):
        # The concrete class hides its payment implementation.
        return f"Paid ${amount:.2f} by card"


payment = CreditCard()
print(payment.pay(25))

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

Запустить код →

Наследование специализирует класс только при настоящем отношении «является».

inheritance.py
class Employee:
    def __init__(self, name):
        self.name = name

    def describe(self):
        return self.name


class Developer(Employee):
    def __init__(self, name, language):
        # Reuse initialization from the parent class.
        super().__init__(name)
        self.language = language

    def describe(self):
        # Extend inherited behavior instead of duplicating it.
        return f"{super().describe()} writes {self.language}"


print(Developer("Ada", "Python").describe())

Полиморфизм

Запустить код →

Полиморфизм применяет одну операцию к разным объектам с подходящим поведением.

polymorphism.py
class EmailNotification:
    def send(self, message):
        return f"Email: {message}"


class SmsNotification:
    def send(self, message):
        return f"SMS: {message}"


def notify(channels, message):
    for channel in channels:
        # The same call selects behavior from each concrete object.
        print(channel.send(message))


channels = [EmailNotification(), SmsNotification()]
notify(channels, "Order shipped")

Разбор кода

Класс BankAccount инкапсулирует баланс в атрибуте _balance и позволяет менять его только через контролируемые методы, например deposit(). Класс SavingsAccount наследует все эти методы и переопределяет month_end(), чтобы начислять проценты. Цикл вызывает один и тот же метод у обоих счетов, но Python во время выполнения выбирает версию, подходящую для каждого типа объекта. Это и есть полиморфизм.

Измените значения и запустите программу в онлайн-компиляторе Python CodeUtility без локальной установки Python.

Упражнения для практики

Попробуйте изменить код по подсказкам ниже. Если менять код и смотреть на результат, урок запомнится гораздо лучше, чем при простом чтении.

  1. Измените входные данные и предскажите результат до запуска.
  2. Добавьте проверку пустых или неверных данных.
  3. Вынесите обработку в отдельную функцию и проверьте её на нескольких наборах данных.
Запустить в компиляторе Python →

Частые ошибки

Не вызван super().__init__

Без него настройка родителя не выполняется, и атрибутов вроде owner нет.

Ошибка
class SavingsAccount(BankAccount):
    def __init__(self, owner, balance, rate):
        self.interest_rate = rate
Исправление
class SavingsAccount(BankAccount):
    def __init__(self, owner, balance, rate):
        super().__init__(owner, balance)
        self.interest_rate = rate

Прямое изменение защищённых данных

Присваивание _balance снаружи обходит проверки в deposit().

Ошибка
account._balance = -500
Исправление
account.deposit(50)

Закончили этот урок?

Отметьте его как изученный, чтобы следить за прогрессом.

Попрактикуйтесь на задаче

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

Все задачи