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

Новая логика программы, где данные и функции живут вместе

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

product_name = "Кофемолка"
product_price = 2990.0
product_stock = 12

def product_info(name, price, stock):
    return f"{name}, цена {price}, в наличии {stock} шт."

Пока товар один, беды нет. Но магазин с одним товаром долго не живёт, и как только ассортимент вырастет до десяти позиций, переменных станет тридцать, а путаница неизбежна. Функции тоже неудобно: product_info приходится вручную скармливать три аргумента, и легко перепутать их порядок. Данные и действия, которые к ним относятся, тянутся друг к другу, но код держит их на расстоянии. ООП решает проблему радикально: товар описывается как единая сущность, которая сама помнит название, цену и остаток и сама умеет о себе рассказать. Объект в этом смысле похож на коробку с перегородками: внутри лежат данные, а рядом сложены инструменты для работы с ними. Такой способ мышления переносится на что угодно: банковский счёт с балансом и операциями, игрок со здоровьем и инвентарём, заказ с датой и составом.

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

Синтаксис класса и рождение первого объекта

Класс объявляется ключевым словом class, за которым идут имя и двоеточие. Имя класса по традиции пишут в стиле PascalCase, каждое слово с заглавной буквы, потому что имя класса становится внутри программы новым типом данных. Классы называют существительными, которые описывают сущность: Product, BankAccount, Player. Так имена в коде читаются как обычная речь:

class Product:
    pass

first_item = Product()
print(type(first_item))

Вывод будет таким:

<class '__main__.Product'>

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

Когда встречается строка item = Product("Кофе", 350), внутри интерпретатора происходит три шага:

  1. Python находит класс Product и выделяет в памяти место под новый, пока пустой, объект;
  2. управление передаётся конструктору __init__, и свежесозданный объект автоматически подставляется на первое место, то есть на место self;
  3. конструктор заполняет атрибуты, ссылка на готовый объект записывается в переменную item, и на этом создание завершено.

Понимание этих трёх шагов снимает главный страх новичков, потому что становится ясно, откуда вообще берётся таинственный self.

Конструктор __init__ и простой смысл слова self

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

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

Здесь начинается то самое место, на котором спотыкаются почти все начинающие. Слово self означает сам объект, для которого сейчас выполняется метод. Строка Product("Кофе", 350) превращается интерпретатором в вызов __init__(новый_объект, "Кофе", 350): на место self подставляется свежесозданный объект, а аргументы name и price уходят на свои места. Запись self.name = name читается так: у этого конкретного объекта появляется атрибут name, и в него кладётся значение из аргумента. Человек, который пишет код, никогда не передаёт self сам, Python делает это за него, зато забывать self в списке параметров нельзя, иначе метод не поймёт, с каким объектом ему работать. У параметров конструктора, как у любой функции, бывают значения по умолчанию: def __init__(self, name, price=100). Тогда Product("Ручка") создаст товар с ценой сто, а Product("Стол", 7900) переопределит её. Обязательные данные идут первыми, необязательные со значениями по умолчанию после них. Сам __init__ ничего не возвращает: его задача заполнить атрибуты, а выдачу ссылки на готовый объект Python берёт на себя.

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

Переменные, записанные через self, называются атрибутами экземпляра, и у каждого объекта свой собственный комплект. Создадим два товара из одного класса и посмотрим на них вживую:

coffee = Product("Кофе", 350)
tea = Product("Чай", 180)

print(coffee.name, coffee.price)   # Кофе 350
print(tea.name, tea.price)         # Чай 180

coffee.price = 400                 # атрибут можно изменить
print(coffee.price)                # 400
print(tea.price)                   # 180

Похоже на анкеты, заполненные на каждого ученика одного класса: бланк один, а записи в нём разные. Оба объекта выросли из одного шаблона, но живут в памяти как две отдельные личности, и изменение цены кофе никак не задевает чай. Атрибуты можно заводить и после создания, прямо на лету, строкой coffee.old_price = 350, однако опытные разработчики предпочитают описывать все нужные атрибуты в конструкторе, чтобы каждый объект выходил из формы с одинаковым набором данных. Так код получается предсказуемым, а ошибки всплывают раньше и в понятном месте.

Полезно знать и такой приём: print(item.__dict__) покажет весь комплект атрибутов объекта одним словарём, {'name': 'Клавиатура', 'price': 4990}. Заодно он отвечает на частый вопрос, чем атрибут отличается от обычной переменной внутри метода. Локальная переменная живёт только пока выполняется вызов и исчезает вместе с ним, а атрибут прибит к объекту и остаётся с ним, пока объект существует.

Методы класса и вызов через точку

Функция, определённая внутри класса, называется методом. Первым параметром метода почти всегда стоит self, а вызывается метод через объект и точку:

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

    def discounted_price(self, percent):
        return round(self.price - self.price * percent / 100, 2)

item = Product("Клавиатура", 4990)
print(item.discounted_price(15))   # 4241.5

Метод читает атрибуты того объекта, к которому привязан: внутри self.price лежит 4990, поэтому расчёт идёт по цене клавиатуры, а не по чьей-то чужой. Рядом поставим обычную функцию, которая решает ту же задачу:

def discounted(price, percent):
    return round(price - price * percent / 100, 2)

print(discounted(4990, 15))        # 4241.5

Результат одинаковый, разница в философии. Обычная функция стоит сама по себе и требует принести данные в аргументах. Метод принадлежит объекту и берёт данные прямо из него, поэтому при вызове item.discounted_price(15) товар передавать не нужно, он и так знает свою цену. Метод это функция, которая знает, с какими данными работает, а функция это метод, которому всё время приходится объяснять контекст. Первая формулировка короче и точнее, но вторая хорошо показывает направление мысли.

Тут новичков ждёт приятное открытие: объектами они пользовались с самых первых уроков. Строка это объект, и text.upper() это вызов его метода. Список тоже объект со своими append() и sort(). Привычные вызовы через точку всегда были вызовами методов, просто теперь понятно, как такие методы устроены изнутри и как писать собственные. Запись через точку читается слева направо, и это помогает пониманию: сначала объект, потом действие над ним. Когда объектов много, каждый вызов остаётся очевидным: coffee.discounted_price(10) считается по кофе, tea.discounted_price(20) по чаю, и ни один не мешает другому.

Практика с классом товара и скидками

Пора собрать всё изученное в один цельный пример, который можно скопировать и запустить целиком:

class Product:
    def __init__(self, name, price, stock):
        self.name = name
        self.price = price
        self.stock = stock

    def discounted_price(self, percent):
        return round(self.price - self.price * percent / 100, 2)

    def apply_discount(self, percent):
        self.price = self.discounted_price(percent)
        print(f"Новая цена {self.name}: {self.price}")

    def sell(self, pieces):
        if pieces > self.stock:
            print(f"{self.name}: на складе только {self.stock} шт.")
            return
        self.stock -= pieces
        print(f"Продано {pieces} шт., осталось {self.stock}")

mouse = Product("Мышь беспроводная", 1990, 7)
mouse.apply_discount(10)
mouse.sell(3)
mouse.sell(10)
print(mouse.price, mouse.stock)

Вывод программы будет таким:

Новая цена Мышь беспроводная: 1791.0
Продано 3 шт., осталось 4
Мышь беспроводная: на складе только 4 шт.
1791.0 4

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

Тем, кому ближе финансовая тема, подойдёт второй вариант для самостоятельной тренировки, банковский счёт с депозитом и снятием:

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        self.balance += amount
        return self.balance

    def withdraw(self, amount):
        if amount > self.balance:
            print("Недостаточно средств")
            return
        self.balance -= amount
        return self.balance

account = BankAccount("Анна")
account.deposit(5000)
print(account.withdraw(2000))   # 3000
account.withdraw(9000)          # Недостаточно средств

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

Для закрепления напрашивается упражнение: добавить классу Product метод restock(self, pieces), который увеличивает остаток на складе, и метод get_info(self), который возвращает строку с названием, ценой и остатком. Оба пишутся по уже знакомому шаблону: self в параметрах, чтение и запись атрибутов внутри, вызов через точку.

Частые ошибки новичков и мостик к наследованию

Разбор типовых падений сэкономит часы отладки. Самая частая ошибка это забытое self в заголовке метода:

def discounted_price(percent):     # self потерян
    return round(self.price - self.price * percent / 100, 2)

Python ответит ошибкой TypeError: Product.discounted_price() takes 1 positional argument but 2 were given. Причина показательная: интерпретатор всё равно подсовывает на первый параметр сам объект, и места для аргумента percent уже не остаётся. Метод без self в списке параметров просто не знает, чьи price и name ему брать. Вторая ошибка родственная: потерянные скобки при вызове. Запись print(item.discounted_price) без скобок напечатает вместо цены что-то вроде <bound method Product.discounted_price of ...>, ведь без скобок метод не выполняется, а только упоминается. Третья ошибка касается типов данных: если передать цену строкой, Product("Чай", "180"), то вычисление скидки упадёт с TypeError: строку нельзя разделить на сто. Правило простое: числа хранятся числами, строки строками, и конструктор должен получать данные уже правильных типов.

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