Persistencia de datos de ciudadades - Python Programming Exercise

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 datos en lugar de archivos de texto. Este ejercicio es perfecto para practicar el manejo de archivos, el almacenamiento de datos y la gestión de bases de datos en Python. Al implementar este programa, obtendrás experiencia práctica en el manejo de operaciones de archivos, almacenamiento de datos y gestión de bases de datos en Python. Este ejercicio no solo refuerza tu comprensión del manejo de archivos, 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 el manejo de archivos, el almacenamiento de datos y la gestión de bases 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

Persistencia De Datos De Ciudadades

 Objectivo

Desarrollar un programa Python para crear una nueva versión de la "base de datos de ciudades", utilizando persistencia para almacenar sus datos en lugar de archivos de texto.

 Ejemplo de ejercicio de Python

 Copiar código Python
import sqlite3


class City:
    """Represents a city with a name and population."""

    def __init__(self, name, population):
        """Initialize the city with a name and population."""
        self.name = name
        self.population = population

    def __str__(self):
        """Return a string representation of the city."""
        return f"City: {self.name}, Population: {self.population}"


class CityDatabase:
    """Manages a database of cities."""

    def __init__(self, db_name="cities.db"):
        """Initialize the database connection and create the table if necessary."""
        self.db_name = db_name
        self.connection = sqlite3.connect(self.db_name)
        self.cursor = self.connection.cursor()
        self._create_table()

    def _create_table(self):
        """Create the cities table if it does not exist."""
        self.cursor.execute("""
            CREATE TABLE IF NOT EXISTS cities (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                name TEXT NOT NULL,
                population INTEGER NOT NULL
            )
        """)
        self.connection.commit()

    def add_city(self, city):
        """Add a new city to the database."""
        self.cursor.execute("INSERT INTO cities (name, population) VALUES (?, ?)", (city.name, city.population))
        self.connection.commit()

    def get_all_cities(self):
        """Retrieve all cities from the database."""
        self.cursor.execute("SELECT name, population FROM cities")
        rows = self.cursor.fetchall()
        return [City(name, population) for name, population in rows]

    def delete_city(self, city_name):
        """Delete a city from the database by its name."""
        self.cursor.execute("DELETE FROM cities WHERE name = ?", (city_name,))
        self.connection.commit()

    def update_city_population(self, city_name, new_population):
        """Update the population of a city."""
        self.cursor.execute("UPDATE cities SET population = ? WHERE name = ?", (new_population, city_name))
        self.connection.commit()

    def close(self):
        """Close the database connection."""
        self.connection.close()


# Test Program
if __name__ == "__main__":
    # Initialize the database
    db = CityDatabase()

    # Add new cities
    print("Adding cities to the database...")
    db.add_city(City("New York", 8419000))
    db.add_city(City("Los Angeles", 3980000))
    db.add_city(City("Chicago", 2716000))

    # Retrieve and display all cities
    print("\nCurrent cities in the database:")
    for city in db.get_all_cities():
        print(city)

    # Update a city's population
    print("\nUpdating population of Los Angeles...")
    db.update_city_population("Los Angeles", 4000000)

    # Retrieve and display all cities again
    print("\nCities after update:")
    for city in db.get_all_cities():
        print(city)

    # Delete a city
    print("\nDeleting Chicago...")
    db.delete_city("Chicago")

    # Retrieve and display all cities after deletion
    print("\nCities after deletion:")
    for city in db.get_all_cities():
        print(city)

    # Close the database
    db.close()

 Output

Updating population of Los Angeles...

Cities after update:
City: New York, Population: 8419000
City: Los Angeles, Population: 4000000
City: Chicago, Population: 2716000

 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.

  •  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...

  •  Recopilación de tablas y gestión de archivos

    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...

  •  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 ...