Объектная модель Python

Объектно-ориентированное_программирование: Поддержка в ЯП объектного проектирования.

• Не «парадигма» (в строгом смысле)
• Не привилегия ЯП (можно писать ООП-программы на Си)

• Статья с Википедии вполне философская, почитайте её ☺, она вообще про управление!

Три составляющих ООП:

0. Абстракция (общее/частное).

   • Примеры «вертикальной» абстракции: класс/экземпляр класса, базовый класс/производный класс и т. п. (Python: +метакласс)
   • Примеры «горизонтальной» абстракции моделирование различных сущностей предметной области одинаковыми структурами ЯП

1. Инкапсуляция: минимализация необходимого информационно пространства; часто — за счёт создания иерархии пространств имён (большинство языков: размещение в одном компоненте данных и методов, которые с ними работают)

   • не смешивать с сокрытием

2. Наследование: повторное использование свойств объектов с описанием различий

3. Полиморфизм (а вот эту статью на Википедии не стоит читать на полном серьёзе): возможность для одного и того же кода обрабатывать данные разных типов (Python: duck typing!)

Статья «Классы в Python3 — это очень просто»

   1 >>> l=()
   2 >>> dir(l)
   3 ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
   4 >>> l.new="QQ"
   5 Traceback (most recent call last):
   6   File "<stdin>", line 1, in <module>
   7 AttributeError: 'tuple' object has no attribute 'new'

   1 >>> class C:
   2 ...   pass
   3 ...
   4 >>> dir(C)
   5 ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
   6 >>> c=C()
   7 >>> dir(c)
   8 ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
   9 >>> c
  10 <__main__.C object at 0x7f39429f92b0>
  11 >>> C
  12 <class '__main__.C'>

   1 >>> c.new="QQ"
   2 >>> dir(c)
   3 ['__class__', …, 'new']
   4 >>> c.new
   5 'QQ'

   1 >>> C.strange="NN"
   2 >>> dir(C)
   3 ['__class__', …, 'strange']
   4 [
   5 >>> dir(c)
   6 ['__class__', …, 'new', 'strange']
   7 >>> c.strange
   8 'NN'

   1 >>> d=C()
   2 >>> dir(d)
   3 ['__class__', …, 'strange']
   4 >>> d.strange='YY'
   5 >>> c.strange
   6 'NN'
   7 >>> C.strange
   8 'NN'
   9 >>> d.strange
  10 'YY'

   1 >>> d.strange
   2 'YY'
   3 >>> del d.strange
   4 >>> d.strange
   5 'NN'

   1 >>> del d.strange
   2 Traceback (most recent call last):
   3   File "<stdin>", line 1, in <module>
   4 AttributeError: strange
   5 >>> dir(d)
   6 ['__class__', …, '__weakref__', 'strange']
   7 >>> del C.strange
   8 >>> d.strange
   9 Traceback (most recent call last):
  10   File "<stdin>", line 1, in <module>
  11 AttributeError: 'C' object has no attribute 'strange'
  12 >>> dir(d)
  13 ['__class__', …]
  14 >>> dir(C)
  15 ['__class__', …]

   1 >>> class D:
   2 ...   w=10
   3 ...   h=20
   4 ...
   5 >>> d=D()
   6 >>> d.w, d.h
   7 (10, 20)

   1 >>> e=D()
   2 >>> e.w, e.h = 18, 11
   3 >>> d.w*d.h-e.w*e.h
   4 2

   1 >>> class E:
   2 ...   l=[]
   3 ...
   4 >>> e=E()
   5 >>> e.l, E.l
   6 ([], [])
   7 >>> e.l.append("QQ")
   8 >>> e.l, E.l
   9 (['QQ'], ['QQ'])

   1 >>> f=E()
   2 >>> f.l=[]
   3 >>> e.l, f.l, E.l
   4 (['QQ'], [], ['QQ'])
   5 >>> f.l.append("Q-K-R-Q")
   6 >>> e.l, f.l, E.l
   7 (['QQ'], ['Q-K-R-Q'], ['QQ'])

   1 >>> class F:
   2 ...   data = "dada"
   3 ...
   4 >>> def fun():
   5 ...   print(F.data)
   6 ...
   7 >>> f=F()
   8 >>> f.pri=fun
   9 >>> f.pri()
  10 dada
  11 >>> f.data = "nono"
  12 >>> f.pri()
  13 dada

   1 >>> class G:
   2 ...   d = 1
   3 ...   def fun(obj):
   4 ...     print(obj.d)
   5 ...
   6 >>> g=G()
   7 >>> g.fun(g)
   8 Traceback (most recent call last):
   9   File "<stdin>", line 1, in <module>
  10 TypeError: fun() takes 1 positional argument but 2 were given

   1 >>> class H:
   2 ...   def test(p1, p2):
   3 ...     print(p1, p2)
   4 ...
   5 >>> h=H()
   6 >>> h.test(100500)
   7 <__main__.H object at 0x7feffab3fdd8> 100500
   8 >>> h
   9 <__main__.H object at 0x7feffab3fdd8>
  10 >>> H.test(h,"I've got it!")
  11 <__main__.H object at 0x7feffab3fdd8> I've got it!

   1 >>> class I:
   2 ...   def meth():
   3 ...     pass
   4 ...
   5 >>> def fun():
   6 ...   pass
   7 ...
   8 >>> I.subfun = fun
   9 >>> i = I()
  10 >>> fun
  11 <function fun at 0x7feffab441e0>
  12 >>> I.subfun
  13 <function fun at 0x7feffab441e0>
  14 >>> I.meth
  15 <function I.meth at 0x7feffab61048>
  16 >>> i.subfun
  17 <bound method fun of <__main__.I object at 0x7feffab604a8>>
  18 >>> i.meth
  19 <bound method I.meth of <__main__.I object at 0x7feffab604a8>>

   1 >>> class J:
   2 ...   t = 42
   3 ...   def answer(obj):
   4 ...     print(obj.t)
   5 ...
   6 >>> j=J()
   7 >>> j.answer()
   8 42
   9 >>> j.t='forty two'
  10 >>> j.answer()
  11 forty two

   1 >>> class K:
   2 ...   def __init__(self, w, h):
   3 ...     self.w, self.h = w, h
   4 ...   def square(self):
   5 ...     return self.w*self.h
   6 ...
   7 >>> k=K(10,20)
   8 >>> dir(k)
   9 ['__doc__', '__init__', '__module__', 'h', 'square', 'w']
  10 >>> k.square()
  11 200

— Всему самому лучшему, что у меня есть, я обязан родителю!
  Я всё унаследовал от него — и эти поля, и эти методы — а сам лишь кое-что улучшил и добавил немного от себя.

Коротко

• Класс — это пространство имён

• Класс — это изготовитель (чтобы не сказать «конструктор») объекта — экземпляра класса, т. е. такой callable.

  • У класса (объекта) есть поля (иногда говорят атрибуты, сейчас поймёте, почему ☺). Callable-поля называются методы, не-callable называются, извините, поля.

• Все поля класса видны в объекте

  • До тех пор, пока их не загородят уникальные поля объекта с теми же именами (аналог: глобальные и локальные переменные)

  • При этом функции класса превращаются в методы объекта

    • Метод — это такая функция внутри пространства имён объекта, при вызове которой в начало кортежа параметров ставится сам объект

• Специальный метод __init__() нужен для создания полей объекта и вообще логики его создания

  • Это не конструктор!

Строка документации класса (и методов, разумеется, но там как в функциях).

Перегрузка операций

На самом деле всё наоборот — нет никаких операций, есть синтаксический сахар и протоколы над методами.

• getattr()/setattr()

• .__getattr__()/.__setattr__()/.__delattr__(), а также .__getattribute__()

• .__del__() — это не деструктор

• .__dir__() тоже

Спецметоды

• .__что-то__()

• правила поиска

  • Только в классе (нельзя подменить в объекте)

  • Нельзя подменить с помощью .__getattr*

• Спецметоды есть для всего

Примеры (сколько успеем)

• .__str__() и .__repr__()

• len()

• iter()

• .__bool__()

• Числовой протокол

  • Например, + (.__add__() и .__radd__())

    • NotImplemented

• [] (.__getitem__()/.__setitem__())

  • slice

  • Ellipsis (он же [...])

• …

Д/З

0. Прочитать про классы в tutorial; про «волшебные методы» например, тут

   • Прочитать про ограничения на перегрузку спецметодов в справочнике

   • Вообще выборочно почитать справочник по этой теме. Там много такого, про что в лекциях мы поговорить не успеем.

1. EJudge: PushPull 'Тяни-толкай'

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

   • имеет метод push(n), перемещение тянитолкая вправо на неотрицательное число n шагов (по умолчанию 1)

   • имеет метод pull(n), перемещение тянитолкая влево.

   • экземпляр класса итерируем, при этом возвращается последовательность чисел от 0 до текущего положения тянитолкая (не включая само положение)

   • преобразование в строку выглядит так: "<слева<", "<0>" и ">справа>"

   • все экземпляры этого класса задают положение/перемещают одного и того же тянитолкая.

   Input:

      1 a = Pushpull(-10)
      2 print(a)
      3 b, c = Pushpull(7), Pushpull(5)
      4 print(b)
      5 for i in b:
      6     c.pull()
      7 print(a)
      8 b.push(3)
      9 t = tuple(c)
     10 a.pull(7)
     11 t += tuple(b)
     12 print(*t)
   

   Output:

   <10<
   >5>
   <0>
   0 1 2 0 -1 -2 -3

2. EJudge: DahDit 'Морзянка'

   Написать класс morse("строка"), экземпляр которого переводит арифметические выражения в морзянку! В выражении «+» — это точка, «-» — тире, а «~» — промежуток между буквами (бывает только между буквами и только один, проверять не надо).

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

   • Два элемента задают точку (она же точка на конце буквы) и тире

   • Если элемента четыре, четвёртый — это то, что выводится в конце сообщения
   • По умолчанию:

     • Если параметров нет, это слова "di", "dit" и "dah".

     • Если параметры — слова: в конце сообщения выводится ".", разделители при выводе: пробел между сигналами и ", " между буквами.

     • Если параметры — символы: непуст только разделитель между буквами (это пробел).
   Input:

      1 print(-+morse())
      2 print(-++~+-+morse())
      3 print(--+~-~-++~+++-morse())
      4 print(--+~-~-++~+++-morse(".-"))
      5 print(--+~-~-++~+++-morse("..-"))
      6 print(--+~-~-++~+++-morse("..-|"))
      7 print(--+~-~-++~+++-morse("dot DOT dash"))
      8 print(--+~-~-++~+++-morse("ai aui oi "))
      9 print(--+~-~-++~+++-morse("dot dot dash ///")) 
   

   Output:

   dah dit.
   dah di dit, di dah dit.
   dah dah dit, dah, dah di dit, di di di dah.
   --. - -.. ...-
   --. - -.. ...-
   --. - -.. ...-|
   dash dash DOT, dash, dash dot DOT, dot dot dot dash.
   oi oi aui, oi, oi ai aui, ai ai ai oi
   dash dash dot, dash, dash dot dot, dot dot dot dash///

3. EJudge: NutsClass 'Странный класс'

   Написать класс Nuts, экземпляры которого

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

   • содержат любое поле (возвращается имя этого поля)

     • в том числе позволяют присваивать и удалять поля (ничего не происходит)

   • итерируемы (возвращаются строки "N", "u", "t" и "s")

   • в виде строки представляются как "Nuts"

   Input:

      1 M, N = Nuts(), Nuts(1,2,3,4)
      2 print(M, N)
      3 M[100] = N.qwerty = 42
      4 print(M[100], N.qwerty)
      5 print(*list(Nuts("QWERQWERQWER")))
      6 del M["QQ"], N[6:10], M[...], N._, N.qwerty
      7 print(M.asdfg, N[-2])
   

   Output:

   Nuts Nuts
   100 qwerty
   N u t s
   asdfg -2

4. EJudge: SpiralString 'Спиральки'

   Написать класс Spiral, экземпляр которого образуется из строки, содержащей одну или несколько последовательностей одинаковых символов, при этом одинаковые символы группируются в порядке их первого вхождения, например Spiral("1233443213") → 11 22 3333 44. При преобразовании в строку такая последовательность должна «закручиваться в спираль» против часовой стрелки, начиная с направления «вправо» (см. пример). Помимо преобразования в строку объект типа Spiral должен:

   • Поддерживать сложение с таким же объектом: существующие в исходном объекте последовательности увеличиваются на соответствующее количество символов, новые — добавляются в конец

   • Поддерживать вычитание объектов типа Spiral, при этом существующие последовательности уменьшаются в длине (до полного исчезновения, если в вычитаемом было не меньше таких символов)

   • Поддерживать умножение на натуральное число N (количество символов в последовательностях увеличивается в N раз)

   • Поддерживать итератор по всем символам последовательности
   Input:

      1 S = Spiral("abbcccddddeeeee")
      2 I = Spiral("abcdefghi")
      3 
      4 print(f"{S}\n")
      5 print(S+I, "\n")
      6 print(S-I, "\n")
      7 print(I*2, "\n")
      8 print(I*2-S, "\n")
      9 print(*list(S+I))
   

   Output:

   dccc
   d  b
   d ab
   d
   eeeee
   
      ihg
        f
   ccbb e
   c  b e
   c aa e
   d    e
   ddddee
   
   eddd
   e  c
   e bc
   e
   
   dccb
   d  b
   e aa i
   e    i
   ffgghh
   
   hhgg
   i  f
   i af
   
   a a b b b c c c c d d d d d e e e e e e f g h i