Python Academy · Aula

Tipos complexos: List, Dict, Optional, Union

Use corretamente os tipos genéricos do módulo typing e Optional/Union.

Tipos complexos: List, Dict, Optional, Union é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 2 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.

Visão geral do módulo typing

Antes do Python 3.9, tipos genéricos como List, Dict e Tuple vinham de typing. A partir da versão 3.9, você pode usar diretamente os tipos integrados.

from typing import List, Dict, Tuple, Optional, Union

# Python 3.9+: use list[int], dict[str,int] directly
# Python 3.8-: use typing.List[int], typing.Dict[str,int]

Lista e sequência

Use list[T] para sequências mutáveis e Sequence[T] ao aceitar qualquer sequência ordenada (lista, tupla ou str).

from typing import Sequence

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

def first(items: Sequence[str]) -> str:
    return items[0]   # works with list, tuple, str

Dicionário e mapeamento

Use dict[K,V] para dicionários mutáveis e Mapping[K,V] para objetos somente leitura semelhantes a dicionários.

from typing import Mapping

def lookup(data: Mapping[str, int], key: str) -> int | None:
    return data.get(key)

result = lookup({"a": 1, "b": 2}, "a")
print(result)   # 1

Anotações de tuplas

Tamanho fixo: tuple[int, str, float]. Tamanho variável: tuple[int, ...].

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

def first_n(n: int) -> tuple[int, ...]:
    return tuple(range(n))

# Named tuple with types:
from typing import NamedTuple
class Point(NamedTuple):
    x: float
    y: float

Optional[T]

Optional[T] é uma forma abreviada de T | None. É sempre a escolha adequada quando um parâmetro pode estar ausente.

from typing import Optional

def find_user(user_id: int) -> Optional[dict[str, str]]:
    db: dict[int, dict[str, str]] = {
        1: {"name": "Alice"}
    }
    return db.get(user_id)

Tipos de união

Union[X, Y] ou X | Y (3.10 ou posterior) para valores que podem ser de um entre vários tipos.

from typing import Union

def stringify(value: Union[int, float, str]) -> str:
    return str(value)

# Python 3.10+:
def stringify2(value: int | float | str) -> str:
    return str(value)

Tipos literais

Literal["a","b","c"] restringe um valor a um conjunto específico de literais.

from typing import Literal

Mode = Literal["read", "write", "append"]

def open_file(path: str, mode: Mode) -> None:
    with open(path, mode):
        pass

open_file("data.txt", "read")    # ok
# open_file("data.txt", "exec")  # mypy error

TypedDict

TypedDict anota formatos de dicionário nos quais cada chave corresponde a um tipo específico.

from typing import TypedDict

class User(TypedDict):
    name: str
    age: int
    email: str | None

def greet(user: User) -> str:
    return f"Hello, {user['name']}"

alice: User = {"name": "Alice", "age": 30, "email": None}

Conjuntos e FrozenSet

Anote conjuntos com set[T] e conjuntos imutáveis com frozenset[T].

def unique(items: list[int]) -> set[int]:
    return set(items)

def allowed_methods() -> frozenset[str]:
    return frozenset({"GET", "POST", "DELETE"})

Iterável e iterador

Use Iterable[T] para qualquer objeto sobre o qual seja possível iterar; use Iterator[T] para objetos com __next__.

from typing import Iterable, Iterator

def evens(numbers: Iterable[int]) -> Iterator[int]:
    return (n for n in numbers if n % 2 == 0)

for n in evens([1, 2, 3, 4, 5]):
    print(n)   # 2 4

Any e NoReturn

Any desativa a verificação de tipos para um valor. NoReturn marca funções que nunca retornam, pois sempre geram uma exceção ou entram em um laço infinito.

from typing import Any, NoReturn

def accept_all(x: Any) -> None:
    print(x)

def crash(msg: str) -> NoReturn:
    raise RuntimeError(msg)   # never returns normally

Verificação rápida

O que significa Optional[str]?

Recapitulação

Use list[T], dict[K,V] e tuple[T,...] para coleções. Optional[T] = T | None. Use Union[X,Y] ou X|Y para vários tipos. Use Literal para valores específicos, TypedDict para formatos de dicionário tipados e Any para desativar a verificação.

Perguntas Frequentes

A aula “Tipos complexos: List, Dict, Optional, Union” é grátis?

Sim — o texto completo de “Tipos complexos: List, Dict, Optional, Union” é 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 “Tipos complexos: List, Dict, Optional, Union”?

Use corretamente os tipos genéricos do módulo typing e Optional/Union. 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 2 de 4.

Quanto tempo leva a aula “Tipos complexos: List, Dict, Optional, Union”?

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

Anotações básicas de tipos
Tipos complexos: List, Dict, Optional, Union
TypeVar, classes genéricas e Protocol
Executando mypy e corrigindo erros de tipos

← Voltar para Python Academy