Como Usar namedtuple no Python?
[
Escrevendo um código Pythonic e Limpo com Named Tuple
Python’s collections module fornece uma função de fábrica chamada namedtuple(), que é especialmente projetada para tornar seu código mais Pythonic quando você está trabalhando com tuplas. Com namedtuple(), você pode criar tipos de sequência imutáveis que permitem acessar seus valores usando nomes de campo descritivos e a notação de ponto em vez de índices numéricos obscuros.
Usando namedtuple para Escrever Código Pythonic
O primeiro passo para usar a namedtuple é importar o módulo collections:
from collections import namedtupleAgora você pode criar uma namedtuple usando a função namedtuple(). Ao criar uma namedtuple, você precisa especificar um nome para a classe que será criada e uma sequência de nomes de campo:
Person = namedtuple('Person', ['name', 'age'])Isso criará uma classe Person com os campos name e age. Você pode então criar uma instância dessa namedtuple passando argumentos para cada campo:
person = Person(name='Alice', age=30)Você pode acessar os valores dos campos usando a notação de ponto:
print(person.name) # Output: Aliceprint(person.age) # Output: 30Criando Classes Semelhantes a Tuplas com namedtuple()
Além de criar namedtuples com campos específicos, você também pode criar classes semelhantes a tuplas usando namedtuple() sem especificar os campos. Nesse caso, a namedtuple é criada como uma função que pode receber qualquer número de argumentos posicionais:
Point = namedtuple('Point', [])Agora você pode criar uma instância dessa namedtuple passando quaisquer valores como argumentos posicionais:
point = Point(10, 20)Você pode acessar os valores usando a notação de índice:
print(point[0]) # Output: 10print(point[1]) # Output: 20Essa sintaxe é semelhante à de uma tupla regular, mas com a vantagem de poder acessar os valores usando nomes de campo em vez de índices numéricos.
Explorando Recursos Adicionais das Classes Named Tuple
As classes named tuple têm alguns recursos adicionais que podem facilitar ainda mais o seu trabalho.
Criando Instâncias Named Tuple a partir de Iteráveis
Você pode criar uma instância de uma namedtuple passando um objeto iterável como argumento. Os valores do objeto iterável serão atribuídos aos campos da namedtuple na ordem em que aparecem:
values = [1, 2, 3]Point = namedtuple('Point', ['x', 'y', 'z'])point = Point._make(values)Agora, point será uma instância de Point com os valores [1, 2, 3] atribuídos aos campos x, y e z, respectivamente.
Convertendo Instâncias Named Tuple em Dicionários
Você pode converter uma instância de namedtuple em um dicionário usando o método ._asdict(). Isso retorna um dicionário em que as chaves são os nomes dos campos e os valores são os valores correspondentes:
person = Person(name='Alice', age=30)person_dict = person._asdict()O valor de person_dict será {'name': 'Alice', 'age': 30}.
Substituindo Campos em Instâncias Named Tuple Existente
Você também pode substituir os valores de um ou mais campos em uma instância de namedtuple existente. Para fazer isso, você precisa usar o método ._replace(), passando os valores atualizados:
person = Person(name='Alice', age=30)updated_person = person._replace(age=31)O valor de updated_person será Person(name='Alice', age=31).
Explorando Atributos Adicionais de Named Tuple
As instâncias de namedtuple têm alguns atributos adicionais úteis:
._fields: retorna uma tupla com os nomes dos campos danamedtuple.._as_tuple(): retorna uma tupla com os valores danamedtuple.._source: retorna o código-fonte danamedtuple.
Escrevendo Código Pythonic com Named Tuple
A principal vantagem do uso de namedtuple é que ela permite que você escreva um código mais Pythonic. Isso significa que seu código será mais legível, mais conciso e mais fácil de entender.
Usando Nomes de Campo em Vez de Índices
Em vez de acessar os valores de uma tupla usando índices numéricos, você pode usar nomes de campo para tornar seu código mais legível:
person = Person(name='Alice', age=30)
# Em vez de:print(person[0]) # Output: Alice
# Use:print(person.name) # Output: AliceRetornando Múltiplos Valores Nomeados de Funções
Com namedtuple, você pode retornar múltiplos valores nomeados de uma função, o que facilita o entendimento e o uso desses valores:
def get_person(): return Person(name='Alice', age=30)
person = get_person()print(person.name) # Output: Aliceprint(person.age) # Output: 30Reduzindo o Número de Argumentos para Funções
Quando você tem uma função que requer vários argumentos, o uso de uma namedtuple pode tornar seu código mais limpo, reduzindo a quantidade de argumentos necessários:
def process_person(person): # Faça algo com os valores de person pass
person = Person(name='Alice', age=30)process_person(person)Com uma namedtuple, você só precisa passar um argumento em vez de vários.
Lendo Dados Tabulares de Arquivos e Bancos de Dados
Ao trabalhar com dados tabulares, como arquivos CSV ou bancos de dados, você pode usar namedtuple para tornar seu código mais conciso e legível. Em vez de trabalhar com listas de listas ou dicionários, você pode representar cada linha de dados como uma instância de namedtuple, onde os nomes dos campos correspondem aos nomes das colunas:
import csv
# Lendo dados do arquivo CSVwith open('data.csv', 'r') as file: reader = csv.reader(file) headers = next(reader) DataRow = namedtuple('DataRow', headers)
for row in reader: data = DataRow._make(row) print(data.name, data.age, data.city)Usando Named Tuple vs Outras Estruturas de Dados
Ao decidir se deve usar namedtuple ou outra estrutura de dados, como um dicionário ou uma classe de dados, você deve levar em consideração as vantagens e desvantagens de cada uma.
Named Tuple vs Dicionário
As instâncias de namedtuple são mais leves em termos de uso de memória do que os dicionários, pois não precisam armazenar as chaves em cada instância. No entanto, os dicionários fornecem uma estrutura flexível que permite adicionar, remover e modificar chaves e valores dinamicamente.
A escolha entre namedtuple e dicionários depende das necessidades específicas do seu código. Se você precisa de uma estrutura de dados imutável e eficiente em termos de memória para armazenar um conjunto fixo de valores, use namedtuple. Caso contrário, se você precisa de uma estrutura de dados flexível com capacidade de expansão dinâmica, os dicionários podem ser uma escolha melhor.
Named Tuple vs Data Class
A partir do Python 3.7, o Python introduziu a dataclass, uma nova técnica para criar classes de dados com facilidade. dataclass oferece recursos semelhantes ao namedtuple, como inicialização automática de campos e geração automática de métodos __repr__() e __eq__().
A principal diferença entre namedtuple e dataclass é que dataclass permite modificar os valores dos campos, enquanto namedtuple cria instâncias imutáveis. Se você precisa de uma estrutura de dados imutável, use namedtuple. Caso contrário, se você precisa de uma estrutura de dados mutável que possa ser modificada após a criação, as dataclasses podem ser uma alternativa mais adequada.
Named Tuple vs typing.NamedTuple
O módulo typing no Python fornece a classe NamedTuple, que é semelhante à função namedtuple() da collections, mas permite adicionar anotações de tipo aos campos da namedtuple. Se você está trabalhando com um projeto que exige anotações de tipo, você pode preferir usar typing.NamedTuple em vez de namedtuple.
Conclusão
Usar namedtuple é uma ótima maneira de escrever código Pythonic e limpo. Com a capacidade de usar nomes de campo em vez de índices e as várias funcionalidades adicionais das namedtuples, você pode tornar seu código mais legível, conciso e fácil de entender. Além disso, a escolha entre namedtuple e outras estruturas de dados depende das necessidades específicas do seu código, então escolha a opção que melhor atenda às suas necessidades.
Esperamos que este tutorial tenha ajudado você a entender melhor as namedtuples e como usá-las em seus projetos Python. Lembre-se de praticar e experimentar para se familiarizar completamente com o seu uso.
