Python 3. Классы и ООП

В этой статье разбираем классы в Python 3 и ООП на простых примерах. Узнаем про переменные и методы классов, приватные атрибуты, property, наследование, полиморфизм, перегрузку операторов и dataclass.

Классы и объекты в Python 3

На Python 3 можно писать код в стиле ООП (объектно-ориентированное программирование). То есть создавать свои классы и объекты (экземпляры классов), а затем использовать эти объекты для решения той или иной задачи.

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

Новый класс создаётся с помощью ключевого слова class, затем пишется название класса и ставится знак двоеточия. Ниже, с отступом, пишутся переменные и методы класса.

Вот пример класса Human:

class Human:
    # переменная класса
    passport_age = 14

    # конструктор
    def __init__(self, height, weight, sex, age):
        self.height = height
        self.weight = weight
        self.sex = sex
        self.age = age
  • passport_age — это переменная класса. Она относится именно к классу, а не к создаваемым объектам. Любой объект класса может прочитать значение этой переменной, но если он попробует её «изменить», то изменение затронет только его самого (ниже я это покажу).
  • __init__ — это специальный метод, который вызывается при создании объекта и задаёт ему начальные значения. То есть, создавая объект, мы должны в скобках указать его свойства (height, weight, sex, age).
  • self — это ссылка на создаваемый объект класса.

Чтобы стало понятнее, разберу процесс создания экземпляров класса:

alex = Human(height=165, weight=71, sex='man', age=30)
elena = Human(160, 50, 'woman', 30)
print(alex.sex)
print(elena.sex)

Исполнение:

man
woman

Для создания объекта класса мы должны указать имя объекта (в примере это alex и elena). Затем, после знака равенства, указать класс и в скобках передать параметры, которые мы указали в методе __init__ в классе. Параметры можно указывать либо по порядку (как мы сделали для elena), либо с указанием имени параметра и его значением (как мы сделали для alex).

Обратите внимание, что параметр self мы при создании объекта не передаём. Python подставляет его сам.

Переменные класса

С помощью записи имя_объекта.переменная (alex.passport_age) мы можем получить значение переменной. Python сначала ищет эту переменную в самом объекте, а если не находит, то ищет в классе.

Чтобы убедиться, что это переменная класса, а не объекта, попробуем изменить значение этой переменной у одного из объектов:

Код:

alex = Human(height=165, weight=71, sex='man', age=30)
elena = Human(160, 50, 'woman', 30)

# пытаемся изменить переменную passport_age у alex
# а фактически создаём новую переменную в объекте alex
alex.passport_age = 16

print(alex.passport_age)
print(elena.passport_age)

Исполнение:

16
14

Как видим, у elena значение переменной passport_age не изменилось, оно всё также берётся из класса. А у объекта alex значение этой переменной изменилось, оно уже берётся локально из объекта, а не из класса. Мы не изменили переменную класса, а создали в объекте alex новую переменную с таким же именем, которая «заслонила» переменную класса.

Чтобы посмотреть значение переменной класса, можно либо напрямую обратиться к классу (Human.passport_age), либо через атрибут __class__ (alex.__class__.passport_age), который хранит ссылку на класс объекта:

Код:

alex = Human(height=165, weight=71, sex='man', age=30)
alex.passport_age = 16
print(Human.passport_age)
print(alex.__class__.passport_age)

Исполнение:

14
14

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

alex = Human(height=165, weight=71, sex='man', age=30)
elena = Human(160, 50, 'woman', 30)

# у alex появляется собственная переменная
alex.passport_age = 16

# меняем переменную самого класса
Human.passport_age = 18

print(elena.passport_age)
print(alex.passport_age)

Исполнение:

18
16

У elena своей переменной passport_age нет, поэтому она берёт значение из класса и видит новое значение (18). А у alex есть собственная переменная, поэтому изменение класса его не затронуло.

Метод __init__ и переменные объекта

С переменной класса разобрались, теперь разберёмся с методом __init__ в классе. Этот метод ещё называют конструктором. Строго говоря, сам объект создаёт другой метод (__new__), а __init__ только заполняет уже созданный объект начальными значениями. Но на практике __init__ почти всегда и называют конструктором, а __new__ нам почти никогда не нужен.

Как я уже писал, __init__ позволяет в процессе создания объекта задать ему переменные. В нашем случае при создании объекта нужно задать переменные height, weight, sex, age. А переменная self будет ссылаться на созданный объект.

То есть создавая объект таким образом alex = Human(height=165, weight=71, sex='man', age=30), у нас получится:

  • alex — это имя объекта;
  • height=165 — попадёт в переменную объекта self.height, а так как self ссылается на объект, то в alex.height;
  • weight=71 — попадёт в переменную объекта alex.weight;
  • sex=‘man’ — попадёт в переменную объекта alex.sex;
  • age=30 — попадёт в переменную объекта alex.age.

Все эти переменные (alex.height, alex.weight, alex.sex, alex.age) — это переменные объекта, а не класса.

Посмотреть все переменные объекта можно с помощью атрибута __dict__:

alex = Human(height=165, weight=71, sex='man', age=30)
print(alex.__dict__)

Исполнение:

{'height': 165, 'weight': 71, 'sex': 'man', 'age': 30}

А в процессе работы объекту можно добавлять новые переменные с помощью конструкции имя_объекта.имя_переменной = значение:

Код:

alex.city = 'Moscow'
print(alex.city)

Исполнение:

Moscow

Эта переменная появится только у объекта alex. У других объектов класса Human её не будет.

Методы

Обычные методы

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

Давайте добавим классу Human метод norm_weight(). Этот метод будет рассчитывать, какой вес для данного роста является нормальным, и проверять, нормальный ли вес у этого человека. Для расчёта нормального веса я использую формулу Лоренца . Для мужчин в ней рост сначала уменьшается на 100, а затем из результата вычитается четверть разницы между ростом и 150. Для женщин вычитается половина этой разницы.

Вот пример нашего класса Human с добавленным методом расчёта нормального веса norm_weight():

Код:

class Human:
    # переменная класса
    passport_age = 14

    # конструктор
    def __init__(self, height, weight, sex, age):
        self.height = height
        self.weight = weight
        self.sex = sex
        self.age = age

    # метод
    def norm_weight(self):
        # формула Лоренца (норма веса)
        if self.sex == 'man':
            norm = (self.height - 100) - (self.height - 150) / 4
        else:
            norm = (self.height - 100) - (self.height - 150) / 2

        if self.weight > norm:
            print("Вес данного человека превышает норму на", self.weight - norm)
        elif self.weight < norm:
            print("Вес данного человека меньше нормы на", norm - self.weight)
        else:
            print("Вес данного человека в норме")

Теперь создадим экземпляры класса и проверим, в норме ли у них вес:

alex = Human(height=165, weight=71, sex='man', age=30)
elena = Human(160, 50, 'woman', 30)
alex.norm_weight()
elena.norm_weight()

Исполнение:

Вес данного человека превышает норму на 9.75
Вес данного человека меньше нормы на 5.0

Такой метод с параметром self принадлежит объекту, поэтому и вызывается через объект (alex.norm_weight()).

Но мы можем создавать и методы самого класса, которые вызываются без создания объектов. Для их создания существуют декораторы:

  • @classmethod — создаёт метод класса. Такой метод получает ссылку на класс и может работать с переменными класса.
  • @staticmethod — создаёт статический метод. Такой метод не получает ни ссылку на объект, ни ссылку на класс. Он работает только с тем, что ему передадут.

Методы класса (@classmethod)

Создавая метод класса с помощью декоратора @classmethod, нужно вместо слова self (ссылки на объект) использовать cls (ссылку на класс).

Дополним наш класс методом reach_passport_age(cls, age). Он будет связан с классом (cls) и будет принимать параметр (age). Весь код нового класса:

class Human:
    # переменная класса
    passport_age = 14

    # конструктор
    def __init__(self, height, weight, sex, age):
        self.height = height
        self.weight = weight
        self.sex = sex
        self.age = age

    # метод
    def norm_weight(self):
        # формула Лоренца (норма веса)
        if self.sex == 'man':
            norm = (self.height - 100) - (self.height - 150) / 4
        else:
            norm = (self.height - 100) - (self.height - 150) / 2

        if self.weight > norm:
            print("Вес данного человека превышает норму на", self.weight - norm)
        elif self.weight < norm:
            print("Вес данного человека меньше нормы на", norm - self.weight)
        else:
            print("Вес данного человека в норме")

    # метод класса
    @classmethod
    def reach_passport_age(cls, age):
        if age >= cls.passport_age:
            print("Человек достиг возраста, когда ему выдают паспорт.")
        else:
            print("Человек ещё не достиг возраста, когда ему выдают паспорт.")

И теперь мы можем работать с методом класса, не создавая объекты класса:

Код:

Human.reach_passport_age(12)
Human.reach_passport_age(15)

Исполнение:

Человек ещё не достиг возраста, когда ему выдают паспорт.
Человек достиг возраста, когда ему выдают паспорт.

Метод класса можно вызвать и через объект (alex.reach_passport_age(12)), результат будет такой же, ведь cls всё равно ссылается на класс.

Альтернативный конструктор

Методы класса часто используют для создания альтернативных конструкторов. Допустим, данные о человеке приходят к нам одной строкой, например "170,65,man,25". Мы можем добавить в класс метод from_string(), который разберёт строку и вернёт готовый объект. Чтобы не дублировать весь класс, покажу только нужные части:

class Human:
    passport_age = 14

    def __init__(self, height, weight, sex, age):
        self.height = height
        self.weight = weight
        self.sex = sex
        self.age = age

    # альтернативный конструктор
    @classmethod
    def from_string(cls, text):
        height, weight, sex, age = text.split(',')
        return cls(int(height), int(weight), sex, int(age))


bob = Human.from_string("170,65,man,25")
print(bob.height, bob.weight, bob.sex, bob.age)

Исполнение:

170 65 man 25

Здесь cls(...) — это то же самое, что Human(...). Но если потом мы создадим класс-наследник, то метод вернёт объект именно этого наследника, а не родителя.

Статические методы класса (@staticmethod)

Теперь создадим такой же метод, только статический (reach_passport_age2(age)). Этот метод не получает ссылку на класс, поэтому он не видит переменные класса через cls. Здесь мне пришлось продублировать переменную, содержащую возраст выдачи паспорта (pass_age = 14). Вот полный код класса с добавленным методом:

Код:

class Human:
    # переменная класса
    passport_age = 14

    # конструктор
    def __init__(self, height, weight, sex, age):
        self.height = height
        self.weight = weight
        self.sex = sex
        self.age = age

    # метод
    def norm_weight(self):
        # формула Лоренца (норма веса)
        if self.sex == 'man':
            norm = (self.height - 100) - (self.height - 150) / 4
        else:
            norm = (self.height - 100) - (self.height - 150) / 2

        if self.weight > norm:
            print("Вес данного человека превышает норму на", self.weight - norm)
        elif self.weight < norm:
            print("Вес данного человека меньше нормы на", norm - self.weight)
        else:
            print("Вес данного человека в норме")

    # метод класса
    @classmethod
    def reach_passport_age(cls, age):
        if age >= cls.passport_age:
            print("Человек достиг возраста, когда ему выдают паспорт.")
        else:
            print("Человек ещё не достиг возраста, когда ему выдают паспорт.")

    # статический метод класса
    @staticmethod
    def reach_passport_age2(age):
        pass_age = 14
        if age >= pass_age:
            print("Человек достиг возраста, когда ему выдают паспорт.")
        else:
            print("Человек ещё не достиг возраста, когда ему выдают паспорт.")

То есть в классе появляется обычная функция, которая никак не связана ни с экземплярами класса, ни с самим классом. Класс просто содержит эту функцию, потому что она по смыслу относится к нему.

А работает всё точно так же:

Human.reach_passport_age2(12)
Human.reach_passport_age2(15)

Исполнение:

Человек ещё не достиг возраста, когда ему выдают паспорт.
Человек достиг возраста, когда ему выдают паспорт.

Дублировать значение (pass_age = 14) — не лучшая идея: если возраст изменится, то править придётся в двух местах. Поэтому, если методу нужны данные класса, лучше использовать @classmethod. А @staticmethod подходит для вспомогательных функций, которым данные класса не нужны.

Приватные переменные

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

Для примера я напишу новый тестовый класс PrivateTest, в котором размещу приватную переменную __y. В этом же классе я создам метод print_y(), который будет выводить значение переменной __y:

Код:

class PrivateTest:
    def __init__(self):
        self.__y = "Я приватная переменная"

    # метод для обращения к приватной переменной
    def print_y(self):
        print(self.__y)

Попробуем обратиться к переменной через метод и напрямую:

private_test = PrivateTest()
private_test.print_y()
print(private_test.__y)

Исполнение:

Я приватная переменная
AttributeError: 'PrivateTest' object has no attribute '__y'

Напрямую вывести значение не получилось, а через метод получилось.

Но на самом деле в Python нет настоящей защиты. Интерпретатор просто переименовывает переменную с двойным подчёркиванием, добавляя в начало имя класса. Этот приём называется name mangling. Посмотрим, как переменная хранится в объекте:

print(private_test.__dict__)
print(private_test._PrivateTest__y)

Исполнение:

{'_PrivateTest__y': 'Я приватная переменная'}
Я приватная переменная

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

В повседневной практике чаще используют соглашение: если имя начинается с одного подчёркивания (_y), то это «внутренняя» переменная, и снаружи класса её трогать не стоит. Python это не запрещает, но все программисты понимают такую запись.

Свойства (@property)

Если нужно контролировать, что записывается в переменную объекта, то используют свойства. Снаружи свойство выглядит как обычная переменная, но при чтении и записи выполняется наш код. Например, запретим задавать вес меньше или равный нулю:

class Person:
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight    # здесь сработает setter

    # чтение (getter)
    @property
    def weight(self):
        return self._weight

    # запись (setter)
    @weight.setter
    def weight(self, value):
        if value <= 0:
            raise ValueError("Вес должен быть больше нуля")
        self._weight = value

alex = Person("Alex", 71)
print(alex.weight)
alex.weight = 70
print(alex.weight)
alex.weight = -5

Исполнение:

71
70
ValueError: Вес должен быть больше нуля

Мы обращаемся к alex.weight как к обычной переменной, а проверка выполняется автоматически. Само значение хранится в «внутренней» переменной _weight.

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

В Python 3 любой класс по умолчанию наследуется от object, даже если мы это не указываем. Но мы можем создать ещё один класс, который будет наследоваться от первого класса.

При наследовании дочерний класс получает доступ к методам и переменным родительского класса.

Чтобы указать, что класс Circle будет наследоваться от класса Shape, а не от object, нужно при создании класса Circle в скобках указать Shape.

Вот пример всех трёх классов:

# фигура
class Shape:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move(self, delta_x, delta_y):
        self.x = self.x + delta_x
        self.y = self.y + delta_y

# квадрат
class Square(Shape):
    def __init__(self, side=1, x=0, y=0):
        super().__init__(x, y)
        self.side = side

# круг
class Circle(Shape):
    def __init__(self, radius=1, x=0, y=0):
        super().__init__(x, y)
        self.radius = radius

Любой объект класса Shape будет иметь параметры: x и y (координаты). А также будет иметь метод: move (перемещение объекта, то есть изменение координат).

Если дочерний класс создаёт собственный метод __init__, то __init__ родителя автоматически не вызывается. Поэтому нужно вручную вызвать его с помощью функции super(). Именно это мы и делаем в строке super().__init__(x, y).

Любой объект класса:

  • Square дополнительно имеет атрибут side (размер стороны);
  • Circle имеет дополнительный атрибут radius (радиус).

После создания классов мы можем создать объекты, а затем изменить их координаты с помощью метода move():

# создание круга и квадрата
my_circle = Circle(x=10, y=5)
my_square = Square(x=20, y=5)

# перемещение круга и квадрата
my_circle.move(10, 5)
my_square.move(10, 3)

# вывод координат и свойств фигур
print("Координаты нашего круга:", my_circle.x, "x", my_circle.y, "Радиус =", my_circle.radius)
print("Координаты нашего квадрата:", my_square.x, "x", my_square.y, "Сторона =", my_square.side)

Исполнение:

Координаты нашего круга: 20 x 10 Радиус = 1
Координаты нашего квадрата: 30 x 8 Сторона = 1

Наследование позволяет уменьшить количество кода. В нашем случае нам не пришлось создавать переменные x и y и метод move для классов Square и Circle, всё это они наследуют от класса Shape.

Проверить, относится ли объект к определённому классу (с учётом наследования), можно с помощью функций isinstance() (объект и класс) и issubclass() (класс и класс):

Код:

print(isinstance(my_circle, Shape))
print(isinstance(my_circle, Square))
print(issubclass(Circle, Shape))

Исполнение:

True
False
True

Круг является фигурой (Shape), но не является квадратом (Square).

Множественное наследование

Класс может наследоваться от нескольких классов. Для этого при создании класса нужно в скобках указать несколько родителей, например class Person(Doctor, Builder).

При этом методы и переменные вначале ищутся в своём классе, затем во всех родительских, начиная слева направо. Выполняться будет первый найденный метод. Порядок поиска называется MRO (Method Resolution Order).

Итак, реализуем наши классы:

class Doctor:
    def can_cure(self):
        print("Я доктор, я умею лечить")
    def can_build(self):
        print("Я доктор, я умею строить, но не очень")

class Builder:
    def can_build(self):
        print("Я строитель, я умею строить")
    def can_cure(self):
        print("Я строитель, я умею лечить, но не очень")

# MRO - Method Resolution Order (порядок поиска методов слева направо)
class Person(Doctor, Builder):
    pass

Любой объект класса Doctor будет иметь два метода can_cure() и can_build(). Любой объект класса Builder будет иметь такие же методы, но они будут выводить немного другую информацию.

При создании класса Person мы в скобках вначале указали Doctor, а затем Builder. Из этого следует, что любой объект класса Person будет больше доктором, чем строителем. То есть методы can_cure() и can_build() будут браться из класса Doctor, так как поиск найдёт их там первыми.

Код:

alex = Person()
alex.can_build()
alex.can_cure()
print(Person.__mro__)  # смотрим порядок поиска методов

Исполнение:

Я доктор, я умею строить, но не очень
Я доктор, я умею лечить
(<class '__main__.Person'>, <class '__main__.Doctor'>, <class '__main__.Builder'>, <class 'object'>)

С помощью атрибута __mro__ (или метода Person.mro()) можем посмотреть порядок поиска методов:

  • вначале они ищутся в классе Person;
  • затем в классе Doctor;
  • после чего в классе Builder;
  • и наконец в object.

Полиморфизм, абстрактные методы и интерфейсы

Полиморфизм — это возможность работать с разными объектами единым образом. Мы вызываем один и тот же метод, а что именно произойдёт, зависит от объекта.

Например, мы можем сделать класс Geom для создания объектов (геометрических фигур). Затем мы можем сделать два класса Rectangle (прямоугольник) и Square (квадрат) — наследники от Geom.

В классах Rectangle и Square сделаем одноимённый метод get_pr(), который будет находить периметр данной фигуры.

При этом в родительском классе нужно тоже сделать метод get_pr(), но он будет формальный. Его нужно будет обязательно переопределять в дочерних классах. Этот метод имеет лишь одну цель — дать понять программисту, что в дочернем классе этот метод нужно не забыть переопределить.

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

Итак, реализуем наши классы на Python 3. Чтобы забытый метод не прошёл незамеченным, в родительском классе будем вызывать исключение NotImplementedError:

# интерфейс (класс содержит только абстрактный метод)
class Geom:
    # абстрактный метод
    def get_pr(self):
        raise NotImplementedError("В дочернем классе должен быть переопределён метод get_pr()")

class Rectangle(Geom):
    def __init__(self, w, h):
        self.w = w
        self.h = h

    def get_pr(self):
        return 2 * (self.w + self.h)

class Square(Geom):
    def __init__(self, a):
        self.a = a

    def get_pr(self):
        return 4 * self.a

Здесь класс Square — это новый класс для этого примера, он не связан с Square из раздела про наследование.

Теперь мы можем создать объекты наших классов и вычислить их периметры в цикле, выполняя один и тот же метод — get_pr():

# создадим 4 объекта
my_rectangle1 = Rectangle(1, 2)
my_rectangle2 = Rectangle(3, 4)
my_square1 = Square(10)
my_square2 = Square(20)

# пробежимся по списку наших объектов и определим их периметр
geom = [my_rectangle1, my_rectangle2, my_square1, my_square2]
for g in geom:
    # метод get_pr вызывается у соответствующего объекта - это и есть пример полиморфизма
    print(g.get_pr())

Исполнение:

6
14
40
80

Теперь, если программист напишет новый класс, например Triangle(Geom) (треугольник), и забудет переопределить метод get_pr(), то программа ему об этом скажет:

Код:

class Triangle(Geom):
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c

my_triangle = Triangle(4, 6, 7)
print(my_triangle.get_pr())

Исполнение:

NotImplementedError: В дочернем классе должен быть переопределён метод get_pr()

Программист поймёт свою ошибку и добавит метод:

class Triangle(Geom):
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c

    def get_pr(self):
        return self.a + self.b + self.c

my_triangle = Triangle(4, 6, 7)
print(my_triangle.get_pr())

Исполнение:

17

Модуль abc

Способ с NotImplementedError рабочий, но у него есть недостаток: об ошибке мы узнаем только в момент вызова метода. В Python есть стандартный модуль abc (Abstract Base Classes), который позволяет сделать настоящие абстрактные методы. Тогда ошибка возникнет уже при создании объекта:

from abc import ABC, abstractmethod

class Geom(ABC):
    @abstractmethod
    def get_pr(self):
        pass

class Triangle(Geom):
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c

my_triangle = Triangle(4, 6, 7)

Исполнение:

TypeError: Can't instantiate abstract class Triangle without an implementation for abstract method 'get_pr'

Python не даёт создать объект, пока в дочернем классе не будут переопределены все абстрактные методы. Это надёжнее, поэтому в больших проектах обычно используют именно abc.

Утиная типизация

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

class Duck:
    def say(self):
        print("Кря")

class Dog:
    def say(self):
        print("Гав")

for animal in (Duck(), Dog()):
    animal.say()

Исполнение:

Кря
Гав

Классы Duck и Dog никак не связаны между собой, но с ними можно работать единым образом.

Перегрузка операторов

Перегрузка операторов — это придание альтернативного значения какому-то действию. Например, оператор сложения (+) может выполнить сложение двух чисел, объединить две строки или объединить два списка.

Python 3 позволяет выполнять одному оператору разные действия в зависимости от типа объекта. Для этого в классе используются специальные методы (их ещё называют «магическими» или «dunder-методами», от англ. double underscore), которые вызываются автоматически.

В своём классе мы можем использовать, например, такие специальные методы:

  • __add__ (для сложения);
  • __sub__ (для вычитания);
  • __mul__ (для умножения);
  • __truediv__ (для деления);
  • __floordiv__ (целочисленное деление);
  • __mod__ (остаток от деления);
  • __lt__ (меньше);
  • __gt__ (больше);
  • __le__ (меньше или равно);
  • __ge__ (больше или равно);
  • __eq__ (равно);
  • __ne__ (не равно);
  • __str__ (строковое представление объекта, которое используется в print());
  • __len__ (длина объекта, которую возвращает len()).

Для перегрузки оператора в своём классе мы должны написать один из этих методов и задать ему код. Вот пример:

class Y:
    # конструктор
    def __init__(self, y):
        self.y = y

    # этот метод выполнится, если мы будем складывать два объекта
    def __add__(self, other):
        return Y(self.y + other.y)

    # этот метод выполнится, если мы будем проверять, меньше ли первый объект, чем второй
    def __lt__(self, other):
        return self.y < other.y

    # этот метод выполнится, когда объект выводят через print()
    def __str__(self):
        return f"Y({self.y})"

Мы сделали класс Y, объекты которого будут иметь параметр y. В нём мы определили три метода (помимо конструктора init):

  • __add__ — этот метод будет вызываться, когда мы будем складывать два объекта. Он возвращает новый объект класса Y;
  • __lt__ — этот метод будет вызываться, когда мы будем проверять, меньше ли первый объект, чем второй. Методы сравнения должны возвращать True или False;
  • __str__ — этот метод позволяет красиво выводить объект через print().

Вот как это работает:

obj1 = Y(3)
obj2 = Y(5)
print(obj1 + obj2)
print(obj1 < obj2)
print(obj1 > obj2)

Исполнение:

Y(8)
True
False

Обратите внимание, что метод __gt__ (больше) мы не писали, а obj1 > obj2 работает. Python сам заменяет эту запись на obj2 < obj1 и вызывает __lt__. Но надеяться на это лучше только для простых случаев.

Не создав этих методов в классе, объекты класса нельзя было бы складывать и сравнивать. Например, мы не создавали __sub__, поэтому вычитание не сработает:

print(obj1 - obj2)

Исполнение:

TypeError: unsupported operand type(s) for -: 'Y' and 'Y'

Dataclass: меньше кода для простых классов

Часто классы нужны только для хранения данных. Тогда приходится писать однотипный __init__, а также методы для вывода и сравнения. Чтобы не писать всё это вручную, в Python есть декоратор @dataclass из модуля dataclasses. Он сам создаёт эти методы по списку переменных:

from dataclasses import dataclass

@dataclass
class Point:
    x: int = 0
    y: int = 0

p1 = Point(1, 2)
print(p1)
print(p1 == Point(1, 2))
print(Point())

Исполнение:

Point(x=1, y=2)
True
Point(x=0, y=0)

Мы не писали ни __init__, ни __str__, ни __eq__, но объекты создаются, красиво выводятся и сравниваются по значениям. Запись x: int = 0 означает: переменная x, тип int (это подсказка для программиста, Python его не проверяет), значение по умолчанию 0.

Итог

Мы узнали, как можно использовать классы и объекты на Python 3. Также узнали про параметры классов и объектов (переменные) и про то, чем они отличаются.

Разобрались с методами (функциями в классе). Есть обычные методы, методы класса и статические методы класса.

Узнали, что можно использовать приватные переменные в классе, имена которых начинаются на два подчёркивания, и что на самом деле это не защита, а переименование (name mangling). А также познакомились со свойствами (@property).

Узнали про наследование классов и про то, что любой класс по умолчанию наследуется от object. А также познакомились с множественным наследованием и MRO (поиском методов слева направо).

Узнали про полиморфизм, абстрактные методы, интерфейсы, модуль abc и утиную типизацию. Разобрались с перегрузкой операторов. И познакомились с @dataclass, который избавляет от лишнего кода в простых классах.


Если понравилась статья, подпишись на мой канал в VK или Telegram .