🚀 DÍA 14/30: El equivalente a "SELECT * WHERE" de SQL, pero en memoria RAM.

Tienes millones de registros y solo quieres los números pares o los usuarios mayores de edad. Las máscaras booleanas son magia.

import numpy as np

edades = np.array([15, 22, 17, 35, 12])

# 🎭 Filtramos directamente poniendo la condición dentro

mayores = edades[edades >= 18]

print(mayores) # [22, 35]

📌 GUARDA este snippet. Filtrar así es hasta 100 veces más rápido que usar bucles FOR.

👇 Etiqueta a alguien que trabaje con bases de datos y necesite este truco.

🚀 DÍA 13/30: Coordenadas precisas en tus tablas bidimensionales.

Acceder a datos en una tabla plana (Filas x Columnas) requiere dos claves. Así se hace en NumPy.

import numpy as np

tabla = np.array([[1, 2, 3],

[4, 5, 6]])

# 📍 [Fila, Columna] (Recuerda: empezamos en 0)

dato = tabla[1, 2]

print("Dato extraído:", dato) # 6

📌 GUARDA este esquema mental: Primero Filas (Y), luego Columnas (X).

👇 ¿Qué código usarías para extraer el número 2? ¡A ver quién acierta primero!

🚀 DÍA 4/30: Moldeando datos a tu voluntad.

Tienes una lista plana de 12 meses de ventas, pero quieres verla como 4 trimestres de 3 meses. reshape es tu mejor amigo.

import numpy as np

meses = np.arange(1, 13) # Del 1 al 12

# 🔄 Convertir lista 1D a matriz 2D (4x3)

trimestres = meses.reshape(4, 3)

print(trimestres)

📌 GUARDA el post para cuando tus datos no encajen en tu base de datos. 👇 Comenta "MOLDE" si quieres ver cómo conectar esto con bases de datos SQL en mi canal.

Día 25 — SQLite: bases de datos sin instalar nada

SQLite es un sistema de base de datos ligero que viene incluido en la librería estándar de Python, sin necesidad de instalar ni configurar ningún servidor adicional. Es ideal para aplicaciones pequeñas, prototipos rápidos o para aprender los fundamentos de SQL desde un entorno controlado.

El módulo sqlite3 permite crear tablas, insertar registros, realizar consultas y gestionar transacciones usando sentencias SQL estándar, lo que hace que el conocimiento adquirido sea directamente transferible a otros motores de base de datos como MySQL o PostgreSQL.

Código de ejemplo:

import sqlite3

conexion = sqlite3.connect("clientes.db")
cursor = conexion.cursor()

cursor.execute("""
    CREATE TABLE IF NOT EXISTS clientes (
        id INTEGER PRIMARY KEY,
        nombre TEXT,
        email TEXT
    )
""")

cursor.execute("INSERT INTO clientes VALUES (1, 'Ana', 'ana@mail.com')")
conexion.commit()

for fila in cursor.execute("SELECT * FROM clientes"):
    print(fila)

conexion.close()

👉 Ejercicios Prácticos con Flask y PostgreSQL en Python

Ya aprendimos a conectar Flask con PostgreSQL. Ahora es momento de poner en práctica lo aprendido con ejercicios explicados paso a paso.

Hoy resolveremos ejercicios sobre:
✔️ Crear una base de datos PostgreSQL y conectarla a Flask
✔️ Definir modelos con SQLAlchemy
✔️ Construir una API REST para insertar y consultar datos
✔️ Actualizar y eliminar registros en PostgreSQL desde Flask

📌 Cada ejercicio incluye código, explicación y prueba de salida.

---

1️⃣ Ejercicio: Crear la Base de Datos y Conectarla con Flask

📍 Objetivo: Crear una base de datos PostgreSQL y conectarla a Flask usando SQLAlchemy.

📌 Código:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)

# Configurar PostgreSQL en Flask
app.config["SQLALCHEMY_DATABASE_URI"] = "postgresql://mi_usuario:mi_clave@localhost/mi_app"
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False

db = SQLAlchemy(app)

@app.route("/")
def home():
    return "Conexión exitosa con PostgreSQL"

if __name__ == "__main__":
    app.run(debug=True)

📌 Salida esperada en http://127.0.0.1:5000/

Conexión exitosa con PostgreSQL

✅ Este código establece la conexión entre Flask y PostgreSQL.

---

2️⃣ Ejercicio: Definir un Modelo para Usuarios en PostgreSQL

📍 Objetivo: Crear una tabla usuarios en PostgreSQL con SQLAlchemy.

📌 Código:

class Usuario(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    nombre = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

# Crear la tabla en PostgreSQL
with app.app_context():
    db.create_all()

📌 Salida esperada:

Tabla usuarios creada en PostgreSQL

✅ Ahora Flask puede almacenar y gestionar usuarios en PostgreSQL.

---

3️⃣ Ejercicio: Insertar Datos en PostgreSQL desde Flask

📍 Objetivo: Crear una API que permita agregar nuevos usuarios.

📌 Código:

from flask import request, jsonify

@app.route("/usuarios", methods=["POST"])
def agregar_usuario():
    datos = request.json
    nuevo_usuario = Usuario(nombre=datos["nombre"], email=datos["email"])
    
    db.session.add(nuevo_usuario)
    db.session.commit()
    
    return jsonify({"mensaje": "Usuario agregado correctamente"}), 201

📌 Ejemplo de JSON enviado en una petición POST:

{
    "nombre": "Carlos",
    "email": "carlos@example.com"
}

📌 Salida esperada:

{
    "mensaje": "Usuario agregado correctamente"
}

✅ Ahora los usuarios pueden registrarse desde una API en Flask.

---

4️⃣ Ejercicio: Consultar Usuarios desde PostgreSQL

📍 Objetivo: Obtener una lista de usuarios desde PostgreSQL.

📌 Código:

@app.route("/usuarios", methods=["GET"])
def obtener_usuarios():
    usuarios = Usuario.query.all()
    
    usuarios_json = [
        {"id": u.id, "nombre": u.nombre, "email": u.email} for u in usuarios
    ]
    
    return jsonify(usuarios_json)

📌 Salida esperada en http://127.0.0.1:5000/usuarios

[
    {"id": 1, "nombre": "Carlos", "email": "carlos@example.com"},
    {"id": 2, "nombre": "Ana", "email": "ana@example.com"}
]

✅ Ahora la API Flask puede consultar usuarios en PostgreSQL.

---

5️⃣ Ejercicio: Actualizar Datos de un Usuario

📍 Objetivo: Modificar el email de un usuario en PostgreSQL.

📌 Código:

@app.route("/usuarios/<int:id>", methods=["PUT"])
def actualizar_usuario(id):
    datos = request.json
    usuario = Usuario.query.get_or_404(id)
    
    usuario.email = datos["email"]
    db.session.commit()
    
    return jsonify({"mensaje": "Usuario actualizado correctamente"})

📌 Ejemplo de JSON enviado en PUT:

{
    "email": "nuevoemail@example.com"
}

📌 Salida esperada:

{
    "mensaje": "Usuario actualizado correctamente"
}

✅ Permite modificar registros en la base de datos desde Flask.

---

6️⃣ Ejercicio: Eliminar un Usuario en PostgreSQL

📍 Objetivo: Borrar un usuario de la base de datos PostgreSQL.

📌 Código:

@app.route("/usuarios/<int:id>", methods=["DELETE"])
def eliminar_usuario(id):
    usuario = Usuario.query.get_or_404(id)
    
    db.session.delete(usuario)
    db.session.commit()
    
    return jsonify({"mensaje": "Usuario eliminado correctamente"})

📌 Salida esperada:

{
    "mensaje": "Usuario eliminado correctamente"
}

✅ Ahora los usuarios pueden ser eliminados desde la API.

---

🚀 Conclusión

✅ Flask y PostgreSQL permiten construir APIs escalables en Python.
✅ SQLAlchemy facilita la manipulación de datos en la base de datos.
✅ Ahora puedes crear, leer, actualizar y eliminar registros en PostgreSQL.

📌 Próximo post: Cómo autenticar usuarios en Flask con PostgreSQL.

📂 Código disponible en mi GitHub: github.com/josecodetech

🎥 Aprende con mis videos en YouTube: https://www.youtube.com/@josecodetech

💬 ¿Has trabajado con PostgreSQL en Flask? ¿Qué tal tu experiencia? Cuéntamelo.

👉 Conectando Flask con PostgreSQL para Aplicaciones Web en Producción

En el post anterior, desplegamos nuestra aplicación Flask con SQLite. Sin embargo, para proyectos más grandes, PostgreSQL es una mejor opción.

Hoy aprenderás:
✔️ Por qué usar PostgreSQL en vez de SQLite
✔️ Cómo conectar Flask con PostgreSQL
✔️ Migrar datos de SQLite a PostgreSQL
✔️ Ejemplo paso a paso con SQLAlchemy

📌 Al final del tutorial, podrás manejar bases de datos PostgreSQL en Flask.

---

1️⃣ ¿Por qué Usar PostgreSQL en Producción?

📌 Diferencias entre SQLite y PostgreSQL:

Característica	SQLite	PostgreSQL
Uso recomendado	Apps pequeñas	Proyectos grandes
Manejo de datos	Local (archivo)	Cliente-servidor
Concurrencia	Limitada	Alta escalabilidad
Soporte de usuarios	No	Sí
Integración con la nube	No recomendada	Ideal para producción

🔹 Usamos PostgreSQL cuando necesitamos:
✅ Alta concurrencia (múltiples usuarios accediendo a la base de datos).
✅ Escalabilidad (mejor rendimiento en grandes volúmenes de datos).
✅ Despliegue en producción con plataformas en la nube.

---

2️⃣ Instalar PostgreSQL y Crear una Base de Datos

📌 Si no tienes PostgreSQL, instálalo:

🔹 En Linux (Ubuntu/Debian):

sudo apt update && sudo apt install postgresql postgresql-contrib

🔹 En Windows:
Descarga desde postgresql.org e instala.

📌 Para acceder a PostgreSQL en la terminal:

sudo -i -u postgres
psql

📌 Crea una base de datos llamada mi_app:

CREATE DATABASE mi_app;

📌 Crea un usuario y otorga permisos:

CREATE USER mi_usuario WITH PASSWORD 'mi_clave';
GRANT ALL PRIVILEGES ON DATABASE mi_app TO mi_usuario;

✅ La base de datos PostgreSQL está lista para usarse con Flask.

---

3️⃣ Conectar Flask con PostgreSQL

Usaremos SQLAlchemy, el ORM de Flask, para manejar PostgreSQL.

📌 Instala las dependencias:

pip install flask flask-sqlalchemy psycopg2-binary

📌 Configura Flask para conectarse a PostgreSQL:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)

# Configurar PostgreSQL en Flask
app.config["SQLALCHEMY_DATABASE_URI"] = "postgresql://mi_usuario:mi_clave@localhost/mi_app"
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False

db = SQLAlchemy(app)

@app.route("/")
def home():
    return "Conexión exitosa con PostgreSQL"

if __name__ == "__main__":
    app.run(debug=True)

📌 Explicación:
✅ SQLALCHEMY_DATABASE_URI → Define la conexión con PostgreSQL.
✅ db = SQLAlchemy(app) → Inicializa SQLAlchemy en Flask.

📌 Ejecuta la aplicación:

python app.py

✅ Si visitas http://127.0.0.1:5000/ y ves "Conexión exitosa con PostgreSQL", todo está funcionando.

---

4️⃣ Migrar Datos de SQLite a PostgreSQL

Si tienes datos en SQLite, puedes migrarlos a PostgreSQL fácilmente.

📌 Pasos para migrar:

1️⃣ Exportar datos desde SQLite:

sqlite3 mi_base.db .dump > backup.sql

2️⃣ Convertir el formato de SQLite a PostgreSQL:
Abre backup.sql en un editor de texto y reemplaza:

• "AUTOINCREMENT" por "SERIAL"
• INSERT INTO "tabla" por INSERT INTO tabla

3️⃣ Importar datos en PostgreSQL:

psql -U mi_usuario -d mi_app -f backup.sql

✅ Los datos ahora están en PostgreSQL y listos para usarse con Flask.

---

5️⃣ Crear una Tabla y Manipular Datos con SQLAlchemy

📌 Código para definir y manipular datos en PostgreSQL con SQLAlchemy:

class Usuario(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    nombre = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

# Crear la base de datos y la tabla
with app.app_context():
    db.create_all()

📌 Insertar datos en PostgreSQL desde Flask:

nuevo_usuario = Usuario(nombre="José", email="jose@example.com")
db.session.add(nuevo_usuario)
db.session.commit()

📌 Consultar datos en PostgreSQL:

usuarios = Usuario.query.all()
for usuario in usuarios:
    print(usuario.nombre, usuario.email)

✅ PostgreSQL ahora está completamente integrado con Flask.

---

🚀 Conclusión

✅ PostgreSQL es más potente y escalable que SQLite para producción.
✅ SQLAlchemy facilita la conexión entre Flask y PostgreSQL.
✅ Migrar datos de SQLite a PostgreSQL es simple con .dump.

📌 Próximo post: Ejercicios prácticos con Flask y PostgreSQL.

📂 Código disponible en mi GitHub: github.com/josecodetech

🎥 Aprende con mis videos en YouTube: https://www.youtube.com/@josecodetech/

💬 ¿Prefieres SQLite o PostgreSQL? Cuéntamelo en los comentarios.

👉 Ejercicios Prácticos con Flask y SQLite en Python

Ya aprendimos a conectar SQLite con Flask para crear aplicaciones web dinámicas. Ahora es momento de poner en práctica lo aprendido con ejercicios explicados paso a paso.

Hoy resolveremos ejercicios sobre:
✔️ Conectar Flask con una base de datos SQLite
✔️ Crear una API para insertar y consultar datos
✔️ Actualizar y eliminar registros desde la web
✔️ Ejemplo práctico con un sistema de gestión de tareas

📌 Cada ejercicio incluye código, explicación y prueba de salida.

---

1️⃣ Ejercicio: Crear la Base de Datos SQLite y una Tabla de Tareas

📍 Objetivo: Crear una base de datos tareas.db y una tabla tareas.

🔹 Código:

import sqlite3

conexion = sqlite3.connect("tareas.db")
cursor = conexion.cursor()

cursor.execute("""
CREATE TABLE IF NOT EXISTS tareas (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    descripcion TEXT,
    estado TEXT
)
""")

conexion.commit()
conexion.close()
print("Base de datos y tabla de tareas creadas exitosamente.")

📌 Salida esperada:

Base de datos y tabla de tareas creadas exitosamente.

✅ Este código crea la base de datos SQLite con una tabla de tareas.

---

2️⃣ Ejercicio: Crear una API con Flask para Obtener las Tareas

📍 Objetivo: Crear una API con Flask para obtener todas las tareas almacenadas en SQLite.

🔹 Código:

from flask import Flask, jsonify
import sqlite3

app = Flask(__name__)

def get_db_connection():
    conexion = sqlite3.connect("tareas.db")
    conexion.row_factory = sqlite3.Row
    return conexion

@app.route("/tareas", methods=["GET"])
def obtener_tareas():
    conexion = get_db_connection()
    cursor = conexion.cursor()
    cursor.execute("SELECT * FROM tareas")
    tareas = cursor.fetchall()
    conexion.close()
    
    tareas_json = [{"id": tarea["id"], "descripcion": tarea["descripcion"], "estado": tarea["estado"]} for tarea in tareas]
    
    return jsonify(tareas_json)

if __name__ == "__main__":
    app.run(debug=True)

📌 Salida esperada en http://127.0.0.1:5000/tareas:

[
    {"id": 1, "descripcion": "Terminar proyecto", "estado": "Pendiente"},
    {"id": 2, "descripcion": "Enviar informe", "estado": "Completado"}
]

✅ Esta API permite obtener todas las tareas almacenadas en la base de datos.

---

3️⃣ Ejercicio: Agregar Tareas a la Base de Datos Desde una API

📍 Objetivo: Permitir que los usuarios agreguen tareas mediante una API Flask.

🔹 Código:

from flask import request

@app.route("/tareas", methods=["POST"])
def agregar_tarea():
    nueva_tarea = request.json
    conexion = get_db_connection()
    cursor = conexion.cursor()
    
    cursor.execute("INSERT INTO tareas (descripcion, estado) VALUES (?, ?)",
                   (nueva_tarea["descripcion"], nueva_tarea["estado"]))
    
    conexion.commit()
    conexion.close()
    
    return jsonify({"mensaje": "Tarea agregada correctamente"}), 201

📌 Ejemplo de JSON enviado en una petición POST:

{
    "descripcion": "Aprender Flask",
    "estado": "Pendiente"
}

📌 Salida esperada:

{
    "mensaje": "Tarea agregada correctamente"
}

✅ Este código permite que los usuarios añadan tareas a la base de datos.

---

4️⃣ Ejercicio: Actualizar el Estado de una Tarea

📍 Objetivo: Modificar el estado de una tarea en la base de datos.

🔹 Código:

@app.route("/tareas/<int:id>", methods=["PUT"])
def actualizar_tarea(id):
    datos = request.json
    conexion = get_db_connection()
    cursor = conexion.cursor()
    
    cursor.execute("UPDATE tareas SET estado = ? WHERE id = ?", (datos["estado"], id))
    
    conexion.commit()
    conexion.close()
    
    return jsonify({"mensaje": "Tarea actualizada correctamente"})

📌 Ejemplo de JSON enviado en una petición PUT:

{
    "estado": "Completado"
}

📌 Salida esperada:

{
    "mensaje": "Tarea actualizada correctamente"
}

✅ Este código permite actualizar el estado de una tarea específica.

---

5️⃣ Ejercicio: Eliminar una Tarea de la Base de Datos

📍 Objetivo: Borrar una tarea de la base de datos SQLite.

🔹 Código:

@app.route("/tareas/<int:id>", methods=["DELETE"])
def eliminar_tarea(id):
    conexion = get_db_connection()
    cursor = conexion.cursor()
    
    cursor.execute("DELETE FROM tareas WHERE id = ?", (id,))
    
    conexion.commit()
    conexion.close()
    
    return jsonify({"mensaje": "Tarea eliminada correctamente"})

📌 Salida esperada al eliminar una tarea:

{
    "mensaje": "Tarea eliminada correctamente"
}

✅ Útil para eliminar registros innecesarios.

---

🚀 Conclusión

✅ Hoy hemos resuelto ejercicios con Flask y SQLite en Python.
✅ Estos ejercicios permiten crear APIs para gestionar tareas desde una base de datos.
✅ Practica modificando el código para entenderlo mejor.

📌 Próximo post: Cómo desplegar una aplicación Flask con SQLite en la nube.

📂 Descarga los ejercicios en mi GitHub: github.com/josecodetech

🎥 Aprende con mis videos en YouTube: https://www.youtube.com/@josecodetech

💬 ¿Te gustaría agregar nuevas funciones a este proyecto? ¡Coméntalo!

👉 Conectando SQLite con una Aplicación Web en Python: Flask y Bases de Datos

 

Hemos aprendido a manejar bases de datos SQLite en Python. Ahora daremos un paso más: conectar SQLite con una aplicación web usando Flask.

Hoy aprenderás:
✔️ ¿Qué es Flask y por qué usarlo?
✔️ Cómo conectar Flask con SQLite
✔️ Crear una API para interactuar con la base de datos
✔️ Consultar y mostrar datos en una página web
✔️ Ejemplo práctico paso a paso

📌 Con este tutorial, podrás construir aplicaciones web dinámicas con bases de datos.

---

1️⃣ ¿Qué es Flask y por qué usarlo?

Flask es un framework ligero para crear aplicaciones web en Python.

📌 Ventajas de Flask:
✅ Fácil de aprender y usar
✅ Permite crear APIs y páginas web dinámicas
✅ Compatible con bases de datos como SQLite
✅ Ideal para proyectos pequeños y medianos

Para instalar Flask, ejecuta:

pip install flask

---

2️⃣ Conectar Flask con SQLite

El primer paso es crear un archivo app.py y configurar la conexión con SQLite.

📌 Código para conectar Flask con SQLite:

from flask import Flask, g
import sqlite3

app = Flask(__name__)
DATABASE = "mi_base.db"

def get_db():
    db = getattr(g, "_database", None)
    if db is None:
        db = g._database = sqlite3.connect(DATABASE)
    return db

@app.teardown_appcontext
def close_connection(exception):
    db = getattr(g, "_database", None)
    if db is not None:
        db.close()

📌 Explicación:
✅ sqlite3.connect(DATABASE) → Conecta SQLite con Flask.
✅ get_db() → Obtiene la conexión a la base de datos.
✅ @app.teardown_appcontext → Cierra la conexión cuando termina la petición.

---

3️⃣ Crear una API con Flask y SQLite

Vamos a crear una API REST que devuelva los datos almacenados en SQLite.

📌 Código para obtener todos los registros de una tabla productos:

from flask import jsonify

@app.route("/productos", methods=["GET"])
def get_productos():
    db = get_db()
    cursor = db.cursor()
    cursor.execute("SELECT * FROM productos")
    productos = cursor.fetchall()
    
    productos_json = [
        {"id": p[0], "nombre": p[1], "precio": p[2], "stock": p[3]} for p in productos
    ]
    
    return jsonify(productos_json)

📌 Explicación:
✅ @app.route("/productos") → Define una ruta para obtener los productos.
✅ jsonify(productos_json) → Devuelve los datos en formato JSON.

📌 Salida esperada al visitar http://127.0.0.1:5000/productos en el navegador:

[
    {"id": 1, "nombre": "Laptop", "precio": 1200.5, "stock": 10},
    {"id": 2, "nombre": "Mouse", "precio": 25.99, "stock": 50}
]

---

4️⃣ Insertar Datos desde una API Flask

También podemos permitir que los usuarios envíen datos a la base de datos.

📌 Código para insertar productos en la base de datos:

from flask import request

@app.route("/productos", methods=["POST"])
def add_producto():
    nuevo_producto = request.json
    db = get_db()
    cursor = db.cursor()
    
    cursor.execute("INSERT INTO productos (nombre, precio, stock) VALUES (?, ?, ?)",
                   (nuevo_producto["nombre"], nuevo_producto["precio"], nuevo_producto["stock"]))
    
    db.commit()
    return jsonify({"mensaje": "Producto agregado correctamente"}), 201

📌 Explicación:
✅ request.json → Recibe los datos enviados en formato JSON.
✅ INSERT INTO productos (...) VALUES (...) → Inserta un nuevo registro en la base de datos.

📌 Ejemplo de JSON enviado en una petición POST:

{
    "nombre": "Teclado",
    "precio": 45.75,
    "stock": 30
}

✅ El producto se agregará a la base de datos y la API responderá con un mensaje de éxito.

---

5️⃣ Mostrar los Datos en una Página Web con Flask y SQLite

Flask también nos permite mostrar los datos en una página HTML en lugar de JSON.

📌 Código para mostrar los productos en una plantilla HTML:

from flask import render_template

@app.route("/")
def index():
    db = get_db()
    cursor = db.cursor()
    cursor.execute("SELECT * FROM productos")
    productos = cursor.fetchall()
    
    return render_template("index.html", productos=productos)

📌 Plantilla templates/index.html:

<!DOCTYPE html>
<html>
<head>
    <title>Lista de Productos</title>
</head>
<body>
    <h1>Productos Disponibles</h1>
    <ul>
        {% for producto in productos %}
            <li>{{ producto[1] }} - Precio: {{ producto[2] }} USD - Stock: {{ producto[3] }}</li>
        {% endfor %}
    </ul>
</body>
</html>

📌 Explicación:
✅ render_template("index.html") → Carga una plantilla HTML.
✅ {% for producto in productos %} → Muestra cada producto en la página.

📌 Salida esperada en el navegador:

Productos Disponibles
- Laptop - Precio: 1200.5 USD - Stock: 10
- Mouse - Precio: 25.99 USD - Stock: 50

✅ Esta página muestra los productos almacenados en SQLite.

---

🚀 Conclusión

✅ Flask permite conectar aplicaciones web con SQLite en Python.
✅ Podemos crear APIs REST para interactuar con la base de datos.
✅ Los datos pueden mostrarse en formato JSON o en una página HTML.

📌 Próximo post: Ejercicios prácticos con Flask y SQLite en Python.

📂 Código disponible en mi GitHub: github.com/josecodetech

🎥 Aprende con mis videos en YouTube: https://www.youtube.com/@josecodetech

💬 ¿Has trabajado con bases de datos en aplicaciones web? Cuéntamelo.

👉 Ejercicios Prácticos con Bases de Datos SQLite en Python

Ya aprendimos a crear, insertar y consultar datos en bases de datos SQLite en Python. Ahora es momento de poner en práctica lo aprendido con ejercicios explicados paso a paso.

Hoy resolveremos ejercicios sobre:
✔️ Conectar y crear una base de datos SQLite
✔️ Insertar múltiples registros en una tabla
✔️ Consultar, actualizar y eliminar datos
✔️ Ejemplo práctico con una base de datos de productos

📌 Cada ejercicio incluye el código, explicación y prueba de salida.

---

1️⃣ Ejercicio: Crear una Base de Datos SQLite y una Tabla

📍 Objetivo: Crear una base de datos llamada tienda.db y una tabla productos.

🔹 Código:

import sqlite3

conexion = sqlite3.connect("tienda.db")
cursor = conexion.cursor()

cursor.execute("""
CREATE TABLE IF NOT EXISTS productos (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    nombre TEXT,
    precio REAL,
    stock INTEGER
)
""")

conexion.commit()
conexion.close()
print("Base de datos y tabla creadas exitosamente.")

✅ Este código crea una base de datos SQLite con una tabla productos.

📌 Salida esperada:

Base de datos y tabla creadas exitosamente.

---

2️⃣ Ejercicio: Insertar Productos en la Base de Datos

📍 Objetivo: Insertar varios productos en la tabla productos.

🔹 Código:

conexion = sqlite3.connect("tienda.db")
cursor = conexion.cursor()

productos = [
    ("Laptop", 1200.50, 10),
    ("Mouse", 25.99, 50),
    ("Teclado", 45.75, 30),
    ("Monitor", 300.00, 15)
]

cursor.executemany("INSERT INTO productos (nombre, precio, stock) VALUES (?, ?, ?)", productos)

conexion.commit()
conexion.close()
print("Productos agregados correctamente.")

📌 Salida esperada:

Productos agregados correctamente.

✅ Este código inserta múltiples registros en la tabla de productos.

---

3️⃣ Ejercicio: Consultar los Productos Disponibles

📍 Objetivo: Obtener todos los productos almacenados en la base de datos.

🔹 Código:

conexion = sqlite3.connect("tienda.db")
cursor = conexion.cursor()

cursor.execute("SELECT * FROM productos")
productos = cursor.fetchall()

for producto in productos:
    print(producto)

conexion.close()

📌 Salida esperada:

(1, 'Laptop', 1200.5, 10)
(2, 'Mouse', 25.99, 50)
(3, 'Teclado', 45.75, 30)
(4, 'Monitor', 300.0, 15)

✅ Ideal para visualizar los datos almacenados en SQLite.

---

4️⃣ Ejercicio: Actualizar el Stock de un Producto

📍 Objetivo: Modificar la cantidad de stock de un producto en la base de datos.

🔹 Código:

conexion = sqlite3.connect("tienda.db")
cursor = conexion.cursor()

cursor.execute("UPDATE productos SET stock = ? WHERE nombre = ?", (20, "Laptop"))

conexion.commit()
conexion.close()
print("Stock actualizado correctamente.")

📌 Salida esperada:

Stock actualizado correctamente.

✅ Permite actualizar datos en la base de datos.

---

5️⃣ Ejercicio: Eliminar un Producto de la Base de Datos

📍 Objetivo: Borrar un producto de la base de datos SQLite.

🔹 Código:

conexion = sqlite3.connect("tienda.db")
cursor = conexion.cursor()

cursor.execute("DELETE FROM productos WHERE nombre = ?", ("Mouse",))

conexion.commit()
conexion.close()
print("Producto eliminado correctamente.")

📌 Salida esperada:

Producto eliminado correctamente.

✅ Útil para eliminar registros innecesarios.

---

🚀 Conclusión

✅ Hoy hemos resuelto ejercicios con bases de datos SQLite en Python.
✅ Estos ejercicios permiten gestionar información almacenada en una base de datos.
✅ Practica modificando el código para entenderlo mejor.

📌 Próximo post: Cómo conectar SQLite con una aplicación web en Python.

📂 Descarga los ejercicios en mi GitHub: github.com/josecodetech

🎥 Aprende con mis videos en YouTube: https://www.youtube.com/@josecodetech

💬 ¿Qué tipo de datos te gustaría gestionar en SQLite? Coméntamelo.