Dejé mi código corriendo y esto pasó... 🤯 DÍA 3/30: Automatización Real.

Ayer aprendimos a tomar decisiones (Lógica if). Hoy vamos a aprender a repetir esas decisiones automáticamente sin cansarnos.

Imagina que tienes que enviar 100 correos de bienvenida o procesar 1000 imágenes. ¿Lo harías uno por uno? No. Usas un bucle for.

Así de fácil es procesar una cola de tareas en Python (como la que ves en la imagen):

# 📦 Cola de paquetes de datos a procesar

cola_de_dispatch = ["Paquete_A", "Paquete_B", "Paquete_C"]

print("🚀 Iniciando secuencia de dispatch...")

# El bucle 'for' repite la acción por cada ítem

for paquete in cola_de_dispatch:

# Simulación de envío

print(f"📡 Enviando {paquete}...")

print("✅ Secuencia completada.")

💡 Tip de oro: La variable paquete dentro del bucle es temporal; solo existe mientras el bucle está corriendo y toma el valor del ítem actual. ¡Es magia pura para procesar listas!

📌 GUARDA este post para cuando necesites recordar cómo estructurar un bucle for.

👇 PREGUNTA TÉCNICA: Si la cola_de_dispatch estuviera vacía ([]), ¿qué imprimiría el bucle en pantalla? ¡Te leo!

✈️ Comparte esto con ese amigo que todavía hace todo a mano.

🚀 DÍA 1/30: De Cero a Backend Profesional. Todo imperio tecnológico empieza con una simple caja.

En programación, esa caja se llama Variable. Es el espacio en la memoria de tu servidor donde guardas la información vital de tu aplicación (como el nombre del usuario o su saldo).

Mira cómo se ve en Python (el lenguaje más limpio para empezar):

# 📦 Así guardamos datos reales:
nombre_usuario = "JoseCodeTech"
usuarios_activos = 1500
app_en_linea = True

print(f"Bienvenido {nombre_usuario}. Hay {usuarios_activos} conectados.")

Cero complicaciones, código que se lee casi como inglés. Si dominas esto, ya diste el primer paso para construir sistemas reales.

📌 GUARDA este post para armar tu propio glosario de programación.

👇 RETO DEL DÍA: ¿Cómo llamarías a la variable que guarde tu edad? Escríbelo en los comentarios (ej: mi_edad = 25) y te corrijo si hay error.

🚀 ¿Buscando talento o pidiendo un viaje a Mordor? La realidad del reclutamiento IT 💍

A los programadores, cada vez que queremos entrar en una nueva empresa, parece que se nos exige haber ido a Mordor a recuperar el Anillo Único, volver ilesos y, además, dominar tres lenguajes alienígenas. 🧝‍♂️🌋

Normalmente, quienes redactan las ofertas o los empresarios que buscan cubrir un puesto, no evalúan lo que el proyecto necesita de forma realista. Nos encontramos a diario con situaciones que debemos dejar de normalizar:

🔹 La paradoja del tiempo: Exigen 5 o más años de experiencia en tecnologías o frameworks que apenas llevan un par de años en el mercado. 🔹 El "Junior" Senior: Piden años demostrables y un stack tecnológico interminable para puestos que catalogan como Junior. 🔹 El desarrollador orquesta: Buscan que sepas de todo para contratar a menos personas, obligándote a cubrir el trabajo de un departamento entero sin la remuneración que correspondería.

💡 La clave está en la lógica, no en la sintaxis En los puestos tecnológicos, de programación o desarrollo, lo que realmente se debe valorar en un candidato es su lógica de programación, su capacidad de análisis y su habilidad para resolver problemas.

Da igual el lenguaje exacto en el que programes hoy. Si tienes una base sólida, entiendes cómo estructurar un flujo de datos y cómo diseñar una base de datos eficiente, puedes desenvolverte en la sintaxis de otros lenguajes. Solo se necesita revisar la documentación, un poco de tiempo y la práctica del trabajo diario.

En el mundo real, los desarrolladores no programamos de memoria. Nos apoyamos en la documentación oficial, buscadores, Inteligencia Artificial y la comunidad. El código se entiende, la lógica se aplica, y poco a poco el trabajo fluye con mayor soltura.

⚠️ El talento descartado Si las empresas no cambian su enfoque, seguirán quejándose de que "no encuentran talento". Hoy en día se descartan perfiles brillantes por no conocer un algoritmo de pizarra que jamás usarán en producción, por no tener experiencia en un framework residual, por la edad, o simplemente por sistemas automáticos (ATS) mal configurados. Si dieran la oportunidad, verían el inmenso valor que estas personas pueden aportar.

👇 ¡Es hora de dejar de normalizar ofertas imposibles y empezar a valorar a los verdaderos solucionadores de problemas!

¿Qué consideras más efectivo para evaluar a un candidato en una prueba técnica: un desafío algorítmico puro (tipo LeetCode) o un proyecto pequeño que evalúe la arquitectura, la lógica del código y el diseño de la base de datos? ¡Te leo en los comentarios! 💬

🚀 ¡Domina Visual Studio Code como un profesional!

¿Sabías que Visual Studio Code es uno de los IDE más potentes y versátiles para programar?

En este curso gratuito en YouTube aprenderás desde lo más básico hasta configuraciones avanzadas para trabajar con cualquier lenguaje.

💻 En este curso aprenderás a:

✅ Configurar correctamente el entorno de desarrollo

✅ Instalar y usar extensiones esenciales

✅ Personalizar la interfaz y los atajos

✅ Integrar Git y GitHub directamente en VS Code

✅ Mejorar tu productividad al programar

🎓 Ideal para estudiantes de DAM, DAW, programadores autodidactas o cualquier persona que quiera dominar este entorno profesional.

📺 Accede gratis al curso completo aquí:

👉 https://www.youtube.com/watch?v=S2o4lXrRUE0&list=PLhr9YdZStgI0NXZQ_dne2mVLrPo4YF-L_

🔥 ¡Aprende a dominar tu entorno de programación y lleva tu código al siguiente nivel!

👉 Autenticación de APIs en Flask con JWT (JSON Web Tokens)

Después de implementar autenticación con sesiones en Flask, es momento de aprender una alternativa moderna y escalable: JWT (JSON Web Tokens). Ideal para APIs RESTful.

En este post aprenderás:
✔️ Qué es JWT y para qué se usa
✔️ Cómo generar y verificar tokens en Flask
✔️ Proteger rutas con decoradores
✔️ Ejemplo práctico paso a paso

📌 JWT es ampliamente usado en APIs modernas por su seguridad y portabilidad.

---

1️⃣ ¿Qué es JWT?

JWT (JSON Web Token) es un estándar para transmitir información de forma segura entre dos partes.

📌 Se compone de 3 partes codificadas en base64:

• Header (tipo y algoritmo)

• Payload (datos del usuario)

• Signature (clave secreta)

✅ Es útil para autenticar usuarios sin necesidad de sesiones.

---

2️⃣ Instalar dependencias

pip install flask flask_sqlalchemy pyjwt

También usaremos werkzeug.security para manejar contraseñas:

from werkzeug.security import generate_password_hash, check_password_hash

---

3️⃣ Generar el token JWT al iniciar sesión

import jwt
from datetime import datetime, timedelta
from flask import Flask, request, jsonify

app = Flask(__name__)
app.config["SECRET_KEY"] = "clave_super_segura"

def generar_token(usuario_id):
    payload = {
        "usuario_id": usuario_id,
        "exp": datetime.utcnow() + timedelta(hours=1)
    }
    token = jwt.encode(payload, app.config["SECRET_KEY"], algorithm="HS256")
    return token

---

4️⃣ Ruta de Login para devolver un JWT

@app.route("/login", methods=["POST"])
def login():
    datos = request.json
    usuario = Usuario.query.filter_by(email=datos["email"]).first()
    
    if usuario and check_password_hash(usuario.password, datos["password"]):
        token = generar_token(usuario.id)
        return jsonify({"token": token})
    
    return jsonify({"error": "Credenciales inválidas"}), 401

📌 Salida esperada:

{
  "token": "eyJhbGciOiJIUzI1NiIsInR..."
}

---

5️⃣ Proteger rutas con un decorador personalizado

from functools import wraps

def token_requerido(f):
    @wraps(f)
    def decorador(*args, **kwargs):
        token = request.headers.get("Authorization")
        if not token:
            return jsonify({"error": "Token requerido"}), 403
        
        try:
            datos = jwt.decode(token, app.config["SECRET_KEY"], algorithms=["HS256"])
            usuario = Usuario.query.get(datos["usuario_id"])
        except:
            return jsonify({"error": "Token inválido o expirado"}), 403
        
        return f(usuario, *args, **kwargs)
    return decorador

---

6️⃣ Ruta protegida usando el token

@app.route("/perfil")
@token_requerido
def perfil(usuario):
    return jsonify({
        "usuario": usuario.username,
        "email": usuario.email
    })

✅ Si el token es válido, se accede al perfil del usuario autenticado.

---

7️⃣ Cómo enviar el token desde el cliente

📌 En las peticiones protegidas, se debe incluir el token:

GET /perfil HTTP/1.1  
Authorization: eyJhbGciOiJIUzI1NiIsInR...

✅ Esto permite que el backend valide al usuario sin usar cookies ni sesiones.

---

🚀 Conclusión

✅ JWT es ideal para autenticar usuarios en APIs REST.
✅ Protege tus rutas con decoradores y claves secretas.
✅ A diferencia de Flask-Login, JWT es stateless, perfecto para microservicios.

📌 Próximo post: Cómo refrescar tokens JWT y controlar expiración.

📂 Código en GitHub: github.com/josecodetech
🎥 Tutorial en YouTube: https://www.youtube.com/@josecodetech/

💬 ¿Ya usaste JWT? ¿Prefieres sesiones o tokens? Cuéntamelo 👇

👉 Cómo Desplegar una Aplicación Flask con SQLite en la Nube

Hemos desarrollado una aplicación web con Flask y SQLite. Ahora es momento de desplegarla en la nube para que cualquier persona pueda acceder a ella.

Hoy aprenderás:
✔️ Opciones para desplegar Flask en la nube
✔️ Cómo preparar la aplicación para producción
✔️ Usar Render o Railway para subir Flask con SQLite
✔️ Ejemplo paso a paso con un despliegue real

📌 Con este tutorial, podrás publicar tu aplicación Flask en internet.

---

1️⃣ Opciones para Desplegar Flask con SQLite

Existen varias opciones para hospedar una aplicación Flask en la nube. Algunas de las más recomendadas son:

✅ Render → Plataforma gratuita y fácil de usar para Flask y SQLite.
✅ Railway → Alternativa moderna con soporte para bases de datos.
✅ Heroku → Requiere configuraciones extra, pero es popular.
✅ VPS (Digital Ocean, AWS, Linode) → Más avanzado, pero con mayor control.

Hoy usaremos Render, ya que permite subir Flask con SQLite fácilmente.

---

2️⃣ Preparar la Aplicación Flask para Producción

Antes de desplegar, debemos crear un entorno virtual y configurar dependencias.

📌 Pasos previos:

1️⃣ Crea un entorno virtual en la carpeta de tu proyecto:

python -m venv venv
source venv/bin/activate  # En Mac/Linux
venv\Scripts\activate  # En Windows

2️⃣ Instala Flask y dependencias necesarias:

pip install flask gunicorn

3️⃣ Crea un archivo requirements.txt con las dependencias:

pip freeze > requirements.txt

📌 Este archivo es necesario para que Render instale las dependencias automáticamente.

---

3️⃣ Subir la Aplicación a GitHub

Para desplegar en Render, primero necesitamos subir el proyecto a GitHub.

📌 Pasos para subir el código a un repositorio:

git init
git add .
git commit -m "Primera versión de la app Flask"
git branch -M main
git remote add origin https://github.com/tuusuario/tu-repositorio.git
git push -u origin main

✅ Ahora el código está en GitHub y listo para ser desplegado.

---

4️⃣ Desplegar Flask con SQLite en Render

Render permite ejecutar Flask con bases de datos SQLite fácilmente.

📌 Pasos para el despliegue:

1️⃣ Ve a Render y crea una cuenta.
2️⃣ En New Web Service, selecciona tu repositorio de GitHub.
3️⃣ En Build Command, escribe:

pip install -r requirements.txt

4️⃣ En Start Command, escribe:

gunicorn -b 0.0.0.0:10000 app:app

5️⃣ Configura el puerto en 10000 y despliega la aplicación.

📌 Después del proceso, tu aplicación Flask estará en línea.

✅ Ejemplo de URL:

https://mi-aplicacion-flask.onrender.com

---

5️⃣ Probar la Aplicación en Producción

📌 Para probar que funciona correctamente, visita:

https://mi-aplicacion-flask.onrender.com/tareas

Si todo está bien, deberías ver los datos de SQLite en JSON:

[
    {"id": 1, "descripcion": "Aprender Flask", "estado": "Pendiente"},
    {"id": 2, "descripcion": "Deploy con Render", "estado": "Completado"}
]

✅ Tu aplicación Flask con SQLite ahora está accesible en internet.

---

🚀 Conclusión

✅ Render permite desplegar Flask con SQLite fácilmente.
✅ Configurar dependencias y subir el código a GitHub es clave.
✅ Una vez en la nube, cualquier persona puede acceder a la API Flask.

📌 Próximo post: Cómo conectar Flask con una base de datos PostgreSQL en producción.

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

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

💬 ¿Has desplegado una aplicación Flask antes? ¿Qué plataforma usaste? Cuéntamelo.

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

👉 Bases de Datos en Python con SQLite: Cómo Almacenar y Consultar Datos

Cuando trabajamos con datos en Python, los archivos TXT, CSV o JSON pueden ser útiles, pero no siempre son la mejor opción. Para almacenar información de forma estructurada y eficiente, utilizamos bases de datos.

Hoy aprenderás:
✔️ ¿Qué es SQLite y por qué usarlo en Python?
✔️ Crear y conectar una base de datos SQLite
✔️ Crear, insertar y consultar datos en una tabla
✔️ Actualizar y eliminar registros
✔️ Ejemplo práctico paso a paso

📌 Al final del post, podrás manejar bases de datos en Python como un profesional.

---

1️⃣ ¿Qué es SQLite y por qué usarlo en Python?

SQLite es un gestor de bases de datos ligero, integrado en Python, que permite almacenar datos en un archivo .db sin necesidad de un servidor.

📌 Ventajas de SQLite:
✅ No necesita configuración extra, ya viene con Python.
✅ Almacena datos en un solo archivo .db.
✅ Soporta SQL para manejar datos de forma eficiente.
✅ Es ideal para pequeñas aplicaciones y pruebas.

Para usar SQLite en Python, solo necesitamos importar sqlite3.

---

2️⃣ Crear y Conectar una Base de Datos SQLite

El primer paso es crear o conectar una base de datos SQLite.

📌 Código para conectar o crear una base de datos:

import sqlite3

conexion = sqlite3.connect("mi_base_de_datos.db")  # Crea o abre el archivo de la BD
cursor = conexion.cursor()  # Permite ejecutar comandos SQL

print("Base de datos conectada correctamente.")

conexion.close()  # Cierra la conexión

📌 Explicación:
✅ sqlite3.connect("mi_base_de_datos.db") → Crea un archivo de base de datos si no existe.
✅ cursor = conexion.cursor() → Permite ejecutar consultas SQL.
✅ conexion.close() → Cierra la conexión cuando terminamos.

---

3️⃣ Crear una Tabla en SQLite

Para guardar datos en la base de datos, necesitamos crear una tabla.

📌 Ejemplo: Crear una tabla usuarios en la base de datos:

import sqlite3

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

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

conexion.commit()  # Guarda los cambios
conexion.close()
print("Tabla creada exitosamente.")

📌 Explicación:
✅ CREATE TABLE IF NOT EXISTS usuarios → Crea la tabla si no existe.
✅ id INTEGER PRIMARY KEY AUTOINCREMENT → Identificador único que se incrementa automáticamente.
✅ nombre TEXT → Almacena texto.
✅ edad INTEGER → Almacena números enteros.
✅ email TEXT → Almacena correos electrónicos.
✅ commit() → Guarda los cambios en la base de datos.

---

4️⃣ Insertar Datos en una Base de Datos SQLite

Ahora que tenemos la tabla, podemos insertar registros.

📌 Ejemplo: Insertar un usuario en la base de datos:

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

cursor.execute("INSERT INTO usuarios (nombre, edad, email) VALUES (?, ?, ?)", 
               ("José", 25, "jose@example.com"))

conexion.commit()
conexion.close()
print("Usuario agregado exitosamente.")

📌 Explicación:
✅ INSERT INTO usuarios (...) VALUES (?, ?, ?) → Inserta datos en la tabla.
✅ Los signos ? evitan ataques SQL Injection.
✅ conexion.commit() → Guarda los cambios.

📌 Para insertar múltiples registros:

datos = [
    ("Ana", 30, "ana@example.com"),
    ("Carlos", 28, "carlos@example.com"),
    ("Laura", 22, "laura@example.com")
]

cursor.executemany("INSERT INTO usuarios (nombre, edad, email) VALUES (?, ?, ?)", datos)
conexion.commit()
print("Usuarios agregados.")

✅ Ideal para insertar muchos datos al mismo tiempo.

---

5️⃣ Consultar Datos en SQLite

📌 Ejemplo: Leer y mostrar todos los usuarios de la base de datos:

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

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

for usuario in usuarios:
    print(usuario)

conexion.close()

📌 Salida esperada:

(1, 'José', 25, 'jose@example.com')
(2, 'Ana', 30, 'ana@example.com')
(3, 'Carlos', 28, 'carlos@example.com')

✅ fetchall() recupera todos los registros.
✅ El resultado es una lista de tuplas con los datos.

📌 Para buscar un usuario específico:

cursor.execute("SELECT * FROM usuarios WHERE nombre = ?", ("Carlos",))
usuario = cursor.fetchone()
print(usuario)

✅ fetchone() devuelve un solo resultado.

---

6️⃣ Actualizar y Eliminar Datos en SQLite

📌 Ejemplo: Actualizar la edad de un usuario:

cursor.execute("UPDATE usuarios SET edad = ? WHERE nombre = ?", (26, "José"))
conexion.commit()
print("Edad actualizada.")

📌 Ejemplo: Eliminar un usuario:

cursor.execute("DELETE FROM usuarios WHERE nombre = ?", ("Ana",))
conexion.commit()
print("Usuario eliminado.")

✅ Siempre usa commit() después de UPDATE o DELETE.

---

🚀 Conclusión

✅ SQLite permite almacenar datos de forma estructurada en Python.
✅ Podemos crear, insertar, actualizar y eliminar registros usando SQL.
✅ Ideal para proyectos pequeños y medianos sin necesidad de un servidor externo.

📌 Próximo post: Ejercicios prácticos con bases de datos SQLite en Python.

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

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

💬 ¿Ya has trabajado con bases de datos en Python? ¿Cuál ha sido tu experiencia? Coméntamelo.