Implementar uma Named Tuple Simples

Introdução

Neste projeto, você aprenderá como implementar uma named tuple simples em Python. Uma named tuple é uma estrutura de dados que permite acessar dados usando tanto indexação posicional quanto nomes de atributos, fornecendo uma maneira mais intuitiva e legível de trabalhar com dados estruturados.

👀 Pré-visualização

## Output

🎯 Tarefas

Neste projeto, você aprenderá:

• Como criar uma classe NamedTuple que herda da classe tuple embutida
• Como implementar os métodos __init__, __new__, __getitem__ e __repr__ para alcançar a funcionalidade desejada
• Como acessar dados usando tanto indexação posicional quanto nomes de atributos
• Como representar a instância NamedTuple em um formato legível

🏆 Conquistas

Após concluir este projeto, você será capaz de:

• Compreender o conceito de named tuples e seus benefícios
• Implementar uma classe named tuple simples em Python
• Usar a named tuple para acessar e representar dados estruturados de uma maneira mais intuitiva

Implementar a Classe NamedTuple

Nesta etapa, você aprenderá como implementar a classe NamedTuple, que permite acessar dados usando tanto indexação posicional quanto nomes de atributos.

1. Abra o arquivo namedtuple.py no seu editor de código.
2. Defina a classe NamedTuple, que deve herdar da classe tuple.
3. No método __init__, aceite dois parâmetros: iterable (os dados) e fields (os nomes para os dados).
4. Armazene o iterable e fields como variáveis de instância self.data e self.fields, respectivamente.
5. Use um loop for para iterar sobre os fields e definir cada campo como um atributo da instância NamedTuple, atribuindo o valor correspondente de self.data.
6. Implemente o método __new__ para criar uma nova instância da classe NamedTuple. Este método deve chamar o método __new__ da classe tuple e retornar a nova instância.
7. Implemente o método __getitem__ para permitir o acesso aos dados usando tanto indexação posicional quanto nomes de atributos. Se o índice for uma string, encontre o índice do campo correspondente em self.fields e retorne o valor de self.data.
8. Implemente o método __repr__ para retornar uma representação em string da instância NamedTuple no formato NamedTuple(x=1, y=2), onde x e y são os nomes dos campos, e 1 e 2 são os valores correspondentes.

Sua classe NamedTuple completa deve ser semelhante a esta:

class NamedTuple(tuple):
    def __init__(self, iterable, fields):
        self.data = iterable
        self.fields = tuple(fields)
        for i, attr in enumerate(self.fields):
            setattr(self, attr, self.data[i])

    def __new__(cls, iterable, fields):
        return super().__new__(cls, iterable)

    def __getitem__(self, index):
        if isinstance(index, str):
            index = self.fields.index(index)
        return self.data[index]

    def __repr__(self):
        return f"NamedTuple({', '.join(f'{field}={self[field]}' for field in self.fields)})"

Testar a Classe NamedTuple

Nesta etapa, você testará a classe NamedTuple que implementou na etapa anterior.

1. No arquivo namedtuple.py, adicione o seguinte código no final do arquivo:

if __name__ == "__main__":
    ## Example usage:
    testData = [1, 2]
    fields = ["x", "y"]
    t = NamedTuple(testData, fields)
    print(t)  ## Output: NamedTuple(x=1, y=2)
    print(t[1])  ## Output: 2
    print(t.x)  ## Output: 1

2. Salve o arquivo namedtuple.py.
3. Abra um terminal ou prompt de comando e navegue até o diretório que contém o arquivo namedtuple.py.
4. Execute o seguinte comando para executar o script:

python3 namedtuple.py

Você deve ver a seguinte saída:

NamedTuple(x=1, y=2)
2
1

Isso demonstra que a classe NamedTuple está funcionando como esperado, permitindo que você acesse os dados usando tanto indexação posicional quanto nomes de atributos.

Parabéns! Você implementou com sucesso uma named tuple simples em Python.

Resumo

Parabéns! Você concluiu este projeto. Você pode praticar mais laboratórios no LabEx para aprimorar suas habilidades.