Оценивает ли Python подсказку типа прямой ссылки?

Рассмотрим следующий код:

class Foo:
    def bar(self) -> Foo:
        return Foo()

Эта программа на самом деле рухнет во время выполнения, если вы попытаетесь запустить ее с помощью Python: когда интерпретатор увидит определение bar, определение Foo еще не закончено. Итак, поскольку Foo еще не добавлено в глобальное пространство имен, мы пока не можем использовать его как подсказку типа.

Аналогично рассмотрим эту программу:

class Foo:
    def bar(self) -> Bar:
        return Bar()

class Bar:
    def foo(self) -> Foo:
        return Foo()

Это взаимозависимое определение страдает от той же проблемы: пока мы оцениваем Foo, Bar еще не вычислено, поэтому интерпретатор выдает исключение.

Есть три решения этой проблемы. Во-первых, сделать некоторые из ваших подсказок типа строками, фактически «объявив» их вперед:

class Foo:
    def bar(self) -> "Foo":
        return Foo()

Это удовлетворяет интерпретатору Python и не нарушит работу сторонних инструментов, таких как mypy: они могут просто удалить кавычки перед синтаксическим анализом типа. Главный недостаток заключается в том, что этот синтаксис выглядит несколько уродливым и неуклюжим.

Второе решение — использовать синтаксис комментариев типа:

class Foo:
    def bar(self):
        # type: () -> Foo
        return Foo()

Это имеет те же преимущества и недостатки, что и первое решение: оно удовлетворяет интерпретатору и инструментарию, но выглядит хакерским и уродливым. У него также есть дополнительное преимущество, заключающееся в том, что он поддерживает обратную совместимость вашего кода с Python 2.7.

Третье решение — только для Python 3.7+ — используйте директиву from __future__ import annotations:

from __future__ import annotations 

class Foo:
    def bar(self) -> Foo:
        return Foo()

Это автоматически сделает все аннотации представленными в виде строк. Таким образом, мы получаем преимущество первого решения, но без уродства.

Это поведение в конечном итоге станет поведением по умолчанию в будущих версиях Python.

Также оказывается, что автоматическое преобразование всех строк аннотаций может привести к некоторым улучшениям производительности. Создание таких типов, как List[Dict[str, int]], может оказаться на удивление дорогим: во время выполнения они представляют собой просто регулярные выражения и оцениваются так, как если бы они были написаны как List.__getitem__(Dict.__getitem__((str, int)).

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

(Короче говоря, им нужно создавать специальные объекты, которые гарантируют, что типы, подобные List[int], не могут быть использованы ненадлежащим образом во время выполнения — например, в проверках isinstance и т.п.)