Наследование и исключения

Полиморфизм в случае duck typing всего один, зато тотальный ☺

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

Просто: 

   1 class New(Old):
   2     # поля и методы, возможно, перекрывающие Old.что-то-там

Видимость:

Вызов конструктора (например, для операция типа «"+"»): 

   1 class A:
   2     …
   3     def __add__(self, other):
   4         return type(self)(self.val + other.val)
   5     …

Использование A(self.val + other.val) неправильно, т. к. подменяет тип. 

   1 class B(A):
   2         pass

Какого типа должно быть B()+B()?

Родительский прокси-объект super()

Вызов методов базового класса: 

   1 class A:
   2     def fun(self):
   3         return "A"
   4 
   5 class B(A):
   6     def fun(self):
   7         return super().fun()+"B"

Защита от коллизии имён

   1 >>> class C:
   2 ...     __A=1
   3 ...
   4 >>> dir(C)
   5 ['_C__A', '__class__', '__delattr__', …
   6

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

Линеаризация

Создание линейного списка родительских классов для поиска полей в нём (Method Resolution Order, MRO).

MRO C3

Общий принцип

Пример

   1 O = object
   2 class F(O): pass
   3 class E(O): pass
   4 class D(O): pass
   5 class C(D,F): pass
   6 class B(D,E): pass
   7 class A(B,C): pass

Но если (B(E,D) вместо B(D,E)): 

   1 O = object
   2 class F(O): pass
   3 class E(O): pass
   4 class D(O): pass
   5 class C(D,F): pass
   6 class B(E,D): pass
   7 class A(B,C): pass


   1 >>> B.mro()
   2 [<class '__main__.B'>, <class '__main__.E'>, <class '__main__.D'>, <class 'object'>]
   3 >>> A.mro()
   4 [<class '__main__.A'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.D'>, <class '__main__.F'>, <class 'object'>]
   5

Соответственно, нет решения для X, но есть для Y: 

   1 class A: pass
   2 class B(A): pass
   3 class X(A, B): pass
   4 class Y(B, A): pass

super(): 

   1 class A:
   2     def __new__(cls, *args):
   3         print(f"New A: {cls}, {args}")
   4         return super().__new__(cls, *args)
   5 
   6     def f(self):
   7         return f"A: {self}"
   8 
   9     def __str__(self):
  10         return f"<{type(self).__name__}>"
  11 
  12 class B:
  13     def __new__(cls, *args):
  14         print(f"New B: {cls}, {args}")
  15         return super().__new__(cls, *args)
  16 
  17     def g(self):
  18         return f"G: {self}"
  19 
  20     def __str__(self):
  21         return f"<<{type(self).__name__}>>"
  22 
  23 class AB(A, B):
  24     def __new__(cls, *args):
  25         print(f"New: {cls}, {args}")
  26         return super().__new__(cls, *args)
  27 
  28 ab = AB()
  29 print(ab, ab.f(), ab.g())

→ 

New: <class '__main__.AB'>, ()
New A: <class '__main__.AB'>, ()
New B: <class '__main__.AB'>, ()
<AB> A: <AB> G: <AB>

Обратите внимание на вызов обоих __new__() из super().__new__

Проксирование

Хранить родительский объект в виде поля, а все методы нового класса делать обёрткой вокруг методов родительского объекта.

Исключения

Исключения – это механизм управления вычислительным потоком, который завязан на разнесении по коду проверки свойств данных и обработки результатов этой проверки.

Синтаксическая ошибка SyntaxError — не обрабатывается (ещё такие ошибки?)

Оператор try:

Оператор `raise`

Исключения — не «ошибки», а способ обработки некоторых условий не там, где они были обнаружены.

Пример: 

   1 class Exc1(Exception): pass
   2 class Exc2(Exception): pass
   3 
   4 def funerr(a,b):
   5     if a<b:
   6         raise Exc1("A must be greater than B")
   7     return a//b
   8 
   9 def justfun(a,b):
  10     if a<b:
  11         raise Exc2("A must be greater than B")
  12     c = funerr(2*a, 3*b)
  13     return c
  14 
  15 for a,b in (10,3),(5,5),(10,0):
  16     try:
  17         c = justfun(a,b)
  18     except Exc1:
  19         c = -1
  20     except Exc2:
  21         c = -2
  22     except ZeroDivisionError:
  23         c = -3
  24     print(c)

На следующую лекцию: локальность имени в операторе as: 

   1 try:
   2     raise Exception("QQ!", "QQ!", "QQ-QRKQ.")
   3 except Exception as E:
   4     print(F:=E)
   5 
   6 print( f"{F=}" if "F" in globals() else "No F")
   7 print( f"{E=}" if "E" in globals() else "No E")


('QQ!', 'QQ!', 'QQ-QRKQ.')
F=Exception('QQ!', 'QQ!', 'QQ-QRKQ.')
No E

Д/З

  1. Прочитать:

  2. EJudge: MroC3 'MRO C3'

    Написать программу, на вход которой подаётся ситнаксически верный код на ЯП Python, без пустых строк и многострочных констант; пустая только последняя строка. В этом коде

    • Могут быть определены некоторые классы с помощью оператора class на верхнем уровне программы (т. е. не внутри классов/функций)

    • Имена классов не меняются (т. е. после class C: … никогда не бывает C = …)

    • В наследовании используются только уже определённые в этом коде классы

    • На выходе программа должна отчитаться, допустимо ли наследование, которое (возможно) встретилось в коде (с точки зрения NRO C3), и вывести "Yes" или "No".

    Input: 

    class A:
    B = 0
class B(A): pass
class C(A, B):
    A = B = C = 5
    Output: 

    No

  3. EJudge: BoldCalc 'Надёжный калькулятор'

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

    • Пробелы в строках игнорируются

    • Команда, начинающаяся на '#' — комментарий, такие команды игнорируются

    • Команда вида Идентификатор = выражение задаёт переменную Идентификатор

      • идентификатор определяется стандартно: «произвольная последовательность латинских букв, цифр и символов подчёркивания не начинающаяся с цифры»

      • Если слева от "=" стоит не идентификатор, выводится "Assignment error"; всё, что справа, игнорируется, присваивания не происходит

    • Команда вида выражение выводит значение выражения.

    • Выражение вычисляется по правилам арифметики, и может состоять из

      • целых чисел

      • уже определённых идентификаторов
      • круглых скобок, внутри которых должно находиться непустое выражение

      • действий +, -, *, /, % и унарных + и -.

        • Деление целочисленное

      • Любое другое выражение приводит к выводу ошибки "Syntax error"

    • Если выражение нельзя вычислить, потому что в нём встречаются неопределённые переменные, выводится ошибка "Name error"

    • Если выражение нельзя вычислить по какой-то другой причине, выводится "Runtime error"

    Input: 

    # Ошибок нет
234
10/3
A = 3*(2+(1-7)%5)
A+100
+ ++ - -- - + - - 0
# Начинаются ошибки
7*B
3=3
A=4=5
A()
A/0
    Output: 

    234
3
118
0
Name error
Assignment error
Syntax error
Syntax error
Runtime error

  4. EJudge: SubString 'Строки с вычитанием'

    Реализовать класс SubString, который бы полностью воспроизводил поведение str, но вдобавок бы поддерживал операцию вычитания строк. Вычитание устроено так: «уменьшаемое» просматривается посимвольно, и если соответствующий символ присутствует в «вычитаемом», то он однократно удаляется из обеих строк. Исходные объекты не меняются; то, что осталось от уменьшаемого, объявляется результатом вычитания.

    • К моменту прохождения теста ничего нового, кроме класса SubString в глобальном пространстве имён быть не должно

    Input: 

       1 print(SubString("qwertyerty")-SubString("ttttr"))
    Output: 

    qweyery

LecturesCMC/PythonIntro2020/10_Inheritance (последним исправлял пользователь FrBrGeorge 2020-11-21 12:52:39)