Методы

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

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

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

Вот пример нашего класса 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):
        # формула Лоренца (норма веса)
        norm = (self.height - 100) - ((self.height - 150)/2)
        if self.weight > norm:
            print("Вес данного человека превышает норму на", self.weight - norm)
        elif self.weight < norm:
            print("Вес данного человека меньше нормы на", norm - self.weight)

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

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

### результат выполнения
Вес данного человека превышает норму на 13.5

Такой метод с параметром 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):
        # формула Лоренца (норма веса)
        norm = (self.height - 100) - ((self.height - 150)/2)
        if self.weight > norm:
            print("Вес данного человека превышает норму на", self.weight - norm)
        elif self.weight < norm:
            print("Вес данного человека меньше нормы на", norm - self.weight)

    # метод класса
    @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)

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

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

Теперь создадим такой же метод, только статический (reach_passport_age2(age)). Этот метод уже не связан с классом, он видит только свои локальные переменные и не видит переменные класса. Поэтому здесь мне пришлось продублировать переменную содержащую возраст выдачи паспортов (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):
        # формула Лоренца (норма веса)
        norm = (self.height - 100) - ((self.height - 150)/2)
        if self.weight > norm:
            print("Вес данного человека превышает норму на", self.weight - norm)
        elif self.weight < norm:
            print("Вес данного человека меньше нормы на", norm - self.weight)

    # метод класса
    @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)

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

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

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

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

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

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

А вот так можем получить значение этой переменной:

private_test = PrivateTest()
# print(private_test.__y) - так вывести значение переменной не получится
private_test.print_y()

### результат выполнения
Я приватная переменная

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

Если мы создаём новый класс, то он наследуется от 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 (перемещение объекта, то есть изменение координат).

Так как дочерний класс не инициализирует родительский класс, нужно вручную выполнять функцию super(), для инициализации родительского класса.

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

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

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

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

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

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

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

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

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

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

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

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

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

А с помощью метода __mro__ можем посмотреть порядок поиска методов:

• вначале они ищутся в классе Person;






• затем в классе Doctor;






• после чего в классе Builder;






• и наконец в object.

# интерфейс (класс содержит только абстрактный метод)
class Geom:
    # абстрактный метод
    def get_pr(self):
        print("В дочернем классе должен быть переопределён метод 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

# создадим 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:
    print(g.get_pr()) # метод get_pr вызывается у соответствующего объекта - это и есть пример полиморфизма

### результат выполнения
6
14
40
80

# интерфейс (класс содержит только абстрактный метод)
class Geom:
    # абстрактный метод
    def get_pr(self):
        print("В дочернем классе должен быть переопределён метод 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())

### результат выполнения
В дочернем классе должен быть переопределён метод get_pr()
None

# интерфейс (класс содержит только абстрактный метод)
class Geom:
     # абстрактный метод
     def get_pr(self):
          print("В дочернем классе должен быть переопределён метод 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

class Y:

    # конструктор
    def __init__(self, y):
        self.y = y
    
    # этот метод выполнится, если мы будем складывать два объекта
    def __add__(self, other):
        return self.y + other.y
    
    # этот метод выполнится, если мы будем проверять, меньше ли первый объект чем второй
    def __lt__(self, other):
        if self.y < other.y:
            return "Объект 1 меньше объекта 2"
        else:
            return "Объект 1 больше объекта 2"

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

### результат выполнения
8
Объект 1 меньше объекта 2