Метаклассы и сопоставление шаблону

Это две совсем разные темы, если что). Или три, если успеем «Введение в аннотации». TODO А успеем ли?

Не-метаклассы

Частые приёмы программирования:

• Дополнительные действия при изготовлении производного класса

  • Метод .__init_subclass__()

       1 class Titled:
       2     def __init_subclass__(cls, title, *args, **kwargs):
       3         cls.title = title
       4         super().__init_subclass__(*args, **kwargs)
       5     def __str__(self):
       6         return f"[{self.title}] {super().__str__()}"
       7 
       8 class C(Titled, title="This is C"):
       9     pass
      10 print(C())
      11 [This is C] <__main__.C object at 0x7fac8261b7d0>
    

  • Объявлению класса можно передавать именные параметры!

  • __init_subclass__ — это @classmethod (без объявления ☹)

• Интроспекция имени поля в классе:

  • Метод .__set_name__():

  • Вместо

       1 class Descr:
       2     def __get__(self, obj, cls):
       3         return obj._x
       4     def __set__(self, obj, val):
       5         obj._x = val
    

    • Кстати, а как будут работать два таких дескриптора? Спойлер: никак, будут работать как один

  • …запихать имя дескриптора в __dict__ и доставать его оттуда явно

       1 class Descr:
       2     def __get__(self, obj, cls):
       3         return obj.__dict__[self.key]
       4     def __set__(self, obj, val):
       5         obj.__dict__[self.key] = abs(val)
       6     def __set_name__(self, owner, name):
       7         self.key = name
    

  • Воспользуемся:

       1 class C:
       2     d = Descr()
       3     e = Descr()
       4 
       5 c = C()
       6 print(C.__dict__)
       7 print(c.__dict__)
       8 c.d, c.e = -3, -4
       9 print(c.d, c.e)
      10 print(c.__dict__)
    

    • →

       1 {'__module__': '__main__', 'd': <__main__.Descr object at 0x7f8177f431d0>, 'e': <__main__.Descr object at 0x7f8177f43210>, '__dict__': <attribute '__dict__' of 'C' objects>, '__weakref__': <attribute '__weakref__' of 'C' objects>, '__doc__': None}
       2 {}
       3 3 4
       4 {'d': 3, 'e': 4}
    

  • Поля c и d в классе — это дескрипторы, поэтому для чтения / записи используются именно они и их методы .__get__() / .__set__()

  • Следовательно, поля c и d в .__dict__ объекта не доступны по имени напрямую — но они есть и используются для хранения соответствующих дескрипторам данных

Метаклассы

Предуведомление: Тим Петерс про метаклассы ☺.

Посылка: в питоне всё — объект. Объекты-экземпляры класса конструируются с помощью вызова самого класса. А кто конструирует класс? Мета-класс!

• В справочнике

• Внезапно развёрнутое описание на StackOverflow (перевод на Хабре)

• Статья Sahand Saba (перевод)

• Забойная статья Sebastian Buczyński 2020 года (Перевод)

Хороший пример real-life кода на Python, эксплуатирующий метаклассы и многое другое:

• enum (в частности, How are Enums different?)

• abc

Итак, что уже и так может служить конструктором класса?

• Класс можно создать просто функцией
• Декоратором
  • Но не т. н. monkey-patch, когда подправляется уже имеющийся класс (⇒ не мы его создаём)
• Класс может быть потомком другого класса, и процесс «создания» — это спецметоды родительского класса.

Зачем тогда нужны ещё отдельные конструкторы классов?

0. Чёткого ответа нет.
1. Чтобы закрыть дурную бесконечность (кто конструирует конструктор?) — но это ответ на вопрос «почему?», а не «зачем?»
2. Чтобы разделить иерархию классов, которой пользуется программист, и то, как конструируется сам базовый класс этой иерархии

   • «Тонкая настройка» класса к моменту его создания уже произошла, и в самом классе этих инструментов нет

   • ⇒ более чистый mro(), чем в случае наследования

   • ⇒ Два похоже работающих класса с общим метаклассом не имеют общего предка
3. Чтобы сами метаклассы тоже можно было организовывать в виде дерева наследования
4. …

Использование type()

• Создание класса с помощью type(name, bases, dict)

     1 class C:
     2     pass
  

  • это вырожденный вызов type("имя", (кортеж родителей), {пространство имён})

     1 C = type("C", (), {})
  

• Например,

     1 C = type('Simple', (), {'val': 42, 'getval': lambda self: self.val})
     2 c = C()
     3 c.val, c.getval()
  

• Но type — это просто класс такой ⇒ от него можно унаследоваться, например, перебить ему __init__():

     1 class overtype(type):
     2     def __init__(self, Name, Parents, Dict):
     3         print(f" Class definition: {Name}{Parents}: {Dict}")
     4         super().__init__(Name, Parents, Dict)
     5 
     6 Boo = overtype("Boo", (), {"A": 100500})
     7 t = Boo()
     8 print(Boo, t, t.A)
  

• а вот это Boo = overtype… можно записать так:

     1 …
     2 class Boo(metaclass=overtype):
     3     A = 100500
  

• (по сути, class C: — это class C(metaclass=type):)

Подробности:

• (__prepare__() для автоматического создания пространства имён, если есть), __new__(), __init__()

  • можно перебить ещё __call__ для внесения правок при создании экземпляра класса

• __new__()

  • создаёт экземпляр объекта (а __init__() заполняет готовый)

  • это метод класса (такой @classmethod без декоратора)

  • в нём можно поменять всё, что в __init__() приезжает готовое и read-only: __slots__, имя класса (если это метакласс) и т. п.

Общая картина:

•    1 class ctype(type):
     2 
     3     @classmethod
     4     def __prepare__(metacls, name, bases, **kwds):
     5         print("prepare", name, bases, kwds)
     6         return super().__prepare__(name, bases, **kwds)
     7 
     8     @staticmethod
     9     def __new__(metacls, name, parents, ns, **kwds):
    10         print("new", metacls, name, parents, ns, kwds)
    11         return super().__new__(metacls, name, parents, ns)
    12 
    13     def __init__(cls, name, parents, ns, **kwds):
    14         print("init", cls, parents, ns, kwds)
    15         return super().__init__(name, parents, ns)
    16 
    17     def __call__(cls, *args, **kwargs):
    18         print("call", cls, args, kwargs)
    19         return super().__call__(*args, **kwargs)
    20 
    21 class C(int, metaclass=ctype, parameter="See me"):
    22      field = 42
    23 
    24 c = C("100500", base=16)
  

  • →

  prepare C (<class 'int'>,) {'parameter': 'See me'}
  new <class '__main__.ctype'> C (<class 'int'>,) {'__module__': '__main__', '__qualname__': 'C', 'field': 42} {'parameter': 'See me'}
  init <class '__main__.C'> (<class 'int'>,) {'__module__': '__main__', '__qualname__': 'C', 'field': 42} {'parameter': 'See me'}
  call <class '__main__.C'> ('100500',) {'base': 16}

• Заметим, куда приезжает именной параметр parameter

• Особенность __new__: это статический метод, при вызове из super() поле cls надо передавать явно

  • при этом @staticmethod можно не писать ( это как?)

• Особенность __prepare__: это метод класса

  • Он не вызывается, если написать C = ctype(…). Неизвестно, бага это или фича.

• Общая особенность: нельзя написать без наследования от type()

Два примера:

• Ненаследуемый класс

     1 class final(type):
     2     def __new__(metacls, name, parents, namespace):
     3         for cls in parents:
     4             if isinstance(cls, final):
     5                 raise TypeError(f"{cls.__name__} is final")
     6         return super().__new__(metacls, name, parents, namespace)
     7 class E(metaclass=final): pass
     8 class C: pass
     9 class A(C, E): pass
  

  • Обратите внимание на параметры super() —

• Синглтон (больше синглтонов тут)

     1 class Singleton(type):
     2     _instance = None
     3     def __call__(cls, *args, **kw):
     4         if cls._instance is None:
     5              cls._instance = super().__call__(*args, **kw)
     6         return cls._instance
     7 
     8 class S(metaclass=Singleton):
     9     A = 3
    10 s, t = S(), S()
    11 s.newfield = 100500
    12 print(f"{s.newfield=}, {t.newfield=}")
    13 print(f"{s is t=}")
  

• Модуль types

Сопоставление шаблону

Базовая статья: pep-636 (а также pep-635 и pep-634)

Главная сложность: конструкция match … case имеет отличный от Python синтаксис! Спасибо смене парсера с LL(1) на PEG.

Пересказ tutorial:

• Вместо цепочки однотипных elif-ов

     1 a = command.split()
     2 if a == ["help"]:
     3         …
     4 elif a == ["help", "--full"]:
     5         …
     6 …
  

  • →

     1 match command.split():
     2         case ["help"]:
     3                 …
     4         case ["help", "--full"]:
     5                 …
  

• Связанные переменные

     1 match command.split():
     2         case ["help"]:
     3                 …
     4         case ["help", command]:
     5                 match command:
     6                         case "run":
     7                                 …
     8                         case "quit":
     9                                 …
  

• Распаковка и catch-all:

     1         case [command, *options]:
     2                 …
     3         case []:
     4                 … пустой список
     5         case _:
     6                 … это как default …
  

  • Распаковка, как всегда, включая len()==0

• Альтернативы и явно связанные переменные

     1         case [("help" | "usage")]:
     2                 …
     3         case [("help" | "usage"), ("help" | "run" | "quit") as command]:
     4                 print(command)
     5                 …
  

• Фильтры:

     1         case ["help", command] if command in commands_list:
     2                 …
  

• Проверка типов (help(complex)), проверка полей объекта (как правило по имени, редко когда определено перечисление полей)

     1 match var := eval(input()):
     2    case int(x):
     3         print("int", x)
     4    case float():
     5         print("float", var)
     6    case complex(real=0, imag=i):
     7         print("Imag", i)
     8    case complex(real=r, imag=i):
     9         print(r, i)
  

  • Здесь x — связанная переменная заданного типа

    • … но можно обойтись и без неё
• Экземпляр класса определяется перечислением полей поимённо или (если задано) позиционно:

     1 from collections import namedtuple
     2 C = namedtuple("C", "a b")
     3 for c in C(2, 3), C(1, 2), C(2, 1), C(42, 100500), C(-1, -1):
     4     match c:
     5         case C(2, 3):                           # Позиционное перечисление
     6             print(C, "with 2 and 3")
     7         case C(a=1, b=V) | C(a=V, b=1):         # Поимённое перечисление, одна переменная связана
     8             print(C, "with 1 and", V)
     9         case C(42):                             # Позиционное задание только одного поля
    10             print("Special", C)
    11         case C(A, b=B):                         # Одна переменная связана позиционно, другая — именем
    12             print("Any", C, "with", A, "and", B
  

  • Не обязательно задавать все поля

  • Можно смешивать позиционное и именное перечисление / связывание

• Позиционное перечисление полей можно определить вручную спецполем __match_args__:

     1 class C:
     2     __match_args__ = "name", "diap"
     3 
     4     def __init__(self, name, diap):
     5         self.name = name
     6         self.diap = diap
     7 
     8 c = C("obj", (1, 10, 2))
     9 match c:
    10     case C(name, (start, stop, step)):
    11         print(name, range(start, stop, step))
  

• Словари:

     1 d = dict(enumerate(input().split(), 1))
     2 print(d)
     3 match d:
     4     case {1: "one", 2: "two"}:
     5         print("exact")
     6     case {1: "one", 2: other}:
     7         print("bounded", other)
     8     case {2: "two", **others}:
     9         print("inexact", others)
  

• Как отличить константу от связанной переменной?

• Никак! Храните константы в изолированных пространствах имён:

     1 class Color:
     2     RED = 0
     3     GREEN = 1
     4     BLUE = 2
     5 WHITE = 4
     6 
     7 match int(input()):
     8     case Color.RED:
     9         print("RED")
    10     case WHITE:
    11         print(f"Not RED, {WHITE}")
  

  • Здесь Color.RED воспринимается как константа, а WHITE — как связанная переменная

Введение в аннотации

Базовая статья: О дисциплине использования аннотаций

Duck typing:

• Экономия кода на описаниях и объявлениях типа
• Экономия (несравненно бо́льшая) кода на всех этих ваших полиморфизмах
• ⇒ Компактный читаемый код, хорошее отношение семантика/синтаксис
• ⇒ Быстрое решение Д/З ☺

Однако:

• Практически все ошибки — runtime
• Много страданий от невнимательности (передал объект не того типа, и не заметил, пока не свалилось)

  • Вашей невнимательности не поможет даже хитрое IDE: оно тоже не знает о том, какого типа объекты правильные, какого — нет

  • (соответственно, о полях вашего объекта тоже)

• Часть прагматики растворяется в коде (например, вы написали строковую функцию, как об этом узнать?)

• Большие и сильно разрозненные проекты — ?

Поэтому нужны указания о типе полей классов, параметрах и возвращаемых значений функций/методов и т. п. — Аннотации (annotations)

• Аннотации — часть синтаксиса Python

• Аннотации не влияют на семантику непосредственно: наличие или отсутствие аннотации не меняет дальнейшую работу интерпретатора, но можно исследовать их как данные

Пример аннотаций полей (переменных), параметров и возвращаемых значений

•    1 import inspect
     2 
     3 class C:
     4     A: int = 2
     5     N: float
     6 
     7     def __init__(self, param: int = None, signed: bool = True):
     8         if param != None:
     9             self.A = param if signed else abs(param)
    10 
    11     def mult(self, mlt: int) -> str:
    12         return self.A * mlt
    13 
    14 a: C = C(3)
    15 b: C = C("QWE")
    16 print(f"{a.mult([2])=}, {b.mult(2)=}")
    17 print(f"{inspect.get_annotations(a.mult)=}")
    18 print(f"{inspect.get_annotations(C.mult)=}")
    19 print(f"{inspect.get_annotations(C)}")
    20 print(f"{inspect.get_annotations(C.__init__)}")
    21 
    22 print(a.mult(2))
    23 print(b.mult(2))
    24 print(a.mult("Ho! "))
    25 print(a.N)  # an Error!
  

• Аннотации сами по себе не влияют на семантику кода (умножение строки сработало)
  • …в т. ч. не занимаются проверкой типов

• Аннотации заполняют словарь __annotations__ в соответствующем пространстве имён

  • …но не они заводят сами имена в пространстве имён

• Типы в аннотациях —

  • это настоящие типы — не всегда возможно, например:

       1 class Widget:
       2     def copy(self) -> Widget:
       3         return deepcopy(self)
    

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

Составные и нечёткие типы

составные типы:

• pep-0585: Во многих случаях можно писать что-то вроде list[int]

     1 >>> def fun(lst: list[int]): pass
     2 >>> inspect.get_annotations(fun)
     3 {'lst': list[int]}
     4 >>> inspect.get_annotations(fun)['lst']
     5 list[int]
     6 >>> type(inspect.get_annotations(fun)['lst'])
     7 <class 'types.GenericAlias'>
     8 >>> ann = inspect.get_annotations(fun)['lst']
     9 >>> typing.get_args(ann)
    10 (<class 'int'>,)
    11 >>> typing.get_origin(ann)
    12 <class 'list'>
    13 
  

  • .get_args() возвращает кортеж с аннотациями элемента, .get_origin() — тип контейнера

  • Again, на семантику работы аннотация не влияет

Более полная лекция по использованию аннотаций для статической типизации в Python планируется в допглавах магистерского курса.

Д/З

0. Прочитать про:
   • Метаклассы (см. множество ссылок выше — выберите ту, что попонятнее))

   • Модули inspect, types,

   • Учебник по match/case

1. EJudge: MetaBool 'Класс с пустотой'

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

   Input:

      1 class C(metaclass=empty):
      2     cfield = 0
      3     def __init__(self, val=0):
      4         self.ofield = val
      5 print(not C(), not C(""), not C(123))
   

   Output:

   True True False

2. EJudge: MatchTurtle 'Интерпретатор с черепашкой'

   С помощью конструкции match / case (и только её, условные операторы и иные конструкции с if в этой задачи не разрешены) написать программу, которая в цикле вводит и интерпретирует перечисленные ниже команды перемещения «черепашки» по координатной плоскости. Конец ввода — пустая строка. Изначально черепашка находится в точке 0, 0. Все «слова» в команде разделены ровно одним пробелом.

   • move направление, где направление — это s, n, w или е: переместить черепашку на один шаг вниз, вверх, влево или вправо соответственно.

   • move: переместить черепашку в том же направлении, указанном последней командой вида move направление. Если такой команды ещё не было, черепашка не перемещается.

   • Все остальные команды вида move что-то там должны выводить текст Cannot move to что-то там, и не перемещать черепашку

   • retreat: переместить черепашку в направлении, обратном последней команде вида move направление. Если такой команды ещё не было, черепашка не перемещается.

   • info что, где что — это x , y или xy: вывести абсциссу, ординату или пару «абсцисса ордината»

   • say какое-то сообщение вывести «какое-то сообщение» (включая пустое)

   • все остальные команды игнорируются

   Перед выходом из программы дополнительно выполняется команда info xy.

   Input:

   say Hello, world!
   move n
   move e
   jump
   info xy
   move n
   move base
   look around
   info x
   retreat
   retreat
   info y

   Output:

   Hello, world!
   1 1
   Cannot move to base
   1
   0
   1 0

3. EJudge: MetaPosition 'Метакласс с заготовками'

   Написать метакласс positioned, который добавляет в создаваемый с его помощью класс три свойства:

   • Строковое представление экземпляра этого класса должно выглядеть как "поле1=значение1 поле2=значение2 …" для всех аннотированных полей этого класса (в порядке их появления в аннотации).

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

      1 class C(metaclass=positioned):
      2     a: int = 1
      3     b: float = 42.0
      4 
      5 for c in C(), C(4), C(100.0, 500), C(7, 2):
      6     print(c)
      7     match c:
      8         case C(1):
      9             print("C1", c.b)
     10         case C(b=42):
     11             print("C42", c.a)
     12         case C(100, 500):
     13             print("C100500")
     14         case C():
     15             print("C", c)
   

   Output:

   a=1 b=42.0
   C1 42.0
   a=4 b=42.0
   C42 4
   a=100.0 b=500
   C100500
   a=7 b=2
   C a=7 b=2