Recopilación de tablas y gestión de archivos - Python Programming Exercise

En este ejercicio, desarrollarás un programa en Python para expandir el ejercicio (tablas + array + archivos) creando tres clases: Table, SetOfTables y un programa de prueba. Este ejercicio es perfecto para practicar la programación orientada a objetos, el manejo de archivos y la serialización de datos en Python. Al implementar este programa, obtendrás experiencia práctica en la programación orientada a objetos, operaciones de archivos y serialización de datos en Python. Este ejercicio no solo refuerza tu comprensión de la programación orientada a objetos, sino que también te ayuda a desarrollar prácticas de codificación eficientes para gestionar las interacciones con el usuario. Además, este ejercicio proporciona una excelente oportunidad para explorar la versatilidad de Python en aplicaciones del mundo real. Al trabajar con la programación orientada a objetos, el manejo de archivos y la serialización de datos, aprenderás a estructurar tu código de manera eficiente, lo cual es una habilidad crucial en muchos escenarios de programación. Este ejercicio también te anima a pensar críticamente sobre cómo estructurar tu código para la legibilidad y el rendimiento, convirtiéndolo en una valiosa adición a tu portafolio de programación. Ya seas un principiante o un programador experimentado, este ejercicio te ayudará a profundizar tu comprensión de Python y mejorar tus habilidades para resolver problemas.

 Categoría

Técnicas de persistencia de objetos

 Ejercicio

Recopilación De Tablas Y Gestión De Archivos

 Objectivo

Desarrollar un programa Python para ampliar el ejercicio (tablas + matriz + archivos) creando tres clases: Table, SetOfTables y un programa de prueba. La clase SetOfTables debe contener una matriz de tablas, así como dos métodos para volcar todos los datos de la matriz en un archivo binario y restaurar los datos del archivo.

 Ejemplo de ejercicio de Python

 Copiar código Python 
import pickle


class Table:
    """Represents a table with width and height."""

    def __init__(self, width, height):
        """Initialize the table with width and height."""
        self.width = width
        self.height = height

    def show_data(self):
        """Display the dimensions of the table."""
        print(f"Width: {self.width}, Height: {self.height}")


class SetOfTables:
    """Manages a collection of Table objects."""

    def __init__(self):
        """Initialize an empty collection of tables."""
        self.tables = []

    def add_table(self, table):
        """Add a new table to the collection."""
        self.tables.append(table)

    def dump_to_file(self, filename):
        """
        Save the collection of tables to a binary file.
        :param filename: Name of the binary file.
        """
        try:
            with open(filename, 'wb') as file:
                pickle.dump(self.tables, file)
            print(f"Data successfully dumped to {filename}.")
        except Exception as e:
            print(f"Error while dumping data to file: {e}")

    def restore_from_file(self, filename):
        """
        Load the collection of tables from a binary file.
        :param filename: Name of the binary file.
        """
        try:
            with open(filename, 'rb') as file:
                self.tables = pickle.load(file)
            print(f"Data successfully restored from {filename}.")
        except Exception as e:
            print(f"Error while restoring data from file: {e}")

    def show_all_tables(self):
        """Display data for all tables in the collection."""
        for i, table in enumerate(self.tables, start=1):
            print(f"Table {i}:")
            table.show_data()


# Test Program
if __name__ == "__main__":
    import random

    # Create an instance of SetOfTables
    set_of_tables = SetOfTables()

    # Generate and add 10 random tables
    for _ in range(10):
        width = random.randint(50, 200)
        height = random.randint(50, 200)
        set_of_tables.add_table(Table(width, height))

    # Display all tables
    print("Initial table data:")
    set_of_tables.show_all_tables()

    # Dump data to a binary file
    filename = "set_of_tables.bin"
    set_of_tables.dump_to_file(filename)

    # Clear the current collection
    set_of_tables.tables = []

    # Restore data from the binary file
    print("\nRestoring data from file...")
    set_of_tables.restore_from_file(filename)

    # Display the restored tables
    print("\nRestored table data:")
    set_of_tables.show_all_tables()

 Output

Initial Table Data:

Initial table data:
Table 1:
Width: 120, Height: 80
Table 2:
Width: 150, Height: 90
...

After Restoring:

Restoring data from file...

Restored table data:
Table 1:
Width: 120, Height: 80
Table 2:
Width: 150, Height: 90
...

 Comparte este ejercicio de Python

 Más Ejercicios Programación Python de Técnicas de persistencia de objetos

¡Explora nuestro conjunto de ejercicios de programación Python! Estos ejercicios, diseñados específicamente para principiantes, te ayudarán a desarrollar una sólida comprensión de los conceptos básicos de Python. Desde variables y tipos de datos hasta estructuras de control y funciones simples, cada ejercicio está diseñado para desafiarte de manera gradual a medida que adquieres confianza en la codificación en Python.

  •  Persistencia de datos sobre insectos

    En este ejercicio, desarrollarás un programa en Python para crear una nueva versión del ejercicio "insectos", que debe persistir los datos utilizando alguna forma de ...

  •  Persistencia de datos de ciudadades

    En este ejercicio, desarrollarás un programa en Python para crear una nueva versión de la "base de datos de ciudades", utilizando persistencia para almacenar sus dato...

  •  Gestión de tablas, matrices y archivos

    En este ejercicio, desarrollarás un programa en Python para expandir el ejercicio de tablas + array, de modo que incluya dos nuevos métodos: volcar los datos del arra...