Implementar una tupla con nombre simple

Introducción

En este proyecto, aprenderás cómo implementar una tupla con nombre simple en Python. Una tupla con nombre es una estructura de datos que te permite acceder a los datos utilizando tanto la indexación posicional como los nombres de atributos, lo que proporciona una forma más intuitiva y legible de trabajar con datos estructurados.

👀 Vista previa

$ python3 amedtuple.py
## Salida
NamedTuple(x=1, y=2)
2
1

🎯 Tareas

En este proyecto, aprenderás:

• Cómo crear una clase NamedTuple que herede de la clase tuple incorporada
• Cómo implementar los métodos __init__, __new__, __getitem__ y __repr__ para lograr la funcionalidad deseada
• Cómo acceder a los datos utilizando tanto la indexación posicional como los nombres de atributos
• Cómo representar la instancia de NamedTuple en un formato legible

🏆 Logros

Después de completar este proyecto, podrás:

• Comprender el concepto de tuplas con nombre y sus beneficios
• Implementar una clase simple de tupla con nombre en Python
• Utilizar la tupla con nombre para acceder y representar datos estructurados de manera más intuitiva

Skills Graph

Implementar la clase NamedTuple

En este paso, aprenderás cómo implementar la clase NamedTuple, que te permite acceder a los datos utilizando tanto la indexación posicional como los nombres de atributos.

1. Abra el archivo namedtuple.py en su editor de código.
2. Defina la clase NamedTuple, que debe heredar de la clase tuple.
3. En el método __init__, acepte dos parámetros: iterable (los datos) y fields (los nombres para los datos).
4. Almacene el iterable y los fields como variables de instancia self.data y self.fields, respectivamente.
5. Utilice un bucle for para iterar sobre los fields y establezca cada campo como un atributo de la instancia de NamedTuple, asignando el valor correspondiente de self.data.
6. Implemente el método __new__ para crear una nueva instancia de la clase NamedTuple. Este método debe llamar al método __new__ de la clase tuple y devolver la nueva instancia.
7. Implemente el método __getitem__ para permitir el acceso a los datos utilizando tanto la indexación posicional como los nombres de atributos. Si el índice es una cadena, encuentre el índice del campo correspondiente en self.fields y devuelva el valor de self.data.
8. Implemente el método __repr__ para devolver una representación en cadena de la instancia de NamedTuple en el formato NamedTuple(x=1, y=2), donde x e y son los nombres de los campos y 1 y 2 son los valores correspondientes.

Su clase NamedTuple completada debería verse así:

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)})"

Prueba la clase NamedTuple

En este paso, probarás la clase NamedTuple que implementaste en el paso anterior.

1. En el archivo namedtuple.py, agregue el siguiente código al final del archivo:

if __name__ == "__main__":
    ## Uso de ejemplo:
    testData = [1, 2]
    fields = ["x", "y"]
    t = NamedTuple(testData, fields)
    print(t)  ## Salida: NamedTuple(x=1, y=2)
    print(t[1])  ## Salida: 2
    print(t.x)  ## Salida: 1

2. Guarde el archivo namedtuple.py.
3. Abra una terminal o un símbolo del sistema y navegue hasta el directorio que contiene el archivo namedtuple.py.
4. Ejecute el siguiente comando para ejecutar el script:

python3 namedtuple.py

Debería ver la siguiente salida:

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

Esto demuestra que la clase NamedTuple está funcionando como se esperaba, lo que te permite acceder a los datos utilizando tanto la indexación posicional como los nombres de atributos.

¡Felicitaciones! Has implementado con éxito una tupla con nombre simple en Python.

Resumen

¡Felicitaciones! Has completado este proyecto. Puedes practicar más laboratorios en LabEx para mejorar tus habilidades.