Действительно ли «None» и «type(None)» эквивалентны для анализа типов?

Да, это было интересно.

Часть 1: Ничего странного

Я бы сказал, что все сводится к следующему: None на самом деле является экземпляром NoneType, но для практических целей его следует рассматривать как None. Учтите следующее:

from types import NoneType
x: None = None # succeeds
y: NoneType = None # succeeds in pyright, fails in mypy
z: type[None] = None # fails in both

Странно, правда? Второй случай проходит по пирайту, поскольку в нем говорится, что None является экземпляром NoneType, но в mypy специальный случай явно запрещен: «NoneType не следует использовать в качестве типа, вместо этого используйте None»

Часть 2. Псевдоним типа требует слишком многого от объединения

Кажется, что когда вы определяете союз, который использует None, он предполагает, что type[None] является частью союза:

from typing import reveal_type

x = int | None
y = None
reveal_type(x) # type[int] | type[None]
reveal_type(y) # None

Мне это кажется ошибкой — я ожидал, что show_type на x покажет:

reveal_type(x) # type[int] | None

...поскольку, как показано выше, type[None] не совсем канонический тип. Но это то, что есть, поэтому нам пока придется с этим работать.

Часть 3. А как насчет варианта использования?

Мне пришло в голову, что инспекция уже реализует подобную функцию, поэтому я бы посмотрел, какие типы имеют следующие:

from inspect import signature

def test() -> int:
    return 1

x = signature(test)
print(x.return_annotation) # int

def test2() -> None:
    pass

y = signature(test2)
print(y.return_annotation) # None

Оказывается, это не поддерживает статическую типизацию, но правильный тип для этих аннотаций возврата будет type[int] | None. Лично я бы выделил «Нет», если это возможно:

from typing import Callable, NamedTuple

ReturnType = int | str

SomeCallableType = Callable[..., None | ReturnType]


class FuncInfos(NamedTuple):
    return_type: None | type[ReturnType]

fi_1 = FuncInfos(return_type=int)
fi_2 = FuncInfos(return_type=None)

Надеюсь это поможет!

Как показано в сообщении, в PEP 484 говорится что-то двусмысленное:

При использовании в подсказке типа выражение None считается эквивалентным type(None).

Но я узнал о PEP 483, который использует гораздо более четкую формулировку в своей Прагматике:

Если ожидается тип, None можно заменить на type(None); например Union[t1, None] == Union[t1, type(None)].

Учитывая это, различные примеры теперь начинают иметь смысл.

Например, мой второй MRE:

from typing import Type

a: Type[None]

# This seems to cause an issue:
# main.py:4: error: Incompatible types in assignment (expression has type "None", variable has type "type[None]")  [assignment]
# Found 1 error in 1 file (checked 1 source file)
a = None

# This seems to work:
a = type(None)

теперь можно интерпретировать как:

from typing import Type

a: Type[type(None)] # Type[...] expects a type.
a = None
a = type(None)

Теперь тип a явно является «подтипом type(None)», что точно не соответствует типу выражения None, отсюда и сообщение об ошибке. Однако на самом деле это тип второго выражения: type(None) («Каждый тип является подтипом самого себя». Согласно самому PEP 483).

Итак, как было предложено в некоторых комментариях, я в основном неверно истолковал PEP 484 и забыл, что «эквивалентность» действует только «в подсказке типа» (или «там, где ожидается тип»). Чего не было при передаче параметров или назначении в моих фрагментах.