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

👉 Ejercicios Prácticos de Python: Manejo de Archivos y Datos

Después de aprender cómo leer, escribir y modificar archivos en Python, es hora de practicar con ejercicios reales y útiles.

Hoy resolveremos ejercicios sobre:
✔️ Leer y escribir archivos de texto (.txt)
✔️ Leer y escribir archivos CSV
✔️ Trabajar con JSON para almacenar datos estructurados
✔️ Ejemplo práctico explicado paso a paso

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

---

1️⃣ Ejercicio: Contar las Palabras en un Archivo de Texto

📍 Objetivo: Leer un archivo de texto y contar cuántas palabras tiene.

🔹 Código:

def contar_palabras(nombre_archivo):
    try:
        with open(nombre_archivo, "r") as archivo:
            contenido = archivo.read()
            palabras = contenido.split()
            print(f"El archivo tiene {len(palabras)} palabras.")
    except FileNotFoundError:
        print("❌ Error: El archivo no existe.")

# Prueba la función
contar_palabras("archivo.txt")

📌 Salida esperada (si el archivo tiene texto):

El archivo tiene 56 palabras.

✅ Se usa split() para dividir el texto en palabras.
✅ try-except evita que el programa se bloquee si el archivo no existe.

---

2️⃣ Ejercicio: Guardar una Lista en un Archivo CSV

📍 Objetivo: Escribir una lista de datos en un archivo CSV y luego leerlo.

🔹 Código:

import csv

datos = [
    ["Nombre", "Edad", "Ciudad"],
    ["José", 25, "Madrid"],
    ["Ana", 30, "Barcelona"],
    ["Carlos", 22, "Sevilla"]
]

# Guardar datos en CSV
with open("datos.csv", "w", newline="") as archivo:
    escritor = csv.writer(archivo)
    escritor.writerows(datos)

# Leer el archivo CSV
with open("datos.csv", "r") as archivo:
    lector = csv.reader(archivo)
    for fila in lector:
        print(fila)

📌 Salida esperada:

['Nombre', 'Edad', 'Ciudad']
['José', '25', 'Madrid']
['Ana', '30', 'Barcelona']
['Carlos', '22', 'Sevilla']

✅ Ideal para trabajar con datos tabulares en Python.

---

3️⃣ Ejercicio: Guardar y Leer Datos en un Archivo JSON

📍 Objetivo: Guardar información de usuarios en un archivo JSON y luego leerla.

🔹 Código:

import json

usuarios = [
    {"nombre": "José", "edad": 25, "ciudad": "Madrid"},
    {"nombre": "Ana", "edad": 30, "ciudad": "Barcelona"},
    {"nombre": "Carlos", "edad": 22, "ciudad": "Sevilla"}
]

# Guardar en JSON
with open("usuarios.json", "w") as archivo:
    json.dump(usuarios, archivo, indent=4)

# Leer el JSON
with open("usuarios.json", "r") as archivo:
    datos = json.load(archivo)
    print(datos)

📌 Salida esperada:

[
    {"nombre": "José", "edad": 25, "ciudad": "Madrid"},
    {"nombre": "Ana", "edad": 30, "ciudad": "Barcelona"},
    {"nombre": "Carlos", "edad": 22, "ciudad": "Sevilla"}
]

✅ JSON es ideal para trabajar con datos estructurados en Python.

---

4️⃣ Ejercicio: Buscar una Palabra en un Archivo

📍 Objetivo: Leer un archivo de texto y contar cuántas veces aparece una palabra específica.

🔹 Código:

def contar_ocurrencias(nombre_archivo, palabra):
    try:
        with open(nombre_archivo, "r") as archivo:
            contenido = archivo.read()
            cantidad = contenido.lower().count(palabra.lower())
            print(f"La palabra '{palabra}' aparece {cantidad} veces en el archivo.")
    except FileNotFoundError:
        print("❌ Error: El archivo no existe.")

# Prueba la función
contar_ocurrencias("archivo.txt", "Python")

📌 Salida esperada:

La palabra 'Python' aparece 3 veces en el archivo.

✅ count() cuenta la cantidad de veces que aparece una palabra en el texto.

---

5️⃣ Ejercicio: Registrar y Leer Notas de Estudiantes

📍 Objetivo: Escribir y leer registros de estudiantes en un archivo de texto.

🔹 Código:

def guardar_estudiante(nombre, nota):
    with open("estudiantes.txt", "a") as archivo:
        archivo.write(f"{nombre}, {nota}\n")

def leer_estudiantes():
    try:
        with open("estudiantes.txt", "r") as archivo:
            for linea in archivo:
                print(linea.strip())
    except FileNotFoundError:
        print("❌ Error: El archivo no existe.")

# Agregar estudiantes
guardar_estudiante("Carlos", 8.5)
guardar_estudiante("Ana", 9.0)

# Leer los datos
leer_estudiantes()

📌 Salida esperada:

Carlos, 8.5
Ana, 9.0

✅ Ejemplo útil para registrar datos y consultarlos después.

---

🚀 Conclusión

✅ Hoy hemos resuelto ejercicios con manejo de archivos en Python.
✅ Estos ejercicios ayudan a leer, escribir y manipular datos de forma eficiente.
✅ Practica modificando el código para entenderlo mejor.

📌 Próximo post: Más ejercicios avanzados con bases de datos en Python (SQLite).

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

🎥 Aprende con mis videos en YouTube: [Tu canal aquí]

💬 ¿Qué tipo de archivos sueles manejar en Python? Cuéntamelo en los comentarios.

👉 Manejo de Archivos en Python: Leer, Escribir y Modificar Información

El manejo de archivos en Python es fundamental para guardar y recuperar información de manera persistente. En este post, aprenderemos a:

✔️ Abrir y leer archivos en Python
✔️ Escribir y modificar archivos de texto
✔️ Diferencias entre modos de apertura (r, w, a)
✔️ Trabajar con archivos CSV y JSON
✔️ Ejemplo práctico explicado paso a paso

📌 Con estas técnicas, podrás almacenar y manipular datos de manera eficiente en Python.

---

1️⃣ Abrir y Leer un Archivo en Python

Para leer un archivo en Python, usamos la función open().

📌 Ejemplo: Leer todo el contenido de un archivo

with open("archivo.txt", "r") as archivo:
    contenido = archivo.read()
    print(contenido)

📌 Explicación:
✅ "archivo.txt" → Nombre del archivo que queremos leer.
✅ "r" → Indica que abrimos el archivo en modo lectura.
✅ with open(...) as archivo: → Asegura que el archivo se cierre automáticamente después de su uso.

📌 Ejemplo de salida (si el archivo contiene texto):

Hola, este es un archivo de prueba.

---

📍 Leer un Archivo Línea por Línea

Si queremos leer un archivo línea por línea, usamos .readlines().

with open("archivo.txt", "r") as archivo:
    for linea in archivo.readlines():
        print(linea.strip())  # strip() elimina espacios en blanco y saltos de línea

📌 Salida esperada:

Línea 1 del archivo
Línea 2 del archivo
Línea 3 del archivo

✅ Ideal para procesar archivos grandes línea por línea.

---

2️⃣ Escribir en un Archivo en Python

Para escribir en un archivo, usamos el modo "w" o "a".

📌 Diferencias entre modos de apertura:
✔️ "w" (write) → Sobrescribe el contenido del archivo.
✔️ "a" (append) → Agrega contenido sin borrar lo anterior.

📌 Ejemplo: Escribir en un archivo (sobreescribe el contenido anterior)

with open("archivo.txt", "w") as archivo:
    archivo.write("Este es un nuevo contenido.\n")
    archivo.write("Se sobrescribió el archivo.\n")

📌 Ejemplo: Agregar texto a un archivo sin borrar lo anterior

with open("archivo.txt", "a") as archivo:
    archivo.write("Esta es una línea nueva.\n")

📌 Explicación:
✅ Modo "w" sobrescribe el contenido existente.
✅ Modo "a" agrega nuevas líneas al archivo sin eliminar lo anterior.

---

3️⃣ Leer y Escribir Archivos CSV en Python

Los archivos CSV (Comma-Separated Values) son muy usados para almacenar datos estructurados.

📌 Ejemplo: Escribir un archivo CSV

import csv

with open("datos.csv", "w", newline="") as archivo:
    escritor = csv.writer(archivo)
    escritor.writerow(["Nombre", "Edad", "Ciudad"])
    escritor.writerow(["José", 25, "Madrid"])
    escritor.writerow(["María", 30, "Barcelona"])

📌 Ejemplo: Leer un archivo CSV

import csv

with open("datos.csv", "r") as archivo:
    lector = csv.reader(archivo)
    for fila in lector:
        print(fila)

📌 Salida esperada:

['Nombre', 'Edad', 'Ciudad']
['José', '25', 'Madrid']
['María', '30', 'Barcelona']

✅ Ideal para trabajar con datos estructurados en Python.

---

4️⃣ Trabajar con Archivos JSON en Python

Los archivos JSON (JavaScript Object Notation) permiten almacenar y compartir datos en formato estructurado.

📌 Ejemplo: Escribir un archivo JSON

import json

datos = {
    "nombre": "José",
    "edad": 25,
    "ciudad": "Madrid"
}

with open("datos.json", "w") as archivo:
    json.dump(datos, archivo, indent=4)

📌 Ejemplo: Leer un archivo JSON

import json

with open("datos.json", "r") as archivo:
    datos = json.load(archivo)
    print(datos)

📌 Salida esperada:

{'nombre': 'José', 'edad': 25, 'ciudad': 'Madrid'}

✅ JSON es ampliamente utilizado en APIs y bases de datos.

---

5️⃣ Ejemplo Completo: Registrar y Leer Notas de Estudiantes

📌 Guardar información de estudiantes en un archivo de texto:

def guardar_estudiante(nombre, nota):
    with open("estudiantes.txt", "a") as archivo:
        archivo.write(f"{nombre}, {nota}\n")

def leer_estudiantes():
    with open("estudiantes.txt", "r") as archivo:
        for linea in archivo:
            print(linea.strip())

# Agregar estudiantes
guardar_estudiante("Carlos", 8.5)
guardar_estudiante("Ana", 9.0)

# Leer los datos
leer_estudiantes()

📌 Salida esperada:

Carlos, 8.5
Ana, 9.0

✅ Ejemplo útil para registrar datos y consultarlos después.

---

🚀 Conclusión

✅ open() permite leer y escribir archivos de texto.
✅ CSV y JSON son formatos clave para almacenar datos estructurados.
✅ Modo "r", "w" y "a" determinan cómo se manipula un archivo.
✅ Manejar archivos es clave para cualquier aplicación real en Python.

📌 Próximo post: Ejercicios prácticos sobre manejo de archivos 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 archivos en Python? ¿Qué datos sueles almacenar? Cuéntamelo en los comentarios.