Полиморфизм и переопределение методов в ООП на Python. Урок 5

Методическая разработка урока
Элективный курс: Введение в объектно-ориентированное программирование на Python
Уровень: Программирование для начинающих

Полиморфизм

Парадигма объектно-ориентированного программирования помимо наследования включает еще одну важную особенность — полиморфизм. Слово «полиморфизм» можно перевести как «много форм». В ОО программировании этим термином обозначают возможность использования одного и того же имени операции или метода к объектам разных классов, при этом действия, совершаемые с объектами, могут существенно различаться. Поэтому можно сказать, что у одного и того же слова много форм. Например, два разных класса могут содержать метод total, однако инструкции в методах могут предусматривать совершенно разные операции: так в классе T1 – это прибавление 10 к аргументу, а в T2 – подсчет длины строки символов. В зависимости от того, к объекту какого класса применяется метод total, выполняются те или иные инструкции.

class T1:
     n=10
     def total(self,N):
          self.total = int(self.n) + int(N)
 
class T2:
     def total(self,s):
          self.total = len(str(s))
 
t1 = T1()
t2 = T2()
t1.total(45)
t2.total(45)
print (t1.total) # Вывод: 55
print (t2.total) # Вывод: 2

Задание. Напишите программу, запрашивающую у пользователя ввод числа. Если число принадлежит диапазону от -100 до 100, то создается объект одного класса, во всех остальных случаях создается объект другого класса. В обоих классах должен быть метод-конструктор __init__, который в первом классе возводит число в квадрат, а во-втором - умножает на два.

Ответ:

class One:
     def __init__(self,a):
          self.a = a ** 2
 
class Two:
     def __init__(self,a):
          self.a = a * 2
 
a = input ("введите число ")
a = int(a)
if -100 < a < 100:
     obj = One(a)
else:
     obj = Two(a)
 
print (obj.a) 

Переопределение методов

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

class Base:
     def __init__(self,n):
          self.numb = n
     def out(self):
          print (self.numb)
 
class One(Base):
     def multi(self,m):
          self.numb *= m
 
class Two(Base):
     def inlist(self):
          self.inlist = list(str(self.numb))
     def out(self):
          i = 0
          while i < len(self.inlist):
               print (self.inlist[i])
               i += 1
 
obj1 = One(45)
obj2 = Two('abc')
 
obj1.multi(2)
obj1.out() # Вывод числа 90
 
obj2.inlist()
obj2.out() # Вывод в столбик букв a, b, c 

В данном случае объект obj1 использует метод out из cуперкласса Base, а obj2 – из своего класса Two. Атрибуты ищутся «снизу вверх»: сначала в классах, затем суперклассах. Поскольку для obj2 атрибут out уже был найден в классе Two, то из класса Base он не используется. Другими словами, класс Two переопределят атрибут суперкласса Base.

Расширение методов

При ООП может возникнуть ситуация, когда метод суперкласса в принципе подходит для реализации того или иного действия с объектами класса, однако требует небольших изменений. В таком случае можно использовать так называемое расширение метода, когда из тела метода класса вызывается метод суперкласса и дописываются дополнительные инструкции. В примере ниже в методе класса Subclass вызывается метод другого класса (в данном случае его суперкласса; однако может вызываться метод, не принадлежащий собственному суперклассу):

class Base:
     def __init__(self,N):
          self.numb = N
     def out(self):
          self.numb /= 2 
          print (self.numb)
 
class Subclass(Base):
     def out(self):
          print ("\n----")
          Base.out(self)
          print ("----\n")
 
i = 0
while i < 10:
     if 4 < i < 7:
          obj = Subclass(i)
     else:
          obj = Base(i)
     i += 1
     obj.out()

Вывод

Полиморфизм в объектно-ориентированном программировании дает возможность реализовывать так называемые единые интерфейсы для объектов различных классов. Имеется ввиду, что если есть методы с одинаковыми названиями (или операции, обозначаемая одинаковыми знаками, как будет показано в уроке №7) для всех объектов, то это позволяет писать более очевидный исходный код. Например, разные классы могут предусматривать различный способ вывода той или иной информации объектов. Однако единое название для всех объектов метода «вывода» позволит не запутать программу, сделать ее более очевидной.

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

Практическая работа

Напишите небольшую объектно-ориентированную программку, демонстрирующую такие свойства ООП как наследование и полиморфизм.

Вот мой вариант ПР class

Вот мой вариант ПР

class main:
    def __init__(self,x=0,y=0,z=0):
        self.x = x
        self.y = y
        self.z = z
    def out(self):
        print('x=', ob.x , 'y=', ob.y, 'z=', ob.z)
 
class sub(main):
    def __init__(self,a,b,c):
        main.__init__(self)
        self.a = a
        self.b = b
        self.c = c
    def out(self):
        print('a=', ob.a , 'b=', ob.b, 'c=', ob.c)
        main.out(self)
        print('ok')
 
inp = int(input('Введите число 1 или 2'))
 
if inp == 1:
    ob = main(1,2,3)
    ob.out()
 
elif inp == 2:
    ob = sub(1,2,3)
    ob.out()
else:
    print('error')

Программка для определения

Программка для определения индекса массы тела (ИМТ), формулы найдены в инете

#супер класс IMT, в нем задаем вес и рост свой, а также
#вычисляем имт по формуле Кетле
class IMT:
    def __init__(self, v, r):
        self.ves = v
        self.rost = r
        self.rez_ketle(v, r)
    def rez_ketle(self, v, r):
        self.rezul = v/r**2
    def rezultat(self):
        print ('IMT Ketle: ves(kg)/(rost(m)**2): ',self.rezul)
 
>>> man1 = IMT(75,1.70)
>>> man1.rezultat()
IMT Ketle: ves(kg)/(rost(m)**2):  25.95155709342561
>>> 
 
#подкласс IMTclassic(IMT) интересен только тем, что содержит
#функцию с таким же именем, как в суперклассе - def rezultat(self),
#но которая считает "классику": рост в см - вес
class IMTclassic(IMT):
    def rezultat(self):
        print ('IMT classik: rost(m)*100 - ves(kg): ',self.rost*100-self.ves)
        print ('esli IMT classik < 100, eto lishniy ves')
 
>>> man2 = IMTclassic(58, 1.70)
>>> man2.rezultat()
IMT classik: rost(m)*100 - ves(kg):  112.0
esli IMT classik < 100, eto lishniy ves
>>> 
 
#подкласс TabKetle(IMT) рисует таблицу Кетле, а перед этим
#расширяется, притянув метод из суперкласса
#IMT.rezultat(self) в свой метод def tabl_imt(self):
class TabKetle(IMT):
    def tabl_imt(self):
        IMT.rezultat(self)
        print ('\t')
        for i in ['|  <18.5 |', '18.6 - 24.9|', '25.0 - 29.9|', '  >30.0  |']:
            print (i, end = ' ' )
        print ('\t')
        for i in ['|defitcit|', '   norma   |', '  izbytok  |', 'ozhirenie|']:
            print (i, end = ' ' )
 
>>> man3 = TabKetle(45,	1.72)
>>> man3.tabl_imt()
IMT Ketle: ves(kg)/(rost(m)**2):  15.210924824229314
 
|  <18.5 | 18.6 - 24.9| 25.0 - 29.9|   >30.0  | 	
|defitcit|    norma   |   izbytok  | ozhirenie| 
>>> 
 
#метод def brok(self, v) подкласса TabBrok(IMT) считает имт с
#учетом возраста, и также расширяется, но методом не из суперкласса,
#а из соседнего подкласса IMTclassic.rezultat(self)
class TabBrok(IMT):
    def brok(self, v):
        self.vozrast = v
        if v<40:
            print ('IMT Broka: <40 let: rost(cm)-100; >40 let: rost(cm)-100; ves: ',self.ves, 'Brok: ', self.rost*100-110)
        else:
            print ('IMT Broka: <40 let: rost(cm)-100; >40 let: rost(cm)-100; ves: ',self.ves, 'Brok: ', self.rost*100-100)
        IMTclassic.rezultat(self)
 
>>> man4 = TabBrok(90,1.60)
>>> man4.brok(52)
IMT Broka: <40 let: rost(cm)-100; >40 let: rost(cm)-100; ves:  90 Brok:  60.0
IMT classik: rost(m)*100 - ves(kg):  70.0
esli IMT classik < 100, eto lishniy ves
>>> 

В ДОГОНКУ К ПЕРВОМУ МОЕМУ

В ДОГОНКУ К ПЕРВОМУ МОЕМУ КОММЕНТАРИЮ!
как в питоне2 реализовать понял - просто добавить IMTclassic в скобки
class TabBrok(IMT,IMTclassic)

Уточнения для тех, кто

Уточнения для тех, кто программирует на Python 2.x:
последняя инструкция в методе brok:
IMTclassic.rezultat(self)
Не работает. Ошибка звучит так: unbound method rezultat() must be called with IMTclassic instance as first argument (got TabBrok instance instead)
Раз никто за три года не написал про это - сделал вывод:
1. все пишут на третьем Python
2. на Python2 брать методы у подклассов одного уровня не получится.
Очень надеюсь, что по второму пункту ошибаюсь.
ВОПРОС: как это в питоне3 реализовывается? ведь, действительно - инициализации класса IMTclassic не происходит ни прямо ни косвенно!