Bezdepbonusu7Программирование: статьи и ответы

Основы программирования

ООП простыми словами: классы, объекты и четыре принципа на Python

ООП простыми словами - это способ писать программу как набор объектов, у каждого из которых есть свои данные и действия. В статье разберём класс и объект, а затем четыре принципа ООП: инкапсуляцию, наследование, полиморфизм и абстракцию, с короткими примерами на Python.

ООП простыми словами: классы, объекты и четыре принципа на Python
Содержание
  1. Что такое ООП и зачем оно нужно
  2. Класс и объект на примере Python
  3. Четыре принципа ООП
  4. Инкапсуляция: спрятать детали
  5. Наследование: не повторять код
  6. Полиморфизм: один интерфейс, разное поведение
  7. Абстракция: описать только главное
  8. Когда ООП помогает, а когда мешает
  9. Частые вопросы

Что такое ООП и зачем оно нужно

Объектно-ориентированное программирование (ООП) - это способ организовать код вокруг объектов. Объект объединяет данные (что о нём известно) и действия (что он умеет). Вместо россыпи переменных и функций вы описываете понятия из задачи: счёт в банке, игрока, заказ, письмо.

Идея простая: программа - это набор объектов, которые общаются друг с другом. Каждый отвечает за свою часть работы, поэтому код проще читать, менять и тестировать. Это один из главных подходов в 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.

Схема: один класс Dog и два объекта с разными данными
Класс - чертёж, объекты - конкретные экземпляры

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

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

ПринципПростыми словамиЗачем
ИнкапсуляцияДанные и методы живут вместе, внутренности скрытыНельзя случайно испортить состояние объекта
НаследованиеНовый класс берёт всё от старого и добавляет своёНе копировать одинаковый код
ПолиморфизмОдин вызов работает с разными объектами по-разномуКод не зависит от конкретного типа
АбстракцияОписываем только существенное, детали прячемПроще мыслить и проектировать

Инкапсуляция: спрятать детали

Представьте банкомат: вы нажимаете кнопки, а как он считает остаток, вас не касается. Инкапсуляция делает то же в коде: состояние объекта меняют только через его методы, а не напрямую.

В 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.

Частые вопросы

Что такое ООП простыми словами?

Это подход, при котором программа строится из объектов, объединяющих данные и методы. Объекты создаются по шаблонам - классам и взаимодействуют друг с другом.

Какие основные принципы ООП существуют?

Четыре: инкапсуляция, наследование, полиморфизм и абстракция. Иногда к ним добавляют композицию как альтернативу наследованию.

Чем класс отличается от объекта?

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

Есть ли ООП в Python?

Да, Python полностью поддерживает ООП: в нём всё является объектом, а классы создаются ключевым словом class. Одновременно можно писать и в процедурном стиле.

Чем ООП в Python отличается от ООП в Java?

Идеи те же, но в Python нет жёстких модификаторов доступа и обязательных типов, а многое держится на соглашениях. В Java приватность и типы проверяются компилятором.

Что такое self в Python?

Это ссылка на текущий объект, которая автоматически передаётся первым параметром в каждый метод. Через неё метод получает доступ к атрибутам объекта.

Нужно ли учить ООП новичку?

Да, но после базы: переменных, условий, циклов и функций. Тогда классы воспринимаются как естественное продолжение, а не набор непонятных терминов.

Источники

Python

Похожие материалы

Версии программ и команды проверены на дату публикации. Если что-то изменилось, сверяйтесь с официальной документацией. Нашли неточность? Напишите на admin@bezdepbonusu7.win.