0Pricing
Python Academy · Aula

Executando mypy e corrigindo erros de tipos

Configure mypy, interprete erros e adicione tipos gradualmente a uma base de código.

Executando mypy e corrigindo erros de tipos é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

Instalando e executando o mypy

Instale o mypy com pip e execute-o em um arquivo ou pacote. Ele relata erros de tipo sem executar seu código.

# pip install mypy

# Check a single file:
# mypy script.py

# Check a package:
# mypy mypackage/

# Strict mode (recommended for new code):
# mypy --strict script.py

Seu primeiro erro do mypy

O mypy detecta tipos incompatíveis, valores de retorno ausentes e argumentos de função sem anotação.

# script.py
def add(a, b):   # mypy: Missing type annotation
    return a + b

result: int = add("hello", 1)  # str, not int

# mypy output:
# error: Returning Any from function declared to return "int"

Sinalizador --strict

--strict habilita muitas verificações adicionais: anotações ausentes, uso de Any, importações sem tipagem e assim por diante. Comece sem ele e adicione-o gradualmente.

# Most important strict flags individually:
# --disallow-untyped-defs
# --disallow-any-generics
# --warn-return-any
# --no-implicit-reexport

# Or all at once:
# mypy --strict mypackage/

Ignorando erros

Adicione # type: ignore ao final de uma linha para suprimir um erro específico. Use-o com moderação e inclua um comentário explicando o motivo.

import third_party  # type: ignore[import]  # no stub available

x: int = get_dynamic_value()  # type: ignore[assignment]

Configuração do mypy.ini / pyproject.toml

Armazene as configurações do mypy em mypy.ini ou pyproject.toml para não precisar passar sinalizadores a cada execução.

# mypy.ini
[mypy]
python_version = 3.11
strict = True
ignore_missing_imports = True

[mypy-third_party.*]
ignore_errors = True

Modo incremental

O mypy armazena os resultados em cache entre as execuções. Somente os arquivos alterados são verificados novamente, tornando rápidas as execuções seguintes.

# First run:
# mypy mypackage/   — full analysis, ~5 s

# Second run (nothing changed):
# mypy mypackage/   — Success: no issues in 0 source files (0.3 s)

Erro comum: tipos incompatíveis

O erro mais frequente: atribuir ou passar um valor do tipo errado.

# error: Incompatible types in assignment
# (expression has type "str", variable has type "int")

count: int = 0
count = "five"   # error

# Fix:
count = 5

Erro comum: incompatibilidade de tipo de argumento

Passar para uma função argumentos com o tipo errado.

def greet(name: str) -> str:
    return f"Hello, {name}"

# error: Argument 1 to "greet" has incompatible type "int"
greet(42)   # error

# Fix:
greet(str(42))

Erro comum: retorno inesperado de None

Uma função declarada para retornar um valor diferente de None tem um caminho de código que retorna None.

# error: Missing return statement
def find(items: list[int], target: int) -> int:
    for item in items:
        if item == target:
            return item
    # Missing: no return if not found!

# Fix:
def find2(items: list[int], target: int) -> int | None:
    for item in items:
        if item == target:
            return item
    return None

Restringindo tipos com isinstance

Use isinstance para restringir um tipo de união dentro de um ramo. O mypy entende isso e restringe o tipo.

def process(value: int | str) -> str:
    if isinstance(value, int):
        return str(value * 2)   # mypy knows value is int here
    return value.upper()         # mypy knows value is str here

Usando cast

typing.cast(Type, value) informa ao mypy para tratar um valor como um determinado tipo, sem efeito em tempo de execução. Use-o somente quando tiver certeza de que sabe mais que o mypy.

from typing import cast

def get_value() -> object:
    return 42

result = cast(int, get_value())   # mypy treats result as int
print(result + 1)   # 43

Verificação rápida

O que adicionar # type: ignore a uma linha faz?

Recapitulação

Execute mypy script.py para verificar os tipos. Corrija atribuições incompatíveis, incompatibilidades de argumentos e retornos ausentes. Use isinstance para restringir uniões, # type: ignore com moderação e configure o mypy em mypy.ini. Habilite --strict gradualmente.

Perguntas Frequentes

A aula “Executando mypy e corrigindo erros de tipos” é grátis?

Sim — o texto completo de “Executando mypy e corrigindo erros de tipos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “Executando mypy e corrigindo erros de tipos”?

Configure mypy, interprete erros e adicione tipos gradualmente a uma base de código. Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Executando mypy e corrigindo erros de tipos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Anotações básicas de tipos
  2. Tipos complexos: List, Dict, Optional, Union
  3. TypeVar, classes genéricas e Protocol
  4. Executando mypy e corrigindo erros de tipos
← Voltar para Python Academy