0Pricing
Python Academy · Aula

Anotações básicas de tipos

Anote variáveis, parâmetros de funções e tipos de retorno.

Anotações básicas de tipos é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 1 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.

O que são anotações de tipo?

Anotações de tipo são indicações que declaram o tipo esperado de variáveis, parâmetros e valores de retorno. Elas não são impostas em tempo de execução — são lidas por verificadores de tipos como mypy.

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

result: str = greet("Alice")
print(result)

Anotações de variáveis

Anote variáveis de módulo, de classe ou locais com dois-pontos seguidos do tipo.

count: int = 0
pi: float = 3.14159
name: str = "Python"
flag: bool = True

# Annotation without assignment (declaration only)
future_value: int

Anotações de parâmetros de função

Anote cada parâmetro na assinatura da função. Use -> type para anotar o tipo de retorno.

def add(a: int, b: int) -> int:
    return a + b

def repeat(text: str, times: int = 1) -> str:
    return text * times

def no_return() -> None:
    print("side effect only")

Tipos de coleções integrados (Python 3.9+)

A partir do Python 3.9, use diretamente os tipos integrados em minúsculas como genéricos: list[int], dict[str, int], tuple[int, ...].

def total(numbers: list[int]) -> int:
    return sum(numbers)

def config() -> dict[str, str]:
    return {"host": "localhost", "port": "8080"}

def coords() -> tuple[float, float]:
    return (1.0, 2.0)

Opcional e união

X | None (Python 3.10 ou posterior) ou Optional[X] significa que um valor pode ser X ou None. X | Y significa X ou Y.

from typing import Optional

def find(items: list[int], target: int) -> int | None:
    return next((x for x in items if x == target), None)

# Older style:
# def find(...) -> Optional[int]:

Tipos de união

int | str (Python 3.10 ou posterior) ou Union[int, str] anota um valor que pode ser de um entre vários tipos.

from typing import Union

def process(value: int | str) -> str:
    return str(value)

# Older style:
# def process(value: Union[int, str]) -> str:

Apelidos de tipo

Atribua uma expressão de tipo a um nome para criar um apelido reutilizável e melhorar a legibilidade.

from typing import TypeAlias

Vector: TypeAlias = list[float]
Matrix: TypeAlias = list[Vector]

def dot(a: Vector, b: Vector) -> float:
    return sum(x * y for x, y in zip(a, b))

Anotações de funções chamáveis

Use Callable[[arg_types], return_type] para anotar funções passadas como argumentos.

from typing import Callable

def apply(func: Callable[[int, int], int], x: int, y: int) -> int:
    return func(x, y)

result = apply(lambda a, b: a + b, 3, 4)
print(result)  # 7

Anotando *args e **kwargs

Anote *args com o tipo dos elementos, não com um tipo de tupla, e **kwargs com o tipo dos valores.

def log(*messages: str, level: str = "INFO") -> None:
    for msg in messages:
        print(f"[{level}] {msg}")

def configure(**options: int) -> None:
    for key, val in options.items():
        print(f"{key}: {val}")

from __future__ import annotations

Adicione esta importação no início do arquivo para ativar a avaliação adiada das anotações, permitindo referências adiantadas sem aspas.

from __future__ import annotations

class Node:
    def __init__(self, value: int, next: Node | None = None):
        self.value = value
        self.next = next   # forward ref to Node works here

Proteção TYPE_CHECKING

Importe tipos somente durante a verificação de tipos, e não em tempo de execução, para evitar importações circulares ou importações pesadas.

from __future__ import annotations
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from mymodule import HeavyClass

def process(obj: HeavyClass) -> None:
    ...   # HeavyClass not imported at runtime

Verificação rápida

Qual sintaxe de anotação indica que uma função não retorna nada?

Recapitulação

Anote variáveis com name: Type, parâmetros com param: Type e valores de retorno com -> Type. Use list[T], dict[K,V] (Python 3.9 ou posterior), X | None (3.10 ou posterior) e from __future__ import annotations para referências adiantadas.

Perguntas Frequentes

A aula “Anotações básicas de tipos” é grátis?

Sim — o texto completo de “Anotações básicas 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 “Anotações básicas de tipos”?

Anote variáveis, parâmetros de funções e tipos de retorno. 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 1 de 4.

Quanto tempo leva a aula “Anotações básicas 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