typing — Suporte para dicas de tipo

Novo na versão 3.5.

Código-fonte: Lib/typing.py

Nota

O tempo de execução do Python não força anotações de tipos de variáveis e funções. Elas podem ser usadas por ferramentas de terceiros como verificadores de tipo, IDEs, linters, etc.

Este módulo oferece suporte para dicas de tipo ao ambiente de execução. Para a especificação original de tipagem do sistema, veja PEP 484. Para uma introdução simplificada as dicas de tipo, veja PEP 483.

A função abaixo recebe e retorna uma string e é anotada como a seguir:

def greeting(name: str) -> str:
    return 'Hello ' + name

Na função greeting, é esperado que o argumento name seja do tipo str e o retorno do tipo str. Subtipos são aceitos como argumentos.

Novos recursos são frequentemente adicionados ao módulo typing. O pacote typing_extensions provê suporte retroativo a estes novos recursos em versões anteriores do Python.

Para ter um resumo dos recursos descontinuados e um cronograma de descontinuação, por favor, veja Cronograma de Descontinuação dos Principais Recursos.

Ver também

“Guia rápido sobre Dicas de Tipo”

Uma visão geral das dicas de tipo (hospedado por mypy docs, em inglês).

“Referência sobre Sistema de Tipo” seção de the mypy docs

O sistema de tipagem do Python é padronizado pelas PEPs, portanto esta referência deve se aplicar a maioria do verificadores de tipo do Python. (Alguns trechos podem se referir especificamente ao mypy. Documento em inglês).

“Tipagem Estática com Python”

Documentação independente de verificador de tipo escrita pela comunidade, detalhando os recursos do sistema de tipo, ferramentas úteis de tipagem e melhores práticas.

PEPs Relevantes

Desde a introdução das dicas de tipo nas PEP 484 e PEP 483, várias PEPs tem modificado e aprimorado o framework do Python para anotações de tipo:

The full list of PEPs

Apelidos de tipo

A type alias is defined by assigning the type to the alias. In this example, Vector and list[float] will be treated as interchangeable synonyms:

Vector = list[float]

def scale(scalar: float, vector: Vector) -> Vector:
    return [scalar * num for num in vector]

# passes type checking; a list of floats qualifies as a Vector.
new_vector = scale(2.0, [1.0, -4.2, 5.4])

Apelidos de tipo são úteis para simplificar assinaturas de tipo complexas. Por exemplo:

from collections.abc import Sequence

ConnectionOptions = dict[str, str]
Address = tuple[str, int]
Server = tuple[Address, ConnectionOptions]

def broadcast_message(message: str, servers: Sequence[Server]) -> None:
    ...

# The static type checker will treat the previous type signature as
# being exactly equivalent to this one.
def broadcast_message(
        message: str,
        servers: Sequence[tuple[tuple[str, int], dict[str, str]]]) -> None:
    ...

Type aliases may be marked with TypeAlias to make it explicit that the statement is a type alias declaration, not a normal variable assignment:

from typing import TypeAlias

Vector: TypeAlias = list[float]

NewType

Utilize o auxiliar NewType para criar tipos únicos:

from typing import NewType

UserId = NewType('UserId', int)
some_id = UserId(524313)

O verificador de tipo estático tratará o novo tipo como se fosse uma subclasse do tipo original. Isso é útil para ajudar a encontrar erros de lógica:

def get_user_name(user_id: UserId) -> str:
    ...

# passes type checking
user_a = get_user_name(UserId(42351))

# fails type checking; an int is not a UserId
user_b = get_user_name(-1)

Você ainda pode executar todas as operações int em uma variável do tipo UserId, mas o resultado sempre será do tipo int. Isso permite que você passe um UserId em qualquer ocasião que int possa ser esperado, mas previne que você acidentalmente crie um UserId de uma forma inválida:

# 'output' is of type 'int', not 'UserId'
output = UserId(23413) + UserId(54341)

Note que essas verificações são aplicadas apenas pelo verificador de tipo estático. Em tempo de execução, a instrução Derived = NewType('Derived', Base) irá tornar Derived um chamável que retornará imediatamente qualquer parâmetro que você passar. Isso significa que a expressão Derived(some_value) não cria uma nova classe ou introduz sobrecarga além de uma chamada regular de função.instrução

Mais precisamente, a expressão some_value is Derived(some_value) é sempre verdadeira em tempo de execução.

É inválido criar um subtipo de Derived:

from typing import NewType

UserId = NewType('UserId', int)

# Fails at runtime and does not pass type checking
class AdminUserId(UserId): pass

No entanto, é possível criar um NewType baseado em um ‘derivado’ NewType:

from typing import NewType

UserId = NewType('UserId', int)

ProUserId = NewType('ProUserId', UserId)

e a verificação de tipos para ProUserId funcionará como esperado.

Veja PEP 484 para mais detalhes.

Nota

Recall that the use of a type alias declares two types to be equivalent to one another. Doing Alias = Original will make the static type checker treat Alias as being exactly equivalent to Original in all cases. This is useful when you want to simplify complex type signatures.

Em contraste, NewType declara que um tipo será subtipo de outro. Efetuando Derived = NewType('Derived', Original) irá fazer o verificador de tipo estático tratar Derived como uma subclasse de Original, o que significa que um valor do tipo Original não pode ser utilizado onde um valor do tipo Derived é esperado. Isso é útil quando você deseja evitar erros de lógica com custo mínimo de tempo de execução.

Novo na versão 3.5.2.

Alterado na versão 3.10: NewType agora é uma classe em vez de uma função. Consequentemente, existem alguns custos em tempo de execução ao chamar NewType em vez de uma função comum.

Alterado na versão 3.11: O desempenho de chamar NewType voltou ao mesmo nível da versão Python 3.9.

Anotações de objetos chamáveis

Funções – ou outros objetos chamáveis – podem ser anotados utilizando-se collections.abc.Callable ou typing.Callable. Callable[[int], str]. Significa uma função que recebe um único parâmetro do tipo int. e retorna um str.

Por exemplo:

from collections.abc import Callable, Awaitable

def feeder(get_next_item: Callable[[], str]) -> None:
    ...  # Body

def async_query(on_success: Callable[[int], None],
                on_error: Callable[[int, Exception], None]) -> None:
    ...  # Body

async def on_update(value: str) -> None:
    ...  # Body

callback: Callable[[str], Awaitable[None]] = on_update

A sintaxe da subscrição deve sempre ser usada com exatamente dois valores: uma lista de argumentos e o tipo de retorno. A lista de argumentos deve ser uma lista de tipos, um ParamSpec, Concatenate, ou reticências. O tipo de retorno deve ser um único tipo.

Se uma reticências literal ... é passada no lugar de uma lista de argumentos, ela indica que um chamável com uma lista de qualquer parâmetro arbitrário seria aceita.

def concat(x: str, y: str) -> str:
    return x + y

x: Callable[..., str]
x = str     # OK
x = concat  # Also OK

Callable não pode representar assinaturas complexas, como funções que aceitam um número variado de argumentos, funções sobrecarregadas, or funções que recebem apenas parâmetros somente-nomeados. No entanto, essas assinaturas podem ser expressas ao se definir uma Protocol com um método __call__():

from collections.abc import Iterable
from typing import Protocol

class Combiner(Protocol):
    def __call__(self, *vals: bytes, maxlen: int | None = None) -> list[bytes]: ...

def batch_proc(data: Iterable[bytes], cb_results: Combiner) -> bytes:
    for item in data:
        ...

def good_cb(*vals: bytes, maxlen: int | None = None) -> list[bytes]:
    ...
def bad_cb(*vals: bytes, maxitems: int | None) -> list[bytes]:
    ...

batch_proc([], good_cb)  # OK
batch_proc([], bad_cb)   # Error! Argument 2 has incompatible type because of
                         # different name and kind in the callback

Chamáveis que recebem outros chamáveis como argumentos podem indicar que seus tipos de parâmetro dependem uns dos outros usando ParamSpec. Além disso, se esse chamável adiciona ou remove argumentos de outros chamáveis, o operador Concatenate pode ser usado. Eles assumem a forma de Callable[ParamSpecVariable, ReturnType] e Callable[Concatenate[Arg1Type, Arg2Type, ..., ParamSpecVariable], ReturnType], respectivamente.

Alterado na versão 3.10: Callable agora oferece suporte a ParamSpec e Concatenate. Veja PEP 612 para mais detalhes.

Ver também

A documentação para ParamSpec e Concatenate contém exemplos de uso em Callable.

Genéricos

Como a informação de tipo sobre objetos mantidos em contêineres não pode ser inferida estaticamente de uma maneira genérica, muitas classes de contêineres na biblioteca padrão permitem usar subscrição para denotar o tipo esperado dos elementos dos contêineres.

from collections.abc import Mapping, Sequence

class Employee: ...

# Sequence[Employee] indicates that all elements in the sequence
# must be instances of "Employee".
# Mapping[str, str] indicates that all keys and all values in the mapping
# must be strings.
def notify_by_email(employees: Sequence[Employee],
                    overrides: Mapping[str, str]) -> None: ...

Generics can be parameterized by using a factory available in typing called TypeVar.

from collections.abc import Sequence
from typing import TypeVar

T = TypeVar('T')                  # Declare type variable "T"

def first(l: Sequence[T]) -> T:   # Function is generic over the TypeVar "T"
    return l[0]

Anotando tuplas

Para a maior parte dos tipos containers em Python, o sistema de tipagem presume que todos os elementos do contêiner são do mesmo tipo. Por exemplo:

from collections.abc import Mapping

# Type checker will infer that all elements in ``x`` are meant to be ints
x: list[int] = []

# Type checker error: ``list`` only accepts a single type argument:
y: list[int, str] = [1, 'foo']

# Type checker will infer that all keys in ``z`` are meant to be strings,
# and that all values in ``z`` are meant to be either strings or ints
z: Mapping[str, str | int] = {}

list aceita apenas um tipo de argumento, e assim o verificador de tipos emitirá um erro na atribuição y acima. Da mesma forma, Mapping aceita apenas dois tipos de argumento: O primeiro indica o tipo das chaves, e o segundo indica o tipo dos valores.

Ao contrário da maioria dos outros contêineres Python, é comum no código Python idiomático que as tuplas tenham elementos que não sejam todos do mesmo tipo. Por esse motivo, as tuplas têm um caso especial no sistema de tipagem do Python. tuple aceita qualquer quantidade de argumentos de tipo:

# OK: ``x`` is assigned to a tuple of length 1 where the sole element is an int
x: tuple[int] = (5,)

# OK: ``y`` is assigned to a tuple of length 2;
# element 1 is an int, element 2 is a str
y: tuple[int, str] = (5, "foo")

# Error: the type annotation indicates a tuple of length 1,
# but ``z`` has been assigned to a tuple of length 3
z: tuple[int] = (1, 2, 3)

Para indicar um tupla que pode ser de qualquer comprimento, e no qual todos os elementos são do mesmo tipo T, use tuple[T, ...]. Para denotar um tupla vazia, use tuple[()]. Usando apenas tuple como anotação, é equivalente a usar tuple[Any, ...]:

x: tuple[int, ...] = (1, 2)
# These reassignments are OK: ``tuple[int, ...]`` indicates x can be of any length
x = (1, 2, 3)
x = ()
# This reassignment is an error: all elements in ``x`` must be ints
x = ("foo", "bar")

# ``y`` can only ever be assigned to an empty tuple
y: tuple[()] = ()

z: tuple = ("foo", "bar")
# These reassignments are OK: plain ``tuple`` is equivalent to ``tuple[Any, ...]``
z = (1, 2, 3)
z = ()

O tipo de objetos de classe

Uma variável anotada com C pode aceitar um valor do tipo C. Por outro lado, uma variável anotada com type[C] (ou typing.Type[C]) pode aceitar valores que são classes – especificamente, ela aceitará o objeto classe de C. Por exemplo:

a = 3         # Has type ``int``
b = int       # Has type ``type[int]``
c = type(a)   # Also has type ``type[int]``

Observe que type[C] é covariante:

class User: ...
class ProUser(User): ...
class TeamUser(User): ...

def make_new_user(user_class: type[User]) -> User:
    # ...
    return user_class()

make_new_user(User)      # OK
make_new_user(ProUser)   # Also OK: ``type[ProUser]`` is a subtype of ``type[User]``
make_new_user(TeamUser)  # Still fine
make_new_user(User())    # Error: expected ``type[User]`` but got ``User``
make_new_user(int)       # Error: ``type[int]`` is not a subtype of ``type[User]``

Os únicos parâmetros válidos para type são classes, Any, type variables e uniões de qualquer um desses tipos. Por exemplo:

def new_non_team_user(user_class: type[BasicUser | ProUser]): ...

new_non_team_user(BasicUser)  # OK
new_non_team_user(ProUser)    # OK
new_non_team_user(TeamUser)   # Error: ``type[TeamUser]`` is not a subtype
                              # of ``type[BasicUser | ProUser]``
new_non_team_user(User)       # Also an error

type[Any] é equivalente a type, que é a raiz da hierarquia de metaclasses do Python.

Tipos genéricos definidos pelo usuário

Uma classe definida pelo usuário pode ser definica como uma classe genérica.

from typing import TypeVar, Generic
from logging import Logger

T = TypeVar('T')

class LoggedVar(Generic[T]):
    def __init__(self, value: T, name: str, logger: Logger) -> None:
        self.name = name
        self.logger = logger
        self.value = value

    def set(self, new: T) -> None:
        self.log('Set ' + repr(self.value))
        self.value = new

    def get(self) -> T:
        self.log('Get ' + repr(self.value))
        return self.value

    def log(self, message: str) -> None:
        self.logger.info('%s: %s', self.name, message)

Generic[T] as a base class defines that the class LoggedVar takes a single type parameter T . This also makes T valid as a type within the class body.

The Generic base class defines __class_getitem__() so that LoggedVar[T] is valid as a type:

from collections.abc import Iterable

def zero_all_vars(vars: Iterable[LoggedVar[int]]) -> None:
    for var in vars:
        var.set(0)

Um tipo genérico pode ter qualquer número de tipos de variáveis. Todas as variedades de TypeVar são permitidas como parâmetros para um tipo genérico:

from typing import TypeVar, Generic, Sequence

T = TypeVar('T', contravariant=True)
B = TypeVar('B', bound=Sequence[bytes], covariant=True)
S = TypeVar('S', int, str)

class WeirdTrio(Generic[T, B, S]):
    ...

Cada tipo dos argumentos para Generic devem ser distintos. Assim, os seguintes exemplos são inválidos:

from typing import TypeVar, Generic
...

T = TypeVar('T')

class Pair(Generic[T, T]):   # INVALID
    ...

You can use multiple inheritance with Generic:

from collections.abc import Sized
from typing import TypeVar, Generic

T = TypeVar('T')

class LinkedList(Sized, Generic[T]):
    ...

Ao herdar das classes genérico, algun tipos podem ser fixos:

from collections.abc import Mapping
from typing import TypeVar

T = TypeVar('T')

class MyDict(Mapping[str, T]):
    ...

Neste caso MyDict possui um único parâmetro, T.

O uso de uma classe genérica sem especificar tipos pressupõe Any para cada posição. No exemplo a seguir, MyIterable não é genérico, mas herda implicitamente de Iterable[Any]:

from collections.abc import Iterable

class MyIterable(Iterable): # Same as Iterable[Any]
    ...

Também há suporte para tipos genéricos definidos pelo usuário. Exemplos:

from collections.abc import Iterable
from typing import TypeVar
S = TypeVar('S')
Response = Iterable[S] | int

# Return type here is same as Iterable[str] | int
def response(query: str) -> Response[str]:
    ...

T = TypeVar('T', int, float, complex)
Vec = Iterable[tuple[T, T]]

def inproduct(v: Vec[T]) -> T: # Same as Iterable[tuple[T, T]]
    return sum(x*y for x, y in v)

Alterado na versão 3.7: Generic não possui mais uma metaclasse personalizada.

User-defined generics for parameter expressions are also supported via parameter specification variables in the form Generic[P]. The behavior is consistent with type variables’ described above as parameter specification variables are treated by the typing module as a specialized type variable. The one exception to this is that a list of types can be used to substitute a ParamSpec:

>>> from typing import Generic, ParamSpec, TypeVar

>>> T = TypeVar('T')
>>> P = ParamSpec('P')

>>> class Z(Generic[T, P]): ...
...
>>> Z[int, [dict, float]]
__main__.Z[int, (<class 'dict'>, <class 'float'>)]

Furthermore, a generic with only one parameter specification variable will accept parameter lists in the forms X[[Type1, Type2, ...]] and also X[Type1, Type2, ...] for aesthetic reasons. Internally, the latter is converted to the former, so the following are equivalent:

>>> class X(Generic[P]): ...
...
>>> X[int, str]
__main__.X[(<class 'int'>, <class 'str'>)]
>>> X[[int, str]]
__main__.X[(<class 'int'>, <class 'str'>)]

Observe que genéricos com ParamSpec podem não ter __parameters__ corretos após a substituição em alguns casos porque eles são destinados principalmente à verificação de tipo estático.

Alterado na versão 3.10: Generic agora pode ser parametrizado através de expressões de parâmetros. Veja ParamSpec e PEP 612 para mais detalhes.

Uma classe genérica definida pelo usuário pode ter ABCs como classes base sem conflito de metaclasse. Não há suporte a metaclasses genéricas. O resultado da parametrização de genéricos é armazenado em cache, e a maioria dos tipos no módulo typing são hasheáveis e comparáveis em termos de igualdade.

O tipo Any

Um tipo especial de tipo é Any. Um verificador de tipo estático tratará cada tipo como sendo compatível com Any e Any como sendo compatível com todos os tipos.

Isso significa que é possível realizar qualquer operação ou chamada de método sobre um valor do tipo Any e atribuí-lo a qualquer variável:

from typing import Any

a: Any = None
a = []          # OK
a = 2           # OK

s: str = ''
s = a           # OK

def foo(item: Any) -> int:
    # Passes type checking; 'item' could be any type,
    # and that type might have a 'bar' method
    item.bar()
    ...

Observe que nenhuma verificação de tipo é realizada ao atribuir um valor do tipo Any a um tipo mais preciso. Por exemplo, o verificador de tipo estático não relatou um erro ao atribuir a a s mesmo que s tenha sido declarado como sendo do tipo str e receba um valor int em tempo de execução!

Além disso, todas as funções sem um tipo de retorno ou tipos de parâmetro terão como padrão implicitamente o uso de Any:

def legacy_parser(text):
    ...
    return data

# A static type checker will treat the above
# as having the same signature as:
def legacy_parser(text: Any) -> Any:
    ...
    return data

Este comportamento permite que Any seja usado como uma saída de emergência quando você precisar misturar código tipado dinamicamente e estaticamente.

Compare o comportamento de Any com o comportamento de object. Semelhante a Any, todo tipo é um subtipo de object. No entanto, ao contrário de Any, o inverso não é verdadeiro: object não é um subtipo de qualquer outro tipo.

Isso significa que quando o tipo de um valor é object, um verificador de tipo rejeitará quase todas as operações nele, e atribuí-lo a uma variável (ou usá-la como valor de retorno) de um tipo mais especializado é um tipo erro. Por exemplo:

def hash_a(item: object) -> int:
    # Fails type checking; an object does not have a 'magic' method.
    item.magic()
    ...

def hash_b(item: Any) -> int:
    # Passes type checking
    item.magic()
    ...

# Passes type checking, since ints and strs are subclasses of object
hash_a(42)
hash_a("foo")

# Passes type checking, since Any is compatible with all types
hash_b(42)
hash_b("foo")

Use object para indicar que um valor pode ser de qualquer tipo de maneira segura. Use Any para indicar que um valor é tipado dinamicamente.

Subtipagem nominal vs estrutural

Inicialmente a PEP 484 definiu o sistema de tipos estáticos do Python como usando subtipagem nominal. Isto significa que uma classe A é permitida onde uma classe B é esperada se e somente se A for uma subclasse de B.

Este requisito anteriormente também se aplicava a classes base abstratas, como Iterable. O problema com essa abordagem é que uma classe teve que ser marcada explicitamente para suportá-los, o que não é pythônico e diferente do que normalmente seria feito em código Python de tipo dinamicamente idiomático. Por exemplo, isso está em conformidade com PEP 484:

from collections.abc import Sized, Iterable, Iterator

class Bucket(Sized, Iterable[int]):
    ...
    def __len__(self) -> int: ...
    def __iter__(self) -> Iterator[int]: ...

PEP 544 permite resolver este problema permitindo que os usuários escrevam o código acima sem classes base explícitas na definição de classe, permitindo que Bucket seja implicitamente considerado um subtipo de Sized e Iterable[int] por verificador de tipo estático. Isso é conhecido como subtipagem estrutural (ou tipagem pato estática):

from collections.abc import Iterator, Iterable

class Bucket:  # Note: no base classes
    ...
    def __len__(self) -> int: ...
    def __iter__(self) -> Iterator[int]: ...

def collect(items: Iterable[int]) -> int: ...
result = collect(Bucket())  # Passes type check

Além disso, ao criar uma subclasse de uma classe especial Protocol, um usuário pode definir novos protocolos personalizados para aproveitar ao máximo a subtipagem estrutural (veja exemplos abaixo).

Conteúdo do módulo

O módulo typing define as seguintes classes, funções e decoracores.

Tipos primitivos especiais

Tipos especiais

Eles podem ser usados como tipos em anotações. Eles não oferecem suporte a subscrição usando [].

typing.Any

Tipo especial que indica um tipo irrestrito.

  • Todos os tipos são compatíveis com Any.

  • Any é compatível com todos os tipos.

Alterado na versão 3.11: Any agora pode ser usado como classe base. Isso pode ser útil para evitar erros do verificador de tipo com classes que podem digitar em qualquer lugar ou são altamente dinâmicas.

typing.AnyStr

Uma tipo variável restrito.

Definição:

AnyStr = TypeVar('AnyStr', str, bytes)

AnyStr deve ser usado para funções que podem aceitar argumentos str ou bytes mas não podem permitir que os dois se misturem.

Por exemplo:

def concat(a: AnyStr, b: AnyStr) -> AnyStr:
    return a + b

concat("foo", "bar")    # OK, output has type 'str'
concat(b"foo", b"bar")  # OK, output has type 'bytes'
concat("foo", b"bar")   # Error, cannot mix str and bytes

Note que, apesar do nome, AnyStr não tem nada a ver com o tipo Any, nem significa “qualquer string”. Em particular, AnyStr e str | bytes são diferentes entre si e têm casos de uso diferentes:

# Invalid use of AnyStr:
# The type variable is used only once in the function signature,
# so cannot be "solved" by the type checker
def greet_bad(cond: bool) -> AnyStr:
    return "hi there!" if cond else b"greetings!"

# The better way of annotating this function:
def greet_proper(cond: bool) -> str | bytes:
    return "hi there!" if cond else b"greetings!"
typing.LiteralString

Tipo especial que inclui apenas strings literais.

Qualquer literal de string é compatível com LiteralString, assim como outro LiteralString. Entretanto, um objeto digitado apenas str não é. Uma string criada pela composição de objetos do tipo LiteralString também é aceitável como uma LiteralString.

Exemplo:

def run_query(sql: LiteralString) -> None:
    ...

def caller(arbitrary_string: str, literal_string: LiteralString) -> None:
    run_query("SELECT * FROM students")  # OK
    run_query(literal_string)  # OK
    run_query("SELECT * FROM " + literal_string)  # OK
    run_query(arbitrary_string)  # type checker error
    run_query(  # type checker error
        f"SELECT * FROM students WHERE name = {arbitrary_string}"
    )

LiteralString é útil para APIs sensíveis onde strings arbitrárias geradas pelo usuário podem gerar problemas. Por exemplo, os dois casos acima que geram erros no verificador de tipo podem ser vulneráveis a um ataque de injeção de SQL.

Veja PEP 675 para mais detalhes.

Novo na versão 3.11.

typing.Never

The bottom type, a type that has no members.

This can be used to define a function that should never be called, or a function that never returns:

from typing import Never

def never_call_me(arg: Never) -> None:
    pass

def int_or_str(arg: int | str) -> None:
    never_call_me(arg)  # type checker error
    match arg:
        case int():
            print("It's an int")
        case str():
            print("It's a str")
        case _:
            never_call_me(arg)  # OK, arg is of type Never

Novo na versão 3.11: On older Python versions, NoReturn may be used to express the same concept. Never was added to make the intended meaning more explicit.

typing.NoReturn

Tipo especial indicando que uma função nunca retorna.

Por exemplo:

from typing import NoReturn

def stop() -> NoReturn:
    raise RuntimeError('no way')

NoReturn can also be used as a bottom type, a type that has no values. Starting in Python 3.11, the Never type should be used for this concept instead. Type checkers should treat the two equivalently.

Novo na versão 3.6.2.

typing.Self

Tipo especial para representar a classe atual inclusa.

Por exemplo:

from typing import Self, reveal_type

class Foo:
    def return_self(self) -> Self:
        ...
        return self

class SubclassOfFoo(Foo): pass

reveal_type(Foo().return_self())  # Revealed type is "Foo"
reveal_type(SubclassOfFoo().return_self())  # Revealed type is "SubclassOfFoo"

Esta anotação é semanticamente equivalente à seguinte, embora de forma mais sucinta:

from typing import TypeVar

Self = TypeVar("Self", bound="Foo")

class Foo:
    def return_self(self: Self) -> Self:
        ...
        return self

Em geral, se algo retorna self, como nos exemplos acima, você deve usar Self como anotação de retorno. Se Foo.return_self foi anotado como retornando "Foo", então o verificador de tipo inferiria o objeto retornado de SubclassOfFoo.return_self como sendo do tipo Foo em vez de SubclassOfFoo.

Outros casos de uso comuns incluem:

  • classmethods que são usados como construtores alternativos e retornam instâncias do parâmetro cls.

  • Anotando um método __enter__() que retorna self.

Você não deveria usar Self como a anotação de retorno se não for garantido que o método retorne uma instância de uma subclasse quando a classe for subclassificada:

class Eggs:
    # Self would be an incorrect return annotation here,
    # as the object returned is always an instance of Eggs,
    # even in subclasses
    def returns_eggs(self) -> "Eggs":
        return Eggs()

Veja PEP 673 para mais detalhes.

Novo na versão 3.11.

typing.TypeAlias

Anotações especiais para declarar explicitamente um apelido de tipo.

Por exemplo:

from typing import TypeAlias

Factors: TypeAlias = list[int]

TypeAlias is particularly useful for annotating aliases that make use of forward references, as it can be hard for type checkers to distinguish these from normal variable assignments:

from typing import Generic, TypeAlias, TypeVar

T = TypeVar("T")

# "Box" does not exist yet,
# so we have to use quotes for the forward reference.
# Using ``TypeAlias`` tells the type checker that this is a type alias declaration,
# not a variable assignment to a string.
BoxOfStrings: TypeAlias = "Box[str]"

class Box(Generic[T]):
    @classmethod
    def make_box_of_strings(cls) -> BoxOfStrings: ...

Veja PEP 613 para mais detalhes.

Novo na versão 3.10.

Formas especiais

Eles podem ser usados ​como tipos em anotações. Todos eles oferecem suporte a subscrição usando [], mas cada um tem uma sintaxe única.

typing.Union

Tipo de união; Union[X, Y] é equivalente a X | Y e significa X ou Y.

Para definir uma união, use, por exemplo. Union[int, str] ou a abreviatura int | str. Usar essa abreviação é recomendado. Detalhes:

  • Os argumentos devem ser tipos e deve haver pelo menos um.

  • As uniões de uniões são achatadas, por exemplo:

    Union[Union[int, str], float] == Union[int, str, float]

  • As uniões de um único argumento desaparecem, por exemplo:

    Union[int] == int  # The constructor actually returns int

  • Argumento redundantes são pulados, e.g.:

    Union[int, str, int] == Union[int, str] == int | str

  • Ao comparar uniões, a ordem de argumentos é ignorada. Por exemplo:

    Union[int, str] == Union[str, int]

  • Você não pode estender ou instanciar uma Union

  • Você não pode escrever Union[X][Y].

Alterado na versão 3.7: Não remova subclasses explícitas de uniões em tempo de execução.

Alterado na versão 3.10: Uniões agora podem ser escritas com X | Y. Veja expressões de união de tipos.

typing.Optional

Optional[X] equivale a X | None (ou Union[X, None]).

Note que isso não é o mesmo conceito de um argumento opcional, que possui um valor por padrão. Um argumento opcional com padrão não requer o qualificador Optional em sua anotação de tipo só por ser opcional. Por exemplo:

def foo(arg: int = 0) -> None:
    ...

Por outro lado, se um valor explícito de None for permitido, o uso de Optional é apropriado, seja o argumento opcional ou não. Por exemplo:

def foo(arg: Optional[int] = None) -> None:
    ...

Alterado na versão 3.10: Optional agora pode ser escrito como X | None. Veja expressões de união de tipos.

typing.Concatenate

Forma especial para anotar funções de ordem superior.

Concatenate pode ser usado em conjunção com Callable e ParamSpec para anotar um chamável de maior ordem que adiciona, remove ou transforma parâmetros de outro chamável. Seu uso é feito na forma Concatenate[Arg1Type, Arg2Type, ..., ParamSpecVariable], Concatenate atualmente só é válido quando usado como primeiro argumento de um Callable. O último parâmetro de Concatenate deve ser um ParamSpec ou reticências (...).

Por exemplo, para anotar um decorador with_lock que oferece uma instância de threading.Lock para a função decorada, Concatenate pode ser usado para indicar que with_lock espera um chamável cujo primeiro argumento tem tipo Lock, e retorna um chamável com uma assinatura de tipos diferente. Neste caso, o ParamSpec indica que os tipos dos parâmetros do chamável retornado dependem dos tipos dos parâmetros do chamável de entrada:

from collections.abc import Callable
from threading import Lock
from typing import Concatenate, ParamSpec, TypeVar

P = ParamSpec('P')
R = TypeVar('R')

# Use this lock to ensure that only one thread is executing a function
# at any time.
my_lock = Lock()

def with_lock(f: Callable[Concatenate[Lock, P], R]) -> Callable[P, R]:
    '''A type-safe decorator which provides a lock.'''
    def inner(*args: P.args, **kwargs: P.kwargs) -> R:
        # Provide the lock as the first argument.
        return f(my_lock, *args, **kwargs)
    return inner

@with_lock
def sum_threadsafe(lock: Lock, numbers: list[float]) -> float:
    '''Add a list of numbers together in a thread-safe manner.'''
    with lock:
        return sum(numbers)

# We don't need to pass in the lock ourselves thanks to the decorator.
sum_threadsafe([1.1, 2.2, 3.3])

Novo na versão 3.10.

Ver também

typing.Literal

Forma especial de tipagem para definir “tipos literais”.

Literal pode ser usado para indicar aos verificadores de tipo que o objeto anotado tem valor equivalente a algum dos literais oferecidos.

Por exemplo:

def validate_simple(data: Any) -> Literal[True]:  # always returns True
    ...

Mode: TypeAlias = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: Mode) -> str:
    ...

open_helper('/some/path', 'r')      # Passes type check
open_helper('/other/path', 'typo')  # Error in type checker

Literal[...] não é subclasse. Em tempo de execução, permite-se um valor arbitrário como argumento de tipo para Literal[...], mas verificadores de tipo podem impor restrições. Veja PEP 586 para mais detalhes sobre tipos literais.

Novo na versão 3.8.

Alterado na versão 3.9.1: Literal agora remove parâmetros duplicados. Comparações de igualdade entre objetos Literal não dependem da ordem. Objetos Literal agora levantam uma exceção TypeError durante comparações de igualdade se um de seus parâmetros não for hasheável.

typing.ClassVar

Uma construção especial de tipagem para marcar variáveis de classe.

Como introduzido na PEP 526, uma variável cuja anotação de tipo tem um invólucro ClassVar indica que um dado atributo deve ser usado como uma variável de classe, e que ele não deve ser definido em instâncias dessa classe. Modo de usar:

class Starship:
    stats: ClassVar[dict[str, int]] = {} # class variable
    damage: int = 10                     # instance variable

ClassVar aceita apenas tipos e não pode ser subscrita posteriormente.

ClassVar não é uma classe, e não deve ser usada com isinstance() ou issubclass(). ClassVar não muda com o comportamento do Python em tempo de execução, mas pode ser usada por verificadores de tipos de terceiros. Por exemplo, um verificador de tipos pode sinalizar que o seguinte código é errado:

enterprise_d = Starship(3000)
enterprise_d.stats = {} # Error, setting class variable on instance
Starship.stats = {}     # This is OK

Novo na versão 3.5.3.

typing.Final

Uma construção especial de tipagem para indicar nomes finais a verificadores de tipos

Nomes finais não podem ser reatribuídos em qualquer escopo. Nomes finais declarados em escopos de classe não podem ser substituídos em subclasses.

Por exemplo:

MAX_SIZE: Final = 9000
MAX_SIZE += 1  # Error reported by type checker

class Connection:
    TIMEOUT: Final[int] = 10

class FastConnector(Connection):
    TIMEOUT = 1  # Error reported by type checker

Não há verificação em tempo de execução dessas propriedades. Veja PEP 591 para mais detalhes.

Novo na versão 3.8.

typing.Required

Uma construção especial de tipagem para marcar uma chave de TypedDict como necessária.

Isso é útil principalmente para TypedDicts com total=False. Veja TypedDict e PEP 655 para obter mais detalhes.

Novo na versão 3.11.

typing.NotRequired

Uma construção especial de tipagem para marcar uma chave de TypedDict como potencialmente ausente.

Veja TypedDict e PEP 655 para obter mais detalhes.

Novo na versão 3.11.

typing.Annotated

Forma especial de tipagem para adicionar metadados específicos de contexto para uma anotação.

Adiciona metadados x a um determinado tipo T usando a anotação Annotated[T, x]. Os metadados adicionados usando Annotated podem ser usados por ferramentas de análise estática ou em tempo de execução. Em tempo de execução, os metadados são armazenados em um atributo __metadata__.

Se uma biblioteca ou ferramenta encontrar uma anotação Annotated[T, x] e ela não tiver lógica especial para os metadados, ela deverá ignorar os metadados e simplesmente tratar a anotação como T. Dessa forma, Annotated pode ser útil em códigos que desejarem usar a anotação para propósitos fora do sistema de tipagem estática do Python.

Usar Annotated[T, x] como um anotação ainda permite a verificação estática do tipo de T, pois os verificadores de tipo simplesmente ignoram os metadados em x. Dessa forma, o Annotated difere do decorador @no_type_check, que também pode ser usado para adicionar anotações fora do escopo do sistema de tipagem, mas desativa completamente a verificação de tipos para uma função ou classe.

A responsabilidade de como interpretar os metadados é da ferramenta ou da biblioteca que encontrar uma anotação Annotated. Uma ferramenta ou biblioteca que encontrar um tipo Annotated poderá examinar os elementos de metadados para determinar se eles são de interesse (por exemplo, usando isinstance()).

Annotated[<type>, <metadata>]

Aqui está um exemplo de como você pode usar Annotated para adicionar metadados a anotações de tipos se estiver fazendo uma análise de intervalos:

@dataclass
class ValueRange:
    lo: int
    hi: int

T1 = Annotated[int, ValueRange(-10, 5)]
T2 = Annotated[T1, ValueRange(-20, 3)]

Detalhes da sintaxe:

  • O primeiro argumento de Annotated deve ser um tipo válido

  • Múltiplos elementos de metadados podem ser fornecidos (Annotated dá suporte a argumentos variádicos):

    @dataclass
class ctype:
    kind: str

Annotated[int, ValueRange(3, 10), ctype("char")]

    Cabe à ferramenta que consome as anotações decidir se o cliente tem permissão de adicionar vários elementos de metadados a uma anotação e como mesclar essas anotações.

  • Annotated deve ser subscrito com pelo menos dois argumentos (Annotated[int] é inválido)

  • A ordem dos elementos de metadados é preservada e é importante em verificações de igualdade:

    assert Annotated[int, ValueRange(3, 10), ctype("char")] != Annotated[
    int, ctype("char"), ValueRange(3, 10)
]

  • Os tipos Annotated aninhados são achatados. A ordem dos elementos de metadados começa com a anotação mais interna:

    assert Annotated[Annotated[int, ValueRange(3, 10)], ctype("char")] == Annotated[
    int, ValueRange(3, 10), ctype("char")
]

  • Elementos duplicados de metadata não são removidos:

    assert Annotated[int, ValueRange(3, 10)] != Annotated[
    int, ValueRange(3, 10), ValueRange(3, 10)
]

  • Annotated pode ser usado com apelidos aninhados e apelidos genéricos:

    @dataclass
class MaxLen:
    value: int

T = TypeVar("T")
Vec: TypeAlias = Annotated[list[tuple[T, T]], MaxLen(10)]

assert Vec[int] == Annotated[list[tuple[int, int]], MaxLen(10)]

  • Annotated não pode ser usado com um TypeVarTuple desempacotado:

    Variadic: TypeAlias = Annotated[*Ts, Ann1]  # NOT valid

    Isso deve equivaler a:

    Annotated[T1, T2, T3, ..., Ann1]

    onde T1, T2, etc. são TypeVars. Isso seria inválido: somente um tipo deve ser passado para Annotated.

  • Por padrão, get_type_hints() retira os metadados de anotações. Passe include_extras=True para preservar os metadados:

    >>> from typing import Annotated, get_type_hints
>>> def func(x: Annotated[int, "metadata"]) -> None: pass
...
>>> get_type_hints(func)
{'x': <class 'int'>, 'return': <class 'NoneType'>}
>>> get_type_hints(func, include_extras=True)
{'x': typing.Annotated[int, 'metadata'], 'return': <class 'NoneType'>}

  • Em tempo de execução, os metadados associados a um tipo Annotated podem ser recuperados por meio do atributo __metadata__:

    >>> from typing import Annotated
>>> X = Annotated[int, "very", "important", "metadata"]
>>> X
typing.Annotated[int, 'very', 'important', 'metadata']
>>> X.__metadata__
('very', 'important', 'metadata')

Ver também

PEP 593 - Anotações flexíveis para funções e variáveis

A PEP que introduz Annotated à biblioteca padrão.

Novo na versão 3.9.

typing.TypeGuard

Special typing construct for marking user-defined type guard functions.

TypeGuard can be used to annotate the return type of a user-defined type guard function. TypeGuard only accepts a single type argument. At runtime, functions marked this way should return a boolean.

TypeGuard aims to benefit type narrowing – a technique used by static type checkers to determine a more precise type of an expression within a program’s code flow. Usually type narrowing is done by analyzing conditional code flow and applying the narrowing to a block of code. The conditional expression here is sometimes referred to as a “type guard”:

def is_str(val: str | float):
    # "isinstance" type guard
    if isinstance(val, str):
        # Type of ``val`` is narrowed to ``str``
        ...
    else:
        # Else, type of ``val`` is narrowed to ``float``.
        ...

Sometimes it would be convenient to use a user-defined boolean function as a type guard. Such a function should use TypeGuard[...] as its return type to alert static type checkers to this intention.

Usar -> TypeGuard informa ao verificador de tipo estático que, para uma determinada função:

  1. O valor de retorno é um booleano.

  2. Se o valor de retorno for True, o tipo de seu argumento é o tipo dentro de TypeGuard.

Por exemplo:

def is_str_list(val: list[object]) -> TypeGuard[list[str]]:
    '''Determines whether all objects in the list are strings'''
    return all(isinstance(x, str) for x in val)

def func1(val: list[object]):
    if is_str_list(val):
        # Type of ``val`` is narrowed to ``list[str]``.
        print(" ".join(val))
    else:
        # Type of ``val`` remains as ``list[object]``.
        print("Not a list of strings!")

If is_str_list is a class or instance method, then the type in TypeGuard maps to the type of the second parameter after cls or self.

In short, the form def foo(arg: TypeA) -> TypeGuard[TypeB]: ..., means that if foo(arg) returns True, then arg narrows from TypeA to TypeB.

Nota

TypeB need not be a narrower form of TypeA – it can even be a wider form. The main reason is to allow for things like narrowing list[object] to list[str] even though the latter is not a subtype of the former, since list is invariant. The responsibility of writing type-safe type guards is left to the user.

TypeGuard também funciona com tipos variáveis. Consulte a PEP 647 para obter mais detalhes.

Novo na versão 3.10.

typing.Unpack

Operador de tipagem para marcar conceitualmente um objeto como tendo sido desempacotado.

Por exemplo, usar o operador de desempacotamento * em uma tupla de tipos variáveis equivale a usar o Unpack para marcar a tupla de tipos variáveis como tendo sido desempacotada:

Ts = TypeVarTuple('Ts')
tup: tuple[*Ts]
# Effectively does:
tup: tuple[Unpack[Ts]]

Na verdade, Unpack pode ser usado de forma intercambiável com * no contexto dos tipos typing.TypeVarTuple e builtins.tuple. Você pode ver Unpack sendo usado explicitamente em versões mais antigas do Python, onde * não podia ser usado em certos lugares:

# In older versions of Python, TypeVarTuple and Unpack
# are located in the `typing_extensions` backports package.
from typing_extensions import TypeVarTuple, Unpack

Ts = TypeVarTuple('Ts')
tup: tuple[*Ts]         # Syntax error on Python <= 3.10!
tup: tuple[Unpack[Ts]]  # Semantically equivalent, and backwards-compatible

Novo na versão 3.11.

Building generic types

The following classes should not be used directly as annotations. Their intended purpose is to be building blocks for creating generic types.

class typing.Generic

Classe base abstrata para tipos genéricos

A generic type is typically declared by inheriting from an instantiation of this class with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
        # Etc.

Esta classe pode ser utilizada como segue:

X = TypeVar('X')
Y = TypeVar('Y')

def lookup_name(mapping: Mapping[X, Y], key: X, default: Y) -> Y:
    try:
        return mapping[key]
    except KeyError:
        return default
class typing.TypeVar(name, *constraints, bound=None, covariant=False, contravariant=False)

Tipo variável.

Uso:

T = TypeVar('T')  # Can be anything
S = TypeVar('S', bound=str)  # Can be any subtype of str
A = TypeVar('A', str, bytes)  # Must be exactly str or bytes

Type variables exist primarily for the benefit of static type checkers. They serve as the parameters for generic types as well as for generic function and type alias definitions. See Generic for more information on generic types. Generic functions work as follows:

def repeat(x: T, n: int) -> Sequence[T]:
    """Return a list containing n references to x."""
    return [x]*n


def print_capitalized(x: S) -> S:
    """Print x capitalized, and return x."""
    print(x.capitalize())
    return x


def concatenate(x: A, y: A) -> A:
    """Add two strings or bytes objects together."""
    return x + y

Note that type variables can be bound, constrained, or neither, but cannot be both bound and constrained.

Type variables may be marked covariant or contravariant by passing covariant=True or contravariant=True. See PEP 484 for more details. By default, type variables are invariant.

Bound type variables and constrained type variables have different semantics in several important ways. Using a bound type variable means that the TypeVar will be solved using the most specific type possible:

x = print_capitalized('a string')
reveal_type(x)  # revealed type is str

class StringSubclass(str):
    pass

y = print_capitalized(StringSubclass('another string'))
reveal_type(y)  # revealed type is StringSubclass

z = print_capitalized(45)  # error: int is not a subtype of str

Type variables can be bound to concrete types, abstract types (ABCs or protocols), and even unions of types:

U = TypeVar('U', bound=str|bytes)  # Can be any subtype of the union str|bytes
V = TypeVar('V', bound=SupportsAbs)  # Can be anything with an __abs__ method

Porém, usar um tipo variável restrito significa que a TypeVar só poderá ser resolvida como sendo exatamente uma das restrições dadas:

a = concatenate('one', 'two')
reveal_type(a)  # revealed type is str

b = concatenate(StringSubclass('one'), StringSubclass('two'))
reveal_type(b)  # revealed type is str, despite StringSubclass being passed in

c = concatenate('one', b'two')  # error: type variable 'A' can be either str or bytes in a function call, but not both

Em tempo de execução, isinstance(x, T) levantará TypeError.

__name__

The name of the type variable.

__covariant__

Whether the type var has been marked as covariant.

__contravariant__

Whether the type var has been marked as contravariant.

__bound__

The bound of the type variable, if any.

__constraints__

A tuple containing the constraints of the type variable, if any.

class typing.TypeVarTuple(name)

Type variable tuple. A specialized form of type variable that enables variadic generics.

Uso:

T = TypeVar("T")
Ts = TypeVarTuple("Ts")

def move_first_element_to_last(tup: tuple[T, *Ts]) -> tuple[*Ts, T]:
    return (*tup[1:], tup[0])

A normal type variable enables parameterization with a single type. A type variable tuple, in contrast, allows parameterization with an arbitrary number of types by acting like an arbitrary number of type variables wrapped in a tuple. For example:

# T is bound to int, Ts is bound to ()
# Return value is (1,), which has type tuple[int]
move_first_element_to_last(tup=(1,))

# T is bound to int, Ts is bound to (str,)
# Return value is ('spam', 1), which has type tuple[str, int]
move_first_element_to_last(tup=(1, 'spam'))

# T is bound to int, Ts is bound to (str, float)
# Return value is ('spam', 3.0, 1), which has type tuple[str, float, int]
move_first_element_to_last(tup=(1, 'spam', 3.0))

# This fails to type check (and fails at runtime)
# because tuple[()] is not compatible with tuple[T, *Ts]
# (at least one element is required)
move_first_element_to_last(tup=())

Observe o uso do operador de desempacotamento * em tuple[T, *Ts]. Conceitualmente, você pode interpretar Ts como uma tupla de tipos variáveis (T1, T2, ...) . Então o tipo tuple[T, *Ts] se tornaria tuple[T, *(T1, T2, ...)], que equivale a tuple[T, T1, T2, ...]. (Note que, em versões mais antigas de Python, você pode encontrar isso escrito com Unpack em vez de Unpack[Ts].)

Tuplas de tipos variáveis devem sempre ser desempacotadas. Isso ajuda a distinguir entre tuplas de tipos variáveis e tipos variáveis normais:

x: Ts          # Not valid
x: tuple[Ts]   # Not valid
x: tuple[*Ts]  # The correct way to do it

As tuplas de tipos variáveis podem ser usadas no mesmo contexto que tipos variáveis normais. Por exemplo, em argumentos, tipos de retorno e definições de classes:

Shape = TypeVarTuple("Shape")
class Array(Generic[*Shape]):
    def __getitem__(self, key: tuple[*Shape]) -> float: ...
    def __abs__(self) -> "Array[*Shape]": ...
    def get_shape(self) -> tuple[*Shape]: ...

As tuplas de tipos variáveis podem ser combinadas com tipos variáveis normais:

DType = TypeVar('DType')
Shape = TypeVarTuple('Shape')

class Array(Generic[DType, *Shape]):  # This is fine
    pass

class Array2(Generic[*Shape, DType]):  # This would also be fine
    pass

class Height: ...
class Width: ...

float_array_1d: Array[float, Height] = Array()     # Totally fine
int_array_2d: Array[int, Height, Width] = Array()  # Yup, fine too

No entanto, observe que no máximo uma tupla de tipos variáveis pode aparecer em uma única lista de argumentos de tipo ou parâmetros de tipo:

x: tuple[*Ts, *Ts]                     # Not valid
class Array(Generic[*Shape, *Shape]):  # Not valid
    pass

Por fim, uma tupla de tipos variáveis desempacotada pode ser usada como anotação de tipo de *args:

def call_soon(
         callback: Callable[[*Ts], None],
         *args: *Ts
) -> None:
    ...
    callback(*args)

Ao contrário do que acontece com anotações não desempacotadas de *args - por exemplo, *args: int, que especificaria que todos os argumentos são int -, *args: *Ts permite referenciar os tipos de cada argumento em *args individualmente. Isso nos permite garantir que os tipos em *args passados para call_soon correspondem aos tipos dos argumentos (posicionais) de callback.

Consulte a PEP 646 para mais detalhes sobre tuplas de tipos variáveis.

__name__

O nome da tupla de tipos variáveis.

Novo na versão 3.11.

class typing.ParamSpec(name, *, bound=None, covariant=False, contravariant=False)

Variável de especificação de parâmetro. Uma versão especializada de tipos variáveis.

Uso:

P = ParamSpec('P')

Variáveis de especificação de parâmetro existem principalmente para o benefício de verificadores de tipo estático. São usadas para encaminhar os tipos de parâmetros de um chamável para outro chamável – um padrão comumente encontrado em funções e decoradores de ordem superior. Só são válidas quando usados em Concatenate, ou como o primeiro argumento para Callable, ou como parâmetro para genéricos definidos pelo usuário. Consulte Generic para obter mais informações sobre tipos genéricos.

Por exemplo, para adicionar um registro básico de eventos a uma função, é possível criar um decorador add_logging para registrar chamadas de função. A variável de especificação de parâmetro informa ao verificador de tipos que o chamável passado para o decorador e o novo chamável retornado por ele têm parâmetros de tipo interdependentes:

from collections.abc import Callable
from typing import TypeVar, ParamSpec
import logging

T = TypeVar('T')
P = ParamSpec('P')

def add_logging(f: Callable[P, T]) -> Callable[P, T]:
    '''A type-safe decorator to add logging to a function.'''
    def inner(*args: P.args, **kwargs: P.kwargs) -> T:
        logging.info(f'{f.__name__} was called')
        return f(*args, **kwargs)
    return inner

@add_logging
def add_two(x: float, y: float) -> float:
    '''Add two numbers together.'''
    return x + y

Without ParamSpec, the simplest way to annotate this previously was to use a TypeVar with bound Callable[..., Any]. However this causes two problems:

  1. O verificador de tipos não consegue verificar a função inner, porque *args e **kwargs precisam ter tipo Any.

  2. cast() pode ser exigida no corpo do decorador add_logging ao retornar a função inner, ou o verificador de tipo estático deverá ser instruído a ignorar o return inner.

args
kwargs

Como ParamSpec capturar tanto parâmetros posicionais quanto parâmetros nomeados, P.args e P.kwargs podem ser usados para dividir um ParamSpec em seus componentes. P.args representa a tupla de parâmetros posicionais em uma determinada chamada e só deve ser usada para anotar *args. P.kwargs representa o mapeamento de parâmetros nomeados para seus valores em uma determinada chamada, e só deve ser usado para anotar **kwargs. Ambos os atributos exigem que o parâmetro anotado esteja em escopo. Em tempo de execução, P.args e P.kwargs são instâncias, respectivamente, de ParamSpecArgs e ParamSpecKwargs.

__name__

O nome da especificação de parâmetros.

Variáveis de especificação de parâmetros criadas com covariant=True ou contravariant=True podem ser usadas para declarar tipos genéricos covariantes ou contravariantes. O argumento bound também é aceito, semelhante ao TypeVar. Porém, a semântica real dessas palavras reservadas ainda não foi decidida.

Novo na versão 3.10.

Nota

Somente variáveis de especificação de parâmetro definidas em escopo global podem ser serializadas com pickle.

Ver também

typing.ParamSpecArgs
typing.ParamSpecKwargs

Tipos dos argumentos e dos argumentos nomeados de um ParamSpec. O atributo P.args de um ParamSpec é uma instância de ParamSpecArgs, e o atributo P.kwargs é uma instância de ParamSpecKwargs. São destinados à introspecção em tempo de execução, e não têm nenhum significado especial para o verificador de tipo estático.

Chamar get_origin() em qualquer um desses objetos fará retornará o ParamSpec original:

>>> from typing import ParamSpec, get_origin
>>> P = ParamSpec("P")
>>> get_origin(P.args) is P
True
>>> get_origin(P.kwargs) is P
True

Novo na versão 3.10.

Outras diretivas especiais

Essas funções e classes não devem ser usadas diretamente como anotações. O objetivo é que sejam blocos de construção para criar e declarar tipos.

class typing.NamedTuple

Versão tipada de collections.namedtuple().

Uso:

class Employee(NamedTuple):
    name: str
    id: int

Isso equivale a:

Employee = collections.namedtuple('Employee', ['name', 'id'])

Para dar um valor padrão a um campo, você pode atribuir um valor a ele no corpo da classe:

class Employee(NamedTuple):
    name: str
    id: int = 3

employee = Employee('Guido')
assert employee.id == 3

Campos com valores padrão devem vir depois de quaisquer campos sem valores padrão.

A classe resultante tem um atributo extra __annotations__ que fornece um dicionário que mapeia os nomes de campos para os tipos de campos. (Os nomes de campos estão no atributo _fields e os valores padrão estão no atributo _field_defaults, e ambos fazem parte da API de namedtuple().)

Subclasses de NamedTuple também podem ter docstrings e métodos:

class Employee(NamedTuple):
    """Represents an employee."""
    name: str
    id: int = 3

    def __repr__(self) -> str:
        return f'<Employee {self.name}, id={self.id}>'

Subclasses de NamedTuple podem ser genéricas:

class Group(NamedTuple, Generic[T]):
    key: T
    group: list[T]

Uso retrocompatível:

Employee = NamedTuple('Employee', [('name', str), ('id', int)])

Alterado na versão 3.6: Adiciona suporte à sintaxe de anotação de variáveis da PEP 526.

Alterado na versão 3.6.1: Adiciona suporte a valores padrão, métodos, e docstrings.

Alterado na versão 3.8: Os atributos _field_types e __annotations__ agora são dicionários regulares em vez de instâncias de OrderedDict.

Alterado na versão 3.9: Remove o atributo _field_types em favor do atributo mais padrão __annotations__ que tem as mesmas informações.

Alterado na versão 3.11: Adicionado suporte a namedtuples genéricas.

class typing.NewType(name, tp)

Helper class to create low-overhead distinct types.

Um tipo NewType é considerado um tipo distinto por um verificador de tipos. Porém, em tempo de execução, chamar NewType retorna seu argumento inalterado.

Uso:

UserId = NewType('UserId', int)  # Declare the NewType "UserId"
first_user = UserId(1)  # "UserId" returns the argument unchanged at runtime
__module__

O endereço módulo no qual o novo tipo é definido.

__name__

O nome do novo tipo.

__supertype__

O tipo na qual o novo tipo é baseado.

Novo na versão 3.5.2.

Alterado na versão 3.10: NewType agora é uma classe em vez de uma função.

class typing.Protocol(Generic)

Classe base para classes de protocolo.

Classes de protocolo são definidas assim:

class Proto(Protocol):
    def meth(self) -> int:
        ...

Essas classes são usadas principalmente com verificadores de tipo estático que reconhecem a subtipagem estrutural (tipagem pato estática). Por exemplo,:

class C:
    def meth(self) -> int:
        return 0

def func(x: Proto) -> int:
    return x.meth()

func(C())  # Passes static type check

Consulte a PEP 544 para obter mais detalhes. Classes de protocolo decoradas com runtime_checkable() (descritas posteriormente) funcionam como protocolos em tempo de execução simples, somente verificando a presença de determinados atributos, e ignorando suas assinaturas de tipo.

Classes de protocolo podem ser genéricas. Por exemplo:

T = TypeVar("T")

class GenProto(Protocol[T]):
    def meth(self) -> T:
        ...

Novo na versão 3.8.

@typing.runtime_checkable

Marca uma classe de protocolo como um protocolo de tempo de execução.

Such a protocol can be used with isinstance() and issubclass(). This raises TypeError when applied to a non-protocol class. This allows a simple-minded structural check, very similar to “one trick ponies” in collections.abc such as Iterable. For example:

@runtime_checkable
class Closable(Protocol):
    def close(self): ...

assert isinstance(open('/some/file'), Closable)

@runtime_checkable
class Named(Protocol):
    name: str

import threading
assert isinstance(threading.Thread(name='Bob'), Named)

Nota

runtime_checkable() verificará apenas a presença dos métodos ou atributos obrigatórios, em vez de tipos ou assinaturas de tipos. Por exemplo, o ssl.SSLObject é uma classe e, portanto, passa por uma verificação issubclass() em relação ao Callable. No entanto, o método ssl.SSLObject.__init__ existe apenas para levantar um TypeError com uma mensagem mais informativa, o que impossibilita chamar (instanciar) o ssl.SSLObject.

Nota

A verificação isinstance() sobre um protocolo verificável em tempo de execução pode ser surpreendentemente lenta se comparada a uma verificação isinstance() sobre outros tipos de classe. Considere usar expressões alternativas, como chamar a função hasattr() para realizar verificações estruturais em código sensível a desempenho.

Novo na versão 3.8.

class typing.TypedDict(dict)

Uma construção especial para adicionar dicas de tipo a um dicionário. Em tempo de execução, é um simples dict.

TypedDict declara um tipo dicionário que espera que todas as suas instâncias tenham um determinado conjunto de chaves, onde cada chave está associada a um valor de um tipo consistente. Essa expectativa não é verificada em tempo de execução, mas é imposta apenas por verificadores de tipos. Modo de usar:

class Point2D(TypedDict):
    x: int
    y: int
    label: str

a: Point2D = {'x': 1, 'y': 2, 'label': 'good'}  # OK
b: Point2D = {'z': 3, 'label': 'bad'}           # Fails type check

assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')

To allow using this feature with older versions of Python that do not support PEP 526, TypedDict supports two additional equivalent syntactic forms:

  • Utilizando um literal dict como segundo argumento:

    Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})

  • Using keyword arguments:

    Point2D = TypedDict('Point2D', x=int, y=int, label=str)

Descontinuado desde a versão 3.11, será removido na versão 3.13: The keyword-argument syntax is deprecated in 3.11 and will be removed in 3.13. It may also be unsupported by static type checkers.

The functional syntax should also be used when any of the keys are not valid identifiers, for example because they are keywords or contain hyphens. Example:

# raises SyntaxError
class Point2D(TypedDict):
    in: int  # 'in' is a keyword
    x-y: int  # name with hyphens

# OK, functional syntax
Point2D = TypedDict('Point2D', {'in': int, 'x-y': int})

Por padrão, todas as chaves devem estar presentes em um TypedDict. É possível marcar chaves individuais como não obrigatórias usando NotRequired:

class Point2D(TypedDict):
    x: int
    y: int
    label: NotRequired[str]

# Alternative syntax
Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': NotRequired[str]})

Isso significa que um TypedDict Point2D pode ter a chave label omitida.

Também é possível marcar todas as chaves como não necessárias por padrão, especificando a totalidade como False:

class Point2D(TypedDict, total=False):
    x: int
    y: int

# Alternative syntax
Point2D = TypedDict('Point2D', {'x': int, 'y': int}, total=False)

Isso significa que um Point2D TypedDict pode ter qualquer uma de suas chaves omitidas. Espera-se que um verificador de tipos apenas permita os literais False ou True como valores do argumento total. True é o padrão, e todos os itens definidos no corpo da classe tornam-se obrigatórios.

As chaves individuais de um TypedDict com total=False podem ser marcadas conforme necessário usando Required:

class Point2D(TypedDict, total=False):
    x: Required[int]
    y: Required[int]
    label: str

# Alternative syntax
Point2D = TypedDict('Point2D', {
    'x': Required[int],
    'y': Required[int],
    'label': str
}, total=False)

É possível que um tipo TypedDict herde de um ou mais tipos TypedDict usando a sintaxe baseada em classes. Modo de usar:

class Point3D(Point2D):
    z: int

Point3D tem três itens: x, y e z. Equivale a esta definição:

class Point3D(TypedDict):
    x: int
    y: int
    z: int

Um TypedDict não pode herdar de uma classe não TypedDict, exceto Generic. Por exemplo:

class X(TypedDict):
    x: int

class Y(TypedDict):
    y: int

class Z(object): pass  # A non-TypedDict class

class XY(X, Y): pass  # OK

class XZ(X, Z): pass  # raises TypeError

A TypedDict can be generic:

T = TypeVar("T")

class Group(TypedDict, Generic[T]):
    key: T
    group: list[T]

Um TypedDict pode ser introspeccionado por meio de dicionários de anotações (consulte Boas práticas para anotações para obter mais informações sobre as melhores práticas de anotações), __total__, __required_keys__ e __optional_keys__.

__total__

Point2D.__total__ fornece o valor do argumento total. Exemplo:

>>> from typing import TypedDict
>>> class Point2D(TypedDict): pass
>>> Point2D.__total__
True
>>> class Point2D(TypedDict, total=False): pass
>>> Point2D.__total__
False
>>> class Point3D(Point2D): pass
>>> Point3D.__total__
True

This attribute reflects only the value of the total argument to the current TypedDict class, not whether the class is semantically total. For example, a TypedDict with __total__ set to True may have keys marked with NotRequired, or it may inherit from another TypedDict with total=False. Therefore, it is generally better to use __required_keys__ and __optional_keys__ for introspection.

__required_keys__

Novo na versão 3.9.

__optional_keys__

Point2D.__required_keys__ e Point2D.__optional_keys__ retornam objetos frozenset contendo chaves obrigatórias e opcionais, respectivamente.

As chaves marcadas com Required sempre aparecerão em __required_keys__ e as chaves marcadas com NotRequired sempre aparecerão em __optional_keys__.

Para manter a retrocompatibilidade com Python 3.10 e versões anteriores, também é possível usar herança para declarar chaves obrigatórias e opcionais no mesmo TypedDict. Isso é feito declarando um TypedDict com um valor para o argumento total e então herdando-a em outro TypedDict usando um valor total diferente:

>>> class Point2D(TypedDict, total=False):
...     x: int
...     y: int
...
>>> class Point3D(Point2D):
...     z: int
...
>>> Point3D.__required_keys__ == frozenset({'z'})
True
>>> Point3D.__optional_keys__ == frozenset({'x', 'y'})
True

Novo na versão 3.9.

Nota

Se from __future__ import annotations for usado ou se anotações forem fornecidas como strings, as anotações não serão avaliadas quando o TypedDict for definido. Portanto, a introspecção em tempo de execução da qual __required_keys__ e __optional_keys__ dependem pode não funcionar corretamente, e os valores dos atributos podem estar incorretos.

Consulte PEP 589 para obter mais exemplos e regras detalhadas sobre o uso de TypedDict.

Novo na versão 3.8.

Alterado na versão 3.11: Adicionado suporte para marcar chaves individuais como Required ou NotRequired. Consulte PEP 655.

Alterado na versão 3.11: Adicionado suporte para TypedDicts genéricos.

Protocolos

Os protocolos a seguir são fornecidos pelo módulo typing. Todos são decorados com @runtime_checkable.

class typing.SupportsAbs

Um ABC com um método abstrato __abs__ que é covariante em seu tipo de retorno.

class typing.SupportsBytes

Um ABC com um método abstrato __bytes__.

class typing.SupportsComplex

Um ABC com um método abstrato __complex__.

class typing.SupportsFloat

Um ABC com um método abstrato __float__.

class typing.SupportsIndex

Um ABC com um método abstrato __index__.

Novo na versão 3.8.

class typing.SupportsInt

Um ABC com um método abstrato __int__.

class typing.SupportsRound

Uma ABC com um método abstrato __round__ que é covariante em seu tipo de retorno.

ABCs para trabalhar com E/S

class typing.IO
class typing.TextIO
class typing.BinaryIO

O tipo genérico IO[AnyStr] e suas subclasses TextIO(IO[str]) e BinaryIO(IO[bytes]) representam os tipos de fluxos de E/S, como os retornados por open().

Funções e decoradores

typing.cast(typ, val)

Define um valor para um tipo.

Isso retorna o valor inalterado. Para o verificador de tipos, isso indica que o valor de retorno tem o tipo designado, mas em tempo de execução não verificamos nada intencionalmente (queremos que isso seja o mais rápido possível).

typing.assert_type(val, typ, /)

Pede para um verificador de tipo estático confirmar se val tem tipo inferido typ.

Essa função faz nada em tempo de execução: ela retorna o primeiro argumento inalterado, sem verificações ou efeitos colaterais, independentemente do tipo real do argumento.

Quando um verificador de tipo estático encontra uma chamada para assert_type(), ele emite um erro se o valor não for do tipo especificado:

def greet(name: str) -> None:
    assert_type(name, str)  # OK, inferred type of `name` is `str`
    assert_type(name, int)  # type checker error

Esse função é útil para garantir que o verificador de tipos entende um script conforme as intenções do desenvolvedor:

def complex_function(arg: object):
    # Do some complex type-narrowing logic,
    # after which we hope the inferred type will be `int`
    ...
    # Test whether the type checker correctly understands our function
    assert_type(arg, int)

Novo na versão 3.11.

typing.assert_never(arg, /)

Pede ao verificador de tipo estático para confirmar se uma linha de código é inalcançável.

Exemplo:

def int_or_str(arg: int | str) -> None:
    match arg:
        case int():
            print("It's an int")
        case str():
            print("It's a str")
        case _ as unreachable:
            assert_never(unreachable)

Aqui, as anotações permitem que o verificador de tipos deduza que o último caso nunca será executado, pois arg é um int ou uma str, e ambas as opções são cobertas por casos anteriores.

Se um verificador de tipos descobrir que uma chamada para assert_never() é alcançável, ele emitirá um erro. por exemplo, se o anotação de tipo para arg fosse int | str | float, o verificador de tipos emitiria um erro indicando que unreachable é do tipo float. Para que uma chamada para assert_never passe verificação de tipos, o tipo inferido do argumento passado deve ser o tipo inferior, Never, e nada mais.

Em tempo de execução, essa função levanta uma exceção quando chamada.

Ver também

Unreachable Code and Exhaustiveness Checking has more information about exhaustiveness checking with static typing.

Novo na versão 3.11.

typing.reveal_type(obj, /)

Pede para um verificador de tipo estático revelar o tipo inferido de uma expressão.

Quando um verificador de tipo estático encontra uma chamada para essa função, ele emite um diagnóstico com o tipo inferido do argumento. Por exemplo:

x: int = 1
reveal_type(x)  # Revealed type is "builtins.int"

Isso pode ser útil quando você deseja depurar como o verificador de tipos lida com um determinado trecho de código.

Em tempo de execução, esta função envia o tipo de seu argumento para sys.stderr e retorna o argumento inalterado (permitindo que a chamada seja usada em uma expressão):

x = reveal_type(1)  # prints "Runtime type is int"
print(x)  # prints "1"

Observe que o tipo em tempo de execução pode ser diferente (mais ou menos específico) do tipo inferido estaticamente por um verificador de tipos.

A maioria dos verificadores de tipos dá suporte a reveal_type() em qualquer lugar, mesmo que o nome não seja importado de typing. Porém, importar o nome de typing permite que o código seja executado sem erros em tempo de execução e comunica a intenção com mais clareza.

Novo na versão 3.11.

@typing.dataclass_transform(*, eq_default=True, order_default=False, kw_only_default=False, field_specifiers=(), **kwargs)

Um decorador que marca um objeto como tendo comportamento similar a uma dataclass.

dataclass_transform pode ser usado para decorar uma classe, metaclasse, ou função decoradora. A presença de @dataclass_transform() informa a um verificador de tipo estático que o objeto decorado executa “mágica” em tempo de execução que transforma uma classe de maneira semelhante a @dataclasses.dataclass.

Exemplo de uso com a função decoradora:

T = TypeVar("T")

@dataclass_transform()
def create_model(cls: type[T]) -> type[T]:
    ...
    return cls

@create_model
class CustomerModel:
    id: int
    name: str

Em uma classe base:

@dataclass_transform()
class ModelBase: ...

class CustomerModel(ModelBase):
    id: int
    name: str

Em uma metaclasse:

@dataclass_transform()
class ModelMeta(type): ...

class ModelBase(metaclass=ModelMeta): ...

class CustomerModel(ModelBase):
    id: int
    name: str

As classes CustomerModel definidas acima serão tratadas pelos verificadores de tipos semelhantemente às classes criadas com @dataclasses.dataclass. Por exemplo, os verificadores de tipo presumirão que essas classes têm métodos __init__ que aceitam id e name.

A classe, metaclasse, ou função decorada pode aceitar os seguintes argumentos booleanos tal que verificadores de tipo presumirão ter o mesmo efeito que teriam no decorador @dataclasses.dataclass: init, eq, order, unsafe_hash, frozen, match_args, kw_only, e slots. É necessário que o valor desses argumentos (True ou False) seja avaliado estaticamente.

Os argumentos do decorador dataclass_transform podem ser usados para personalizar os comportamentos padrão da classe, metaclasse, ou função decorada:

Parâmetros:

  • eq_default (bool) – Indica se o parâmetro eq é presumido como True ou False se for omitido pelo chamador. O padrão é True.

  • order_default (bool) – Indica se o parâmetro order é presumido como True ou False se for omitido pelo chamador. O padrão é False.

  • kw_only_default (bool) – Indica se o parâmetro kw_only é presumido como True ou False se for omitido pelo chamador. O padrão é False.

  • field_specifiers (tuple[Callable[..., Any], ...]) – Especifica uma lista estática de classes ou funções compatíveis que descrevem campos, semelhante a dataclasses.field(). O valor padrão é ().

  • **kwargs (Any) – Outros argumentos nomeados arbitrários são aceitos para permitir possíveis futuras extensões.

Verificadores de tipo reconhecem os seguintes parâmetros opcionais em especificadores de campos:

Parâmetros reconhecidos para especificadores de campos

Nome do parâmetro

Descrição

init

Indica se o campo deve ser incluído no método __init__ sintetizado. Se não for especificado, o valor padrão de init é True.

default

Fornece o valor padrão do campo.

default_factory

Fornece uma função de retorno de tempo de execução que retorna o valor padrão do campo. Se nem default nem default_factory forem especificados, o campo é presumido como sem valor padrão e deverá receber um valor quando a classe for instanciada.

factory

Um apelido para o parâmetro default_factory em especificadores de campos.

kw_only

Indica se o campo deve ser marcado como somente-nomeado. Se verdadeiro, o campo será somente-nomeado. Se falso, não será somente-nomeado. Se não for especificado, será usado o valor do parâmetro kw_only do objeto decorado com dataclass_transform ou, se este não for especificado, será usado o valor de kw_only_default no dataclass_transform.

alias

Fornece um nome alternativo para o campo. Esse nome alternativo é usado no método __init__ sintetizado.

Em tempo de execução, esse decorador registra seu argumento no atributo __dataclass_transform__ no objeto decorado. Ele não tem nenhum outro efeito em tempo de execução.

Veja PEP 681 para mais detalhes.

Novo na versão 3.11.

@typing.overload

Decorador para criar funções e métodos sobrecarregados.

O decorador @overload permite descrever funções e métodos com suporte a várias combinações de tipos de argumento. Uma sequência de definições decoradas com @overload deve preceder uma única definição não decorada por @overload (para a mesma função/método).

Definições decoradas com @overload são usadas somente para benefício do verificador de tipos, já que serão sobrescritas por definições sem decoração de @overload. Enquanto isso, definições sem decoração de @overload serão usadas em tempo de execução, mas devem ser ignoradas pelo verificador de tipos. Em tempo de execução, chamar uma função decorada por @overload diretamente levantará NotImplementedError.

Um exemplo de sobrecarga que fornece um tipo mais preciso do que o tipo expresso usando uma união ou um tipo variável:

@overload
def process(response: None) -> None:
    ...
@overload
def process(response: int) -> tuple[int, str]:
    ...
@overload
def process(response: bytes) -> str:
    ...
def process(response):
    ...  # actual implementation goes here

Consulte PEP 484 para mais detalhes e uma comparação com outras semânticas de tipagem.

Alterado na versão 3.11: Funções sobrecarregadas agora podem ser introspeccionadas em tempo de execução usando get_overloads().

typing.get_overloads(func)

Retorna uma sequência de @overload -definições decoradas para func.

func é o objeto função para a implementação da função sobrecarregada. Por exemplo, dada a definição de process na documentação de @sobrecarga , get_overloads(process) retornará uma sequência de três objetos função para as três sobrecargas definidas. Se for chamada em uma função sem sobrecargas, get_overloads() retornará uma sequência vazia.

A função get_overloads() pode ser usada em tempo de execução para introspecção de uma função sobrecarregada.

Novo na versão 3.11.

typing.clear_overloads()

Apaga todas as sobrecargas registradas no registro interno.

Isso pode ser usado para recuperar a memória usada pelo registro.

Novo na versão 3.11.

@typing.final

Um decorador para indicar métodos e classes finais.

Decorar um método com @final indica a um verificador de tipos que o método não pode ser substituído em uma subclasse. Decorar uma classe com @final indica que ela não pode ser herdada.

Por exemplo:

class Base:
    @final
    def done(self) -> None:
        ...
class Sub(Base):
    def done(self) -> None:  # Error reported by type checker
        ...

@final
class Leaf:
    ...
class Other(Leaf):  # Error reported by type checker
    ...

Não há verificação em tempo de execução dessas propriedades. Veja PEP 591 para mais detalhes.

Novo na versão 3.8.

Alterado na versão 3.11: O decorador tentará definir um atributo __final__ como True no objeto decorado. Assim, uma verificação como if getattr(obj, "__final__", False) pode ser usada em tempo de execução para determinar se um objeto obj foi marcado como final. Se o objeto decorado dá suporte a definição de atributos, o decorador retorna o objeto inalterado sem levantar uma exceção.

@typing.no_type_check

Decorador para indicar que anotações não são dicas de tipo.

Isso funciona como decorator de uma classe ou função. Com uma classe, ele se aplica recursivamente a todos os métodos e classes definidos nessa classe (mas não a métodos definidos em suas superclasses ou subclasses). Os verificadores de tipos ignorarão todas as anotações em uma função ou classe com este decorador.

@no_type_check modifica o objeto decorado internamente.

@typing.no_type_check_decorator

Decorador para dar a outro decorador o efeito no_type_check().

Isso envolve o decorador com algo que envolve a função decorada em no_type_check().

@typing.type_check_only

Decorador para marcar uma classe ou função como indisponível em tempo de execução.

This decorator is itself not available at runtime. It is mainly intended to mark classes that are defined in type stub files if an implementation returns an instance of a private class:

@type_check_only
class Response:  # private or not available at runtime
    code: int
    def get_header(self, name: str) -> str: ...

def fetch_response() -> Response: ...

Observe que retornar instâncias de classes privadas não é recomendado. Normalmente, é preferível tornar essas classes públicas.

Introspection helpers

typing.get_type_hints(obj, globalns=None, localns=None, include_extras=False)

Retorna um dicionário contendo dicas de tipo para uma função, método, módulo ou objeto classe.

This is often the same as obj.__annotations__. In addition, forward references encoded as string literals are handled by evaluating them in globals and locals namespaces. For a class C, return a dictionary constructed by merging all the __annotations__ along C.__mro__ in reverse order.

The function recursively replaces all Annotated[T, ...] with T, unless include_extras is set to True (see Annotated for more information). For example:

class Student(NamedTuple):
    name: Annotated[str, 'some marker']

assert get_type_hints(Student) == {'name': str}
assert get_type_hints(Student, include_extras=False) == {'name': str}
assert get_type_hints(Student, include_extras=True) == {
    'name': Annotated[str, 'some marker']
}

Nota

get_type_hints() does not work with imported type aliases that include forward references. Enabling postponed evaluation of annotations (PEP 563) may remove the need for most forward references.

Alterado na versão 3.9: Adiciona o parâmetro include_extras como parte da PEP 593. Consulte a documentação em Annotated para obter mais informações.

Alterado na versão 3.11: Anteriormente, Optional[t] era adicionado a anotações de funções e métodos se um valor padrão igual a None fosse definido. Agora, a anotação é retornada inalterada.

typing.get_origin(tp)

Obtenha o versão sem subscrição de um tipo: para um objeto cujo tipo tem a forma X[Y, Z, ...], retorna X .

Se X for um apelido do módulo typing para uma classe embutida ou classe de collections, ele será normalizado para a classe original. Se X for uma instância de ParamSpecArgs ou ParamSpecKwargs, retorna o ParamSpec subjacente. Retorna None para objetos incompatíveis.

Exemplos:

assert get_origin(str) is None
assert get_origin(Dict[str, int]) is dict
assert get_origin(Union[int, str]) is Union
P = ParamSpec('P')
assert get_origin(P.args) is P
assert get_origin(P.kwargs) is P

Novo na versão 3.8.

typing.get_args(tp)

Obtenha os argumentos de tipos com todas as substituições realizadas: para um objeto cujo tipo tem a forma X[Y, Z, ...], retorna (Y, Z, ...) .

Se X for uma união ou um Literal, e estiver contido em outro tipo genérico, a ordem de (Y, Z, ...) poderá ser diferente da ordem dos argumentos originais [Y, Z, ...] devido ao armazenamento dos tipos em cache. Retorna () para objetos sem suporte.

Exemplos:

assert get_args(int) == ()
assert get_args(Dict[int, str]) == (int, str)
assert get_args(Union[int, str]) == (int, str)

Novo na versão 3.8.

typing.is_typeddict(tp)

Verifica se um tipo é um TypedDict.

Por exemplo:

class Film(TypedDict):
    title: str
    year: int

assert is_typeddict(Film)
assert not is_typeddict(list | str)

# TypedDict is a factory for creating typed dicts,
# not a typed dict itself
assert not is_typeddict(TypedDict)

Novo na versão 3.10.

class typing.ForwardRef

Class used for internal typing representation of string forward references.

Por exemplo, o tipo List["SomeClass"] é implicitamente transformado em List[ForwardRef("SomeClass")]. ForwardRef não deve ser instanciado por um usuário, mas pode ser usado por ferramentas de introspecção.

Nota

Tipos genéricos da PEP 585 como list["SomeClass"] não serão transformados implicitamente em list[ForwardRef("SomeClass")] e, portanto, não serão resolvidos automaticamente para list[SomeClass].

Novo na versão 3.7.4.

Constante

typing.TYPE_CHECKING

Uma constante especial presumida ser True por verificadores de tipo estático de terceiros. É False em tempo de execução.

Uso:

if TYPE_CHECKING:
    import expensive_mod

def fun(arg: 'expensive_mod.SomeType') -> None:
    local_var: expensive_mod.AnotherType = other_fun()

A primeira anotação de tipo deve ser colocada entre aspas, tornando-a uma “referência ao futuro”, para esconder do interpretador a referência ao módulo expensive_mod. As anotações de tipos em variáveis locais não são avaliadas, então a segunda anotação não precisa ser colocada entre aspas.

Nota

Se from __future__ import annotations for usado, anotações não serão avaliadas no momento de definição de funções. Em vez disso, elas são armazenadas como string em __annotations__. Isso torna desnecessário o uso de aspas em anotações (consulte PEP 563).

Novo na versão 3.5.2.

Apelidos descontinuados

Este módulo define vários apelidos descontinuados de classes pré-existentes da biblioteca padrão. Originalmente, elas eram incluídas no módulo typing para permitir a parametrização dessas classes genéricas usand []. Porém, os apelidos se tornaram redundantes no Python 3.9, quando as classes pré-existentes correspondentes passaram a dar suporte a [] (consulte a PEP 585).

Os tipos redundantes estão descontinuados desde Python 3.9. No entanto, enquanto os apelidos podem ser removidos em algum momento, essa remoção desses apelidos não está planejada. Assim, nenhum aviso de descontinuação será enviado pelo interpretador para esses apelidos.

Se em algum momento decidirem remover esses apelidos descontinuados, o interpretador emitirá um aviso de descontinuação por, no mínimo, duas versões de lançamento antes da remoção. Os apelidos são garantidos a permanecerem no módulo typing sem avisos de descontinuação até, no mínimo, Python 3.14.

Verificadores de tipos são encorajados a sinalizar o uso de tipos descontinuados se o programa que estão verificando respeita uma versão mínima de Python 3.9 ou mais nova.

Apelidos de tipos embutidos

class typing.Dict(dict, MutableMapping[KT, VT])

Apelido descontinuado de dict.

Note that to annotate arguments, it is preferred to use an abstract collection type such as Mapping rather than to use dict or typing.Dict.

This type can be used as follows:

def count_words(text: str) -> Dict[str, int]:
    ...

Obsoleto desde a versão 3.9: builtins.dict agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.List(list, MutableSequence[T])

Apelido descontinuado de list.

Note that to annotate arguments, it is preferred to use an abstract collection type such as Sequence or Iterable rather than to use list or typing.List.

This type may be used as follows:

T = TypeVar('T', int, float)

def vec2(x: T, y: T) -> List[T]:
    return [x, y]

def keep_positives(vector: Sequence[T]) -> List[T]:
    return [item for item in vector if item > 0]

Obsoleto desde a versão 3.9: builtins.list agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.Set(set, MutableSet[T])

Apelido descontinuado de builtins.set.

Note that to annotate arguments, it is preferred to use an abstract collection type such as AbstractSet rather than to use set or typing.Set.

Obsoleto desde a versão 3.9: builtins.set agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.FrozenSet(frozenset, AbstractSet[T_co])

Apelido descontinuado de builtins.frozenset.

Obsoleto desde a versão 3.9: builtins.frozenset agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

typing.Tuple

Apelido descontinuado para tuple.

tuple e Tuple são casos especiais no sistema de tipos; consulte Anotando tuplas para obter mais detalhes.

Obsoleto desde a versão 3.9: builtins.tuple agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.Type(Generic[CT_co])

Apelido descontinuado de type.

Consulte O tipo de objetos de classe para obter detalhes sobre como usar type ou typing.Type em anotações de tipos.

Novo na versão 3.5.2.

Obsoleto desde a versão 3.9: builtins.type agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

Apelidos para tipos em collections

class typing.DefaultDict(collections.defaultdict, MutableMapping[KT, VT])

Apelido descontinuado de collections.defaultdict.

Novo na versão 3.5.2.

Obsoleto desde a versão 3.9: collections.defaultdict agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.OrderedDict(collections.OrderedDict, MutableMapping[KT, VT])

Apelido descontinuado de collections.OrderedDict.

Novo na versão 3.7.2.

Obsoleto desde a versão 3.9: collections.OrderedDict agora oferece suporte a subscrição ([]). consulte PEP 585 e Tipo Generic Alias.

class typing.ChainMap(collections.ChainMap, MutableMapping[KT, VT])

Apelido descontinuado de collections.ChainMap.

Novo na versão 3.6.1.

Obsoleto desde a versão 3.9: collections.ChainMap agora oferece suporte a subscrição ([]). consulte PEP 585 e Tipo Generic Alias.

class typing.Counter(collections.Counter, Dict[T, int])

Apelido descontinuado de collections.Counter.

Novo na versão 3.6.1.

Obsoleto desde a versão 3.9: collections.Counter agora oferece suporte a subscrição ([]). consulte PEP 585 e Tipo Generic Alias.

class typing.Deque(deque, MutableSequence[T])

Apelido descontinuado de collections.deque.

Novo na versão 3.6.1.

Obsoleto desde a versão 3.9: collections.deque agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

Apelidos de outros tipos concretos

class typing.Pattern
class typing.Match

Apelidos descontinuados correspondem aos tipos de retorno de re.compile() e re.match().

Esses tipos (e as funções correspondentes) são genéricas sobre AnyStr. Pattern pode ser especializado como Pattern[str] ou Pattern[bytes]; Match pode ser especializado como Match[str] ou Match[bytes].

Descontinuado desde a versão 3.8, será removido na versão 3.13: The typing.re namespace is deprecated and will be removed. These types should be directly imported from typing instead.

Obsoleto desde a versão 3.9: Classes Pattern e Match de re agora suporte []. Consulte PEP 585 e Tipo Generic Alias.

class typing.Text

Apelido descontinuado de str.

Text is provided to supply a forward compatible path for Python 2 code: in Python 2, Text is an alias for unicode.

Use Text para indicar que um valor deve conter uma string unicode de forma compatível com Python 2 e Python 3:

def add_unicode_checkmark(text: Text) -> Text:
    return text + u' \u2713'

Novo na versão 3.5.2.

Obsoleto desde a versão 3.11: Python 2 deixou de receber suporte, e a maioria dos verificadores de tipos também não oferece suporte à verificação de tipos de código de Python 2. A remoção do apelido não está planejada no momento, mas os usuários são incentivados a usar str em vez de Text.

Apelidos de contêineres ABC em collections.abc.

class typing.AbstractSet(Collection[T_co])

Apelido descontinuado de collections.abc.Set.

Obsoleto desde a versão 3.9: collections.abc.Set agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.ByteString(Sequence[int])

Este tipo representa os tipos bytes, bytearray e memoryview de sequências de bytes.

Descontinuado desde a versão 3.9, será removido na versão 3.14: Prefer typing_extensions.Buffer, or a union like bytes | bytearray | memoryview.

class typing.Collection(Sized, Iterable[T_co], Container[T_co])

Apelido descontinuado de collections.abc.Collection.

Novo na versão 3.6.

Obsoleto desde a versão 3.9: collections.abc.Collection agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.Container(Generic[T_co])

Apelido descontinuado de collections.abc.Container.

Obsoleto desde a versão 3.9: collections.abc.Container agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.ItemsView(MappingView, AbstractSet[tuple[KT_co, VT_co]])

Apelido descontinuado de collections.abc.ItemsView.

Obsoleto desde a versão 3.9: collections.abc.ItemsView agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.KeysView(MappingView, AbstractSet[KT_co])

Apelido descontinuado de collections.abc.KeysView.

Obsoleto desde a versão 3.9: collections.abc.KeysView agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.Mapping(Collection[KT], Generic[KT, VT_co])

Apelido descontinuado de collections.abc.Mapping.

This type can be used as follows:

def get_position_in_index(word_list: Mapping[str, int], word: str) -> int:
    return word_list[word]

Obsoleto desde a versão 3.9: collections.abc.Mapping agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.MappingView(Sized)

Apelido descontinuado de collections.abc.MappingView.

Obsoleto desde a versão 3.9: collections.abc.MappingView agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.MutableMapping(Mapping[KT, VT])

Apelido descontinuado de collections.abc.MutableMapping.

Obsoleto desde a versão 3.9: collections.abc.MutableMapping agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.MutableSequence(Sequence[T])

Apelido descontinuado de collections.abc.MutableSequence.

Obsoleto desde a versão 3.9: collections.abc.MutableSequence agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.MutableSet(AbstractSet[T])

Apelido descontinuado de collections.abc.MutableSet.

Obsoleto desde a versão 3.9: collections.abc.MutableSet agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.Sequence(Reversible[T_co], Collection[T_co])

Apelido descontinuado de collections.abc.Sequence.

Obsoleto desde a versão 3.9: collections.abc.Sequence agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.ValuesView(MappingView, Collection[_VT_co])

Apelido descontinuado de collections.abc.ValuesView.

Obsoleto desde a versão 3.9: collections.abc.ValuesView agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

Apelidos para ABCs assíncronas em collections.abc

class typing.Coroutine(Awaitable[ReturnType], Generic[YieldType, SendType, ReturnType])

Apelido descontinuado de collections.abc.Coroutine.

The variance and order of type variables correspond to those of Generator, for example:

from collections.abc import Coroutine
c: Coroutine[list[str], str, int]  # Some coroutine defined elsewhere
x = c.send('hi')                   # Inferred type of 'x' is list[str]
async def bar() -> None:
    y = await c                    # Inferred type of 'y' is int

Novo na versão 3.5.3.

Obsoleto desde a versão 3.9: collections.abc.Coroutine agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.AsyncGenerator(AsyncIterator[YieldType], Generic[YieldType, SendType])

Apelido descontinuado de collections.abc.AsyncGenerator.

An async generator can be annotated by the generic type AsyncGenerator[YieldType, SendType]. For example:

async def echo_round() -> AsyncGenerator[int, float]:
    sent = yield 0
    while sent >= 0.0:
        rounded = await round(sent)
        sent = yield rounded

Unlike normal generators, async generators cannot return a value, so there is no ReturnType type parameter. As with Generator, the SendType behaves contravariantly.

If your generator will only yield values, set the SendType to None:

async def infinite_stream(start: int) -> AsyncGenerator[int, None]:
    while True:
        yield start
        start = await increment(start)

Alternatively, annotate your generator as having a return type of either AsyncIterable[YieldType] or AsyncIterator[YieldType]:

async def infinite_stream(start: int) -> AsyncIterator[int]:
    while True:
        yield start
        start = await increment(start)

Novo na versão 3.6.1.

Obsoleto desde a versão 3.9: collections.abc.AsyncGenerator agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.AsyncIterable(Generic[T_co])

Apelido descontinuado de collections.abc.AsyncIterable.

Novo na versão 3.5.2.

Obsoleto desde a versão 3.9: collections.abc.AsyncIterable agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.AsyncIterator(AsyncIterable[T_co])

Apelido descontinuado de collections.abc.AsyncIterator.

Novo na versão 3.5.2.

Obsoleto desde a versão 3.9: collections.abc.AsyncIterator agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.Awaitable(Generic[T_co])

Apelido descontinuado de collections.abc.Awaitable.

Novo na versão 3.5.2.

Obsoleto desde a versão 3.9: collections.abc.Awaitable agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

Apelidos para outros ABCs em collections.abc.

class typing.Iterable(Generic[T_co])

Apelido descontinuado de collections.abc.Iterable.

Obsoleto desde a versão 3.9: collections.abc.Iterable agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.Iterator(Iterable[T_co])

Apelido descontinuado de collections.abc.Iterator.

Obsoleto desde a versão 3.9: collections.abc.Iterator agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

typing.Callable

Apelido descontinuado de collections.abc.Callable.

Veja Anotações de objetos chamáveis para detalhes sobre como usar collections.abc.Callable e typing.Callable em anotações de tipo.

Obsoleto desde a versão 3.9: collections.abc.Callable agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

Alterado na versão 3.10: Callable agora oferece suporte a ParamSpec e Concatenate. Veja PEP 612 para mais detalhes.

class typing.Generator(Iterator[YieldType], Generic[YieldType, SendType, ReturnType])

Apelido descontinuado de collections.abc.Generator.

A generator can be annotated by the generic type Generator[YieldType, SendType, ReturnType]. For example:

def echo_round() -> Generator[int, float, str]:
    sent = yield 0
    while sent >= 0:
        sent = yield round(sent)
    return 'Done'

Note that unlike many other generics in the typing module, the SendType of Generator behaves contravariantly, not covariantly or invariantly.

If your generator will only yield values, set the SendType and ReturnType to None:

def infinite_stream(start: int) -> Generator[int, None, None]:
    while True:
        yield start
        start += 1

Alternatively, annotate your generator as having a return type of either Iterable[YieldType] or Iterator[YieldType]:

def infinite_stream(start: int) -> Iterator[int]:
    while True:
        yield start
        start += 1

Obsoleto desde a versão 3.9: collections.abc.Generator agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.Hashable

Alias to collections.abc.Hashable.

class typing.Reversible(Iterable[T_co])

Apelido descontinuado de collections.abc.Reversible.

Obsoleto desde a versão 3.9: collections.abc.Reversible agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.Sized

Alias to collections.abc.Sized.

Apelidos de ABCs da contextlib

class typing.ContextManager(Generic[T_co])

Apelido descontinuado de contextlib.AbstractContextManager.

Novo na versão 3.5.4.

Obsoleto desde a versão 3.9: contextlib.AbstractContextManager agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

class typing.AsyncContextManager(Generic[T_co])

Apelido descontinuado de contextlib.AbstractAsyncContextManager.

Novo na versão 3.6.2.

Obsoleto desde a versão 3.9: contextlib.AbstractAsyncContextManager agora oferece suporte a subscrição ([]). Consulte PEP 585 e Tipo Generic Alias.

Cronograma de descontinuação dos principais recursos

Alguns recursos em typing estão descontinuados e podem ser removidos em uma versão futura de Python. A tabela a seguir resume as principais descontinuações para sua conveniência. Ela está sujeita a alterações, e nem todas as descontinuações estão listadas.

Recurso

Descontinuado em

Remoção planejada

PEP/issue

typing.io and typing.re submodules

3.8

3.13

bpo-38291

versões typing de coleções-padrão

3.9

Undecided (see Apelidos descontinuados for more information)

PEP 585

typing.ByteString

3.9

3.14

gh-91896

typing.Text

3.11

Não definido

gh-92332