Skip to content

Класс как объединение функций ​

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

Почему классы вместо набора свободных функций?

  • Организация кода: вместо множества отдельных функций мы получаем единый объект с набором методов obj.method().
  • Инкапсуляция: общие детали (например, проверка деления на ноль) можно держать внутри класса, а не дублировать.
  • Гибкость: легко расширять, переопределять и комбинировать функции через наследование и декораторы.

Набор функций ​

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

python
def addition(a, b):
    """Return sum of a and b."""
    return a + b

def subtraction(a, b):
    """Return difference of a and b."""
    return a - b

def multiplication(a, b):
    """Return product of a and b."""
    return a * b

def division(a, b):
    """Return quotient of a and b, return if b == 0."""
    if b == 0:
        return "Division by zero"
    return a / b

Описание кода:

  • Каждая функция принимает два аргумента a и b и возвращает результат соответствующей операции.
  • Для division добавлена защита от деления на ноль через выброс "Division by zero".
  • Такие функции удобно использовать по отдельности, но при увеличении их числа поддерживать код становится сложнее.

Функции в классе ​

Сгруппируем эти функции внутри класса Operator. Обратите внимание: здесь методы объявлены без параметра self.

python
class Operator:
    """Calculator groups basic arithmetic operations."""

    def addition(a, b):
        """Return sum of a and b."""
        return a + b

    def subtraction(a, b):
        """Return difference of a and b."""
        return a - b

    def multiplication(a, b):
        """Return product of a and b."""
        return a * b

    def division(a, b):
        """Return quotient of a and b, return if b == 0."""
        if b == 0:
            return "Division by zero"
        return a / b


operator = Operator                     # без скобок — ссылка на класс, не экземпляр
print(operator.addition(10, 2))         # 12
print(operator.subtraction(10, 2))      # 8
print(operator.multiplication(10, 2))   # 20
print(operator.division(10, 2))         # 5.0

print(Operator.division(10, 2))         # 5.0 — напрямую по имени класса

Особенности реализации:

  • Методы объявлены без self, поэтому при вызове Python воспринимает a и b как первые два аргумента.
  • operator = Operator — здесь мы не создаём экземпляр, а просто присваиваем переменной сам класс.
  • Вызов operator.addition(10, 2) эквивалентен Operator.addition(10, 2).
  • Такая схема может пригодиться для простого объединения функций, но лишена привычной семантики экземпляров.

Функции в классе + self ​

Чтобы методы работали как истинные методы экземпляра, нужно добавить параметр self и создать объект с помощью скобок:

python
class Operator:
    """Calculator groups basic arithmetic operations."""

    def addition(self, a, b):
        """Return sum of a and b."""
        return a + b

    def subtraction(self, a, b):
        """Return difference of a and b."""
        return a - b

    def multiplication(self, a, b):
        """Return product of a and b."""
        return a * b

    def division(self, a, b):
        """Return quotient of a and b, return if b == 0."""
        if b == 0:
            return "Division by zero"
        return a / b


operator = Operator()                   # скобки — создаём экземпляр класса
print(operator.addition(10, 2))         # 12
print(operator.subtraction(10, 2))      # 8
print(operator.multiplication(10, 2))   # 20
print(operator.division(10, 2))         # 5.0

Что изменилось?

  • Первый параметр каждого метода — self — ссылка на текущий экземпляр operator.
  • Вызов operator.addition(10, 2) автоматически передаёт внутрь self, а a=10, b=2.
  • Благодаря self в будущем мы сможем хранить состояние внутри объекта.

Методы с состоянием ​

Теперь посмотрим на hero-класс курса — ParcelBox, где методы работают со состоянием объекта:

python
class ParcelBox:
    def __init__(self, length, width, height):
        self.length = length
        self.width = width
        self.height = height

    def get_volume(self):
        return self.length * self.width * self.height

    def surface_area(self):
        return 2 * (self.length * self.width + self.length * self.height + self.width * self.height)

box = ParcelBox(10, 5, 2)
print(box.get_volume())          # 100
print(box.surface_area())    # 160

Что изменилось?

  • Свободная функция требует явно передать все параметры, метод получает состояние через self.
  • box.get_volume() читает размеры из самого объекта — повторно передавать их не нужно.
  • Состояние живёт в экземпляре: две коробки с разными размерами вернут разные объёмы, а код метода один.

Дальше ​

В следующем уроке разберём два специальных вида методов: @staticmethod (метод без экземпляра) и @classmethod (метод с классом cls, в том числе фабрики-конструкторы).

Проверьте себя ​

❓Зачем объединять логически связанные функции в класс вместо набора свободных функций?
❓Что происходит, если методы класса объявлены без `self`?
❓Что означает строка `operator = Operator` (без скобок)?
❓Зачем добавлять параметр `self` и создавать объект со скобками?

Упражнения ​

Каждое решение оформляйте полностью: docstring-описание каждого метода и вывод результатов тестовых вызовов.

  1. Дополните класс Operator (вариант с self) методами:

    • power(a, b) — возведение в степень;
    • mod(a, b) — остаток от деления;
    • floordiv(a, b) — целочисленное деление.

    Протестируйте каждый метод двумя способами: вызовом через экземпляр operator.power(2, 5) и через имя класса Operator.power(operator, 2, 5) — при вызове через класс экземпляр передаётся явно первым аргументом.

  2. Создайте класс Rectangle с атрибутами width и height, инициализируемыми в __init__:

    • метод area() — возвращает площадь прямоугольника;
    • метод perimeter() — возвращает периметр;
    • метод is_square() — возвращает True, если прямоугольник — квадрат;
    • все методы обращаются к размерам только через self.

    Создайте два экземпляра: rect_a = Rectangle(5, 2) и rect_b = Rectangle(4, 4). Вызовите все методы у обоих экземпляров и убедитесь, что rect_a.area() = 10, rect_a.perimeter() = 14, rect_a.is_square() = False; rect_b.area() = 16, rect_b.perimeter() = 16, rect_b.is_square() = True. Состояние каждой фигуры живёт в её экземпляре — одна фигура не «видит» размеры другой.