Python Academy · Aula

typing.NamedTuple

Adicione dicas de tipo a tuplas nomeadas

typing.NamedTuple é 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.

Uma alternativa tipada

A classe base typing.NamedTuple é uma forma moderna e baseada em classes de definir tuplas nomeadas. Ela adiciona anotações de tipo e se parece com uma classe comum, que a maioria dos editores e verificadores de tipos entende melhor do que a forma de fábrica.

Sintaxe baseada em classe

Crie uma subclasse de NamedTuple e declare cada campo com uma anotação de tipo. O resultado ainda é uma tupla de verdade.

from typing import NamedTuple

class Point(NamedTuple):
    x: int
    y: int

p = Point(1, 2)
print(p)

O mesmo comportamento de tupla

Tudo o que funcionava na versão de fábrica continua funcionando: acesso por nome, acesso por índice, desempacotamento e imutabilidade.

from typing import NamedTuple

class Point(NamedTuple):
    x: int
    y: int

p = Point(1, 2)
print(p.x, p[1])
x, y = p
print(x, y)

Valores padrão em linha

Forneça um valor padrão para um campo simplesmente atribuindo um valor no corpo da classe. Os campos com valores padrão devem vir depois dos campos sem valores padrão.

from typing import NamedTuple

class Point(NamedTuple):
    x: int
    y: int
    z: int = 0

print(Point(1, 2))
print(Point(1, 2, 9))

Adicionando métodos

Como isso é uma classe, você pode adicionar métodos de verdade. A fábrica collections.namedtuple não oferece isso de forma simples.

from typing import NamedTuple

class Point(NamedTuple):
    x: int
    y: int

    def distance_sq(self):
        return self.x ** 2 + self.y ** 2

print(Point(3, 4).distance_sq())

Propriedades também

Você também pode definir propriedades calculadas que derivam valores dos campos.

from typing import NamedTuple

class Rectangle(NamedTuple):
    width: int
    height: int

    @property
    def area(self):
        return self.width * self.height

print(Rectangle(3, 4).area)

Métodos auxiliares continuam disponíveis

Os conhecidos auxiliares de tupla continuam disponíveis: _replace(), _asdict() e _fields funcionam da mesma maneira.

from typing import NamedTuple

class Point(NamedTuple):
    x: int
    y: int

p = Point(1, 2)
print(p._asdict())
print(p._replace(x=9))

Anotações de tipo documentam a intenção

As anotações não são impostas durante a execução, mas documentam os tipos esperados e permitem que ferramentas de verificação de tipos detectem erros antes de você executar o programa.

from typing import NamedTuple

class Employee(NamedTuple):
    name: str
    salary: float
    active: bool = True

e = Employee('Alice', 5000.0)
print(e)

NamedTuple versus classe de dados

Escolhendo entre as duas:

NamedTuple: imutável, semelhante a uma tupla, oferece indexação e desempacotamento.
classe de dados: mutável por padrão (ou congelada), sem indexação e com mais opções de configuração.
Escolha NamedTuple quando o comportamento de tupla for importante; escolha uma classe de dados para registros mais completos.

Aninhamento e composição

As tuplas nomeadas podem ser compostas facilmente. Um campo pode ser outra tupla nomeada, formando dados estruturados e imutáveis.

from typing import NamedTuple

class Point(NamedTuple):
    x: int
    y: int

class Line(NamedTuple):
    start: Point
    end: Point

line = Line(Point(0, 0), Point(3, 4))
print(line.end.y)

Como tipos de retorno de funções

Anote uma função para retornar seu NamedTuple, para que os editores conheçam os tipos dos campos do resultado. A anotação documenta a estrutura do registro retornado.

from typing import NamedTuple

class Stats(NamedTuple):
    minimum: int
    maximum: int

def analyze(nums) -> Stats:
    return Stats(min(nums), max(nums))

r = analyze([5, 2, 8])
print(r.minimum, r.maximum)

Verificação rápida

Qual é uma vantagem de typing.NamedTuple em relação à fábrica collections.namedtuple?

Recapitulação

Você aprendeu a adicionar anotações de tipo a tuplas nomeadas.

Crie uma subclasse de typing.NamedTuple com campos anotados.
Defina valores padrão em linha; adicione métodos e propriedades.
Os auxiliares _replace, _asdict e _fields continuam funcionando.
Prefira essa forma à fábrica por sua legibilidade e pelo suporte das ferramentas.

Perguntas Frequentes

A aula “typing.NamedTuple” é grátis?

Sim — o texto completo de “typing.NamedTuple” é 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 “typing.NamedTuple”?

Adicione dicas de tipo a tuplas nomeadas 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 “typing.NamedTuple”?

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

← Voltar para Python Academy