- setembro 18, 2025

Tipagem estática em Python e módulo mypy

O Python é uma linguagem de tipagem dinâmica, ou seja, as variáveis podem mudar de tipo durante a execução do programa. No entanto, desde a versão 3.5, a linguagem ganhou suporte a type hints (anotações de tipo) através do módulo typing. Com essas anotações, podemos usar ferramentas como mypy para verificar o código estaticamente e encontrar erros antes de executar o programa.

Benefícios da Tipagem Estática

Detectar erros mais cedo (sem precisar rodar o código).
Melhorar a legibilidade e documentação do código.
Auxiliar IDEs e editores (autocompletar, linting, refatoração).

1. Tipos Primitivos

Os tipos mais comuns podem ser usados sem o módulo typing:


def boas_vindas(self) -> str:
    return "Seja bem vindo(a) ao estudo de tipagem estática em Python!"

def somar(self, num1: int, num2: int) -> int:
    return num1 + num2  

def multiplicar(self, num1: float, num2: float) -> float: 
    return num1 * num2

def checar_idade(self, idade: int) -> bool: 
    if idade >= 18:
    	return True
    else:
    	return False

2. Union e Optional

As variáveis podem assumir mais de um tipo. É necessário o módulo typing.


from typing import Union, Optional

def dividir(self, num1: float, num2: float) -> Union[float, str]:
    if num2 == 0:
    	return f"Divisão por zero!"
    else:    
    	return num1 / num2
       
 def digite_nome(self, nome: Optional[str] = None) -> str:
     return nome or "Sem nome!"

3. Tipos Compostos

O módulo typing também fornece os tipos List, Tuple e Dict.

List(Lista)


from typing import List

def media(self, notas: List[int]) -> float: 
    return sum(notas) / len(notas)

Tuple(Tupla)


from typing import Tuple

def idades(self) -> Tuple[int, int]:
    return (44, 77)

Dict(Dicionário)


from typing import Dict

def frutas(self) -> Dict[str, int]:
    return {"abacate": 10, "banana": 5}

4. Funções genéricas

Com TypeVar, você pode criar funções que funcionam para múltiplos tipos:


from typing import TypeVar

T = TypeVar("T")

def identidade(self, valor: T) -> T:
    return valor

5. O tipo Any

O tipo Any em Python significa que o valor pode ser qualquer coisa. Ele desativa a verificação de tipo do mypy para aquela variável ou parâmetro.


from typing import Any

def qualque_valor(self, valor: Any) -> Any:
    return valor

Módulo mypy

Mypy é um verificador de tipos estáticos para Python que ajuda a encontrar erros no seu código antes de ele ser executado, utilizando as Type Hints (dicas de tipo) que você adiciona ao seu programa.


# Instala mypy globalmente
 pip install mypy
 
# Verifica versão global
mypy --version

# Executa globalmente
mypy nomeDoArquivo.py

# Instala mypy no poetry 
poetry add mypy --dev

# Verifica versão
poetry mypy --version

# Executa no ambiente poetry
poetry run mypy nomeDoArquivo.py

# Executa em todos os arquivos do ambiente poetry
poetry run mypy .

Conclusão

Mesmo sendo uma linguagem de tipagem dinâmica, o Python ganhou poderosos recursos de tipagem estática opcional. Usar anotações de tipo junto com ferramentas como mypy pode aumentar a confiabilidade e a legibilidade do seu projeto. Se você trabalha em sistemas maiores ou em equipe, vale a pena adotar a tipagem estática como parte do seu fluxo de desenvolvimento. Muito obrigado e até a próxima.

Observação: existem outros tipo que serão abordados em postagens futuras.

Repositório de estudo sobre tipagem estática em Python: https://github.com/jcarlossc/python-static-typing-mypy

Pesquisar este blog

Informaticus77 - Python