Los tutoriales te enseñan la sintaxis. Los proyectos te enseñan a programar. La diferencia entre alguien que lleva meses "aprendiendo" sin avanzar y alguien que progresa rápido casi siempre es esta: el segundo construye cosas. No importa que sean pequeñas o imperfectas. Lo que importa es que enfrentas problemas reales, buscas soluciones tú solo y acabas con algo funcionando.
Estos diez proyectos están ordenados por dificultad creciente. Cada uno introduce conceptos nuevos que se acumulan sobre los anteriores. Puedes hacerlos en Python, JavaScript o cualquier lenguaje que estés aprendiendo: la lógica es la misma.
1. Calculadora de línea de comandos
Lo que aprendes: entrada/salida de datos, variables, operadores, condicionales, bucles y manejo básico de errores.
Es el primer proyecto real porque te obliga a pensar en qué pasa cuando el usuario hace algo inesperado: ¿qué ocurre si introduce letras en lugar de números? ¿Y si divide entre cero? Manejar esos casos es programar de verdad.
# Python: calculadora interactiva en la terminal
def calcular(a, operador, b):
if operador == "+":
return a + b
elif operador == "-":
return a - b
elif operador == "*":
return a * b
elif operador == "/":
if b == 0:
raise ValueError("No se puede dividir entre cero")
return a / b
else:
raise ValueError(f"Operador desconocido: {operador}")
print("Calculadora (escribe 'salir' para terminar)")
while True:
entrada = input("\n> ").strip()
if entrada.lower() == "salir":
break
try:
partes = entrada.split()
if len(partes) != 3:
print("Formato: número operador número (ej: 5 + 3)")
continue
a = float(partes[0])
operador = partes[1]
b = float(partes[2])
resultado = calcular(a, operador, b)
print(f"= {resultado}")
except ValueError as e:
print(f"Error: {e}")
Mejoras para ir más lejos: añadir historial de operaciones, guardar el historial en un archivo de texto, implementar paréntesis y orden de operaciones.
2. Generador de contraseñas seguras
Lo que aprendes: módulos de la librería estándar, funciones con parámetros, manipulación de strings y listas.
Es un proyecto útil desde el primer día y lo puedes usar tú mismo. Te introduce al concepto de tomar decisiones en el código (¿incluir mayúsculas? ¿símbolos?) y de generar resultados aleatorios de forma controlada.
import random
import string
def generar_contrasena(
longitud: int = 16,
mayusculas: bool = True,
numeros: bool = True,
simbolos: bool = True
) -> str:
caracteres = string.ascii_lowercase # siempre incluye minúsculas
if mayusculas:
caracteres += string.ascii_uppercase
if numeros:
caracteres += string.digits
if simbolos:
caracteres += "!@#$%^&*()-_=+"
if not caracteres:
raise ValueError("Debes incluir al menos un tipo de carácter")
# Garantizar al menos uno de cada tipo seleccionado
contrasena = []
if mayusculas:
contrasena.append(random.choice(string.ascii_uppercase))
if numeros:
contrasena.append(random.choice(string.digits))
if simbolos:
contrasena.append(random.choice("!@#$%^&*()-_=+"))
# Rellenar el resto
while len(contrasena) < longitud:
contrasena.append(random.choice(caracteres))
random.shuffle(contrasena)
return "".join(contrasena)
# Generar varias opciones
for _ in range(5):
print(generar_contrasena(longitud=20))
Mejoras para ir más lejos: crear una interfaz web sencilla con HTML+JavaScript, añadir un indicador de fortaleza de la contraseña, copiar al portapapeles automáticamente.
3. Lista de tareas con almacenamiento en archivo
Lo que aprendes: leer y escribir archivos, trabajar con JSON, funciones, listas y diccionarios.
Este proyecto es el salto de "el programa vive mientras se ejecuta" a "el programa recuerda lo que hiciste". Persistir datos en un archivo introduce uno de los conceptos más importantes del desarrollo: el estado que sobrevive entre sesiones.
import json
import os
ARCHIVO = "tareas.json"
def cargar_tareas():
if not os.path.exists(ARCHIVO):
return []
with open(ARCHIVO, "r", encoding="utf-8") as f:
return json.load(f)
def guardar_tareas(tareas):
with open(ARCHIVO, "w", encoding="utf-8") as f:
json.dump(tareas, f, indent=2, ensure_ascii=False)
def mostrar_tareas(tareas):
if not tareas:
print("No hay tareas.")
return
for i, tarea in enumerate(tareas, 1):
estado = "✓" if tarea["hecha"] else "○"
print(f" {i}. [{estado}] {tarea['texto']}")
tareas = cargar_tareas()
while True:
print("\n── Tareas ──────────────────")
mostrar_tareas(tareas)
print("\nagregar / completar / eliminar / salir")
accion = input("> ").strip().lower()
if accion == "agregar":
texto = input("Nueva tarea: ").strip()
if texto:
tareas.append({"texto": texto, "hecha": False})
guardar_tareas(tareas)
elif accion == "completar":
mostrar_tareas(tareas)
try:
num = int(input("Número de tarea: ")) - 1
tareas[num]["hecha"] = True
guardar_tareas(tareas)
except (ValueError, IndexError):
print("Número inválido")
elif accion == "eliminar":
mostrar_tareas(tareas)
try:
num = int(input("Número de tarea: ")) - 1
eliminada = tareas.pop(num)
guardar_tareas(tareas)
print(f"Eliminada: {eliminada['texto']}")
except (ValueError, IndexError):
print("Número inválido")
elif accion == "salir":
break
Mejoras para ir más lejos: añadir fechas de vencimiento, categorías, prioridades, o migrar el almacenamiento de JSON a SQLite.
4. Juego de ahorcado
Lo que aprendes: lógica de juego, conjuntos, manipulación de strings, bucles con condiciones de salida múltiples.
Los juegos son motivadores porque el feedback es inmediato. El ahorcado te enseña a pensar en estados del programa (¿qué información necesito guardar?) y en la lógica de flujo (¿cuándo termina el juego? ¿quién gana?).
import random
PALABRAS = ["python", "algoritmo", "variable", "funcion", "bucle",
"diccionario", "recursion", "depurar", "compilar", "sintaxis"]
AHORCADO = [
"",
" |",
" |\n O",
" |\n O\n |",
" |\n O\n /|",
" |\n O\n /|\\",
" |\n O\n /|\\\n /",
" |\n O\n /|\\\n / \\",
]
def jugar():
palabra = random.choice(PALABRAS)
intentos = 7
adivinadas = set()
falladas = set()
while intentos > 0:
# Mostrar estado
mostrar = " ".join(c if c in adivinadas else "_" for c in palabra)
print(f"\n{AHORCADO[7 - intentos]}")
print(f"\n {mostrar}")
print(f" Fallos ({intentos} restantes): {' '.join(sorted(falladas)) or '-'}")
if "_" not in mostrar:
print(f"\n¡Ganaste! La palabra era: {palabra}")
return
letra = input("\n Letra: ").strip().lower()
if not letra or not letra.isalpha() or len(letra) != 1:
print(" Introduce una sola letra")
continue
if letra in adivinadas or letra in falladas:
print(" Ya intentaste esa letra")
continue
if letra in palabra:
adivinadas.add(letra)
print(" ¡Correcto!")
else:
falladas.add(letra)
intentos -= 1
print(" Incorrecto")
print(f"\n{AHORCADO[7]}")
print(f"\nPerdiste. La palabra era: {palabra}")
jugar()
Mejoras para ir más lejos: cargar palabras desde un archivo de texto, añadir categorías (animales, países, tecnología), mostrar una pista, registrar las puntuaciones.
5. Convertidor de divisas con API real
Lo que aprendes: hacer peticiones HTTP, consumir APIs REST, parsear JSON de respuestas reales, manejo de errores de red.
Este proyecto es el primer contacto con el mundo exterior: tu programa habla con un servidor real de internet. Es el momento en que la programación deja de ser un ejercicio abstracto.
import urllib.request
import json
# API gratuita: exchangerate-api.com (requiere registro para clave gratuita)
# Alternativa sin clave: open.er-api.com
def obtener_tasas(moneda_base: str = "USD") -> dict:
url = f"https://open.er-api.com/v6/latest/{moneda_base}"
try:
with urllib.request.urlopen(url, timeout=5) as resp:
datos = json.loads(resp.read().decode())
if datos["result"] != "success":
raise ValueError("La API devolvió un error")
return datos["rates"]
except Exception as e:
raise ConnectionError(f"No se pudieron obtener las tasas: {e}")
def convertir(cantidad: float, origen: str, destino: str, tasas: dict) -> float:
if origen not in tasas or destino not in tasas:
raise ValueError("Moneda no encontrada")
# Convertir a través de la moneda base (USD)
en_base = cantidad / tasas[origen]
return en_base * tasas[destino]
print("Convertidor de divisas")
print("Obteniendo tasas actualizadas...")
try:
tasas = obtener_tasas("USD")
print(f"Tasas cargadas ({len(tasas)} monedas disponibles)\n")
while True:
try:
entrada = input("Cantidad y moneda origen (ej: 100 EUR) o 'salir': ").strip()
if entrada.lower() == "salir":
break
partes = entrada.split()
cantidad = float(partes[0])
origen = partes[1].upper()
destino = input("Moneda destino (ej: MXN): ").strip().upper()
resultado = convertir(cantidad, origen, destino, tasas)
print(f"\n {cantidad} {origen} = {resultado:.2f} {destino}\n")
except (ValueError, IndexError) as e:
print(f" Error: {e}")
except ConnectionError as e:
print(f"Error de conexión: {e}")
Mejoras para ir más lejos: guardar un historial de conversiones, mostrar la variación respecto al día anterior, hacer una versión web con un formulario HTML.
6. Web scraper de precios
Lo que aprendes: scraping con BeautifulSoup, navegar el HTML de una página real, guardar datos en CSV, automatización.
El scraping abre una dimensión completamente nueva: puedes extraer datos de cualquier sitio web. Es también el primer proyecto donde tendrás que investigar por tu cuenta cómo está estructurado el HTML de la página que elijas.
# pip install requests beautifulsoup4
import requests
from bs4 import BeautifulSoup
import csv
from datetime import datetime
def scrapear_precios(url: str) -> list[dict]:
"""
Ejemplo con books.toscrape.com (sitio creado específicamente
para practicar scraping, sin restricciones legales).
"""
cabeceras = {
"User-Agent": "Mozilla/5.0 (compatible; bot-aprendizaje/1.0)"
}
respuesta = requests.get(url, headers=cabeceras, timeout=10)
respuesta.raise_for_status()
soup = BeautifulSoup(respuesta.text, "html.parser")
libros = []
for articulo in soup.select("article.product_pod"):
titulo = articulo.select_one("h3 a")["title"]
precio = articulo.select_one("p.price_color").text.strip()
rating_texto = articulo.select_one("p.star-rating")["class"][1]
disponible = articulo.select_one("p.availability").text.strip()
libros.append({
"titulo": titulo,
"precio": precio,
"valoracion": rating_texto,
"disponible": disponible,
"fecha": datetime.now().strftime("%Y-%m-%d %H:%M")
})
return libros
def guardar_csv(datos: list[dict], archivo: str):
if not datos:
return
with open(archivo, "w", newline="", encoding="utf-8") as f:
escritor = csv.DictWriter(f, fieldnames=datos[0].keys())
escritor.writeheader()
escritor.writerows(datos)
print(f"Guardados {len(datos)} registros en {archivo}")
url = "https://books.toscrape.com"
print(f"Scrapeando {url}...")
libros = scrapear_precios(url)
guardar_csv(libros, "libros.csv")
# Mostrar los 5 más baratos
ordenados = sorted(libros, key=lambda x: float(x["precio"].replace("£", "")))
print("\nLos 5 más baratos:")
for libro in ordenados[:5]:
print(f" {libro['precio']} {libro['titulo'][:50]}")
Mejoras para ir más lejos: programar el scraper para que se ejecute periódicamente y te avise cuando cambia el precio de algo concreto, paginar a través de varias páginas del sitio.
7. API REST con base de datos
Lo que aprendes: crear endpoints HTTP, operaciones CRUD, bases de datos SQL con SQLite, conceptos de backend.
Este es el salto al desarrollo backend. Crear una API que otro programa (o tú mismo desde el navegador) puede consultar es uno de los conceptos más empleables que puedes aprender.
# pip install fastapi uvicorn[standard]
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional
import sqlite3
app = FastAPI(title="API de Notas")
# Base de datos SQLite
def init_db():
con = sqlite3.connect("notas.db")
con.execute("""
CREATE TABLE IF NOT EXISTS notas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
contenido TEXT,
creada_en TEXT DEFAULT (datetime('now'))
)
""")
con.commit()
con.close()
init_db()
class NotaCrear(BaseModel):
titulo: str
contenido: Optional[str] = None
class Nota(NotaCrear):
id: int
creada_en: str
@app.get("/notas", response_model=list[Nota])
def listar_notas():
con = sqlite3.connect("notas.db")
con.row_factory = sqlite3.Row
notas = con.execute("SELECT * FROM notas ORDER BY creada_en DESC").fetchall()
con.close()
return [dict(n) for n in notas]
@app.post("/notas", response_model=Nota, status_code=201)
def crear_nota(nota: NotaCrear):
con = sqlite3.connect("notas.db")
cur = con.execute(
"INSERT INTO notas (titulo, contenido) VALUES (?, ?)",
(nota.titulo, nota.contenido)
)
con.commit()
nueva = con.execute("SELECT * FROM notas WHERE id = ?", (cur.lastrowid,)).fetchone()
con.close()
return dict(nueva)
@app.delete("/notas/{id}", status_code=204)
def eliminar_nota(id: int):
con = sqlite3.connect("notas.db")
resultado = con.execute("DELETE FROM notas WHERE id = ?", (id,))
con.commit()
con.close()
if resultado.rowcount == 0:
raise HTTPException(status_code=404, detail="Nota no encontrada")
# Ejecutar: uvicorn main:app --reload
# Documentación automática en: http://localhost:8000/docs
Mejoras para ir más lejos: añadir autenticación básica, crear un frontend en HTML que consuma la API, añadir etiquetas y búsqueda por texto.
8. Bot de Telegram
Lo que aprendes: librerías de terceros, programación asíncrona, webhooks, lógica de conversación con estados.
Los bots son uno de los proyectos más satisfactorios porque los puedes compartir con otras personas inmediatamente. Ver a alguien usando algo que tú construiste es una motivación enorme.
# pip install python-telegram-bot
from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
import random
TOKEN = "TU_TOKEN_AQUI" # obtenerlo hablando con @BotFather en Telegram
# Respuestas automáticas simples
RESPUESTAS = {
"hola": ["¡Hola!", "¡Buenas!", "¡Hey!"],
"cómo estás": ["¡Muy bien, gracias!", "Funcionando a pleno rendimiento 🤖"],
"chiste": [
"¿Por qué los programadores prefieren el oscuro? Porque la luz atrae a los bugs. 🐛",
"Un SQL entra en un bar y le dice al camarero: '¿Me puedes dar una cerveza?'\nEl camarero: 'Claro, ¿necesitas un JOIN con algo?'",
],
}
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
await update.message.reply_text(
"¡Hola! Soy un bot de aprendizaje.\n"
"Comandos disponibles:\n"
"/frase — frase motivadora\n"
"/dado — lanzar un dado\n"
"O escríbeme algo y te respondo 😊"
)
async def frase(update: Update, context: ContextTypes.DEFAULT_TYPE):
frases = [
"El mejor momento para plantar un árbol fue hace 20 años. El segundo mejor momento es ahora.",
"No tienes que ser genial para empezar, pero tienes que empezar para ser genial.",
"El código que no existe no tiene bugs.",
]
await update.message.reply_text(random.choice(frases))
async def dado(update: Update, context: ContextTypes.DEFAULT_TYPE):
resultado = random.randint(1, 6)
caras = ["⚀", "⚁", "⚂", "⚃", "⚄", "⚅"]
await update.message.reply_text(f"{caras[resultado - 1]} Sacaste un {resultado}")
async def mensaje(update: Update, context: ContextTypes.DEFAULT_TYPE):
texto = update.message.text.lower()
for clave, respuestas in RESPUESTAS.items():
if clave in texto:
await update.message.reply_text(random.choice(respuestas))
return
await update.message.reply_text("No entendí eso, pero estoy aprendiendo 🤖")
app = Application.builder().token(TOKEN).build()
app.add_handler(CommandHandler("start", start))
app.add_handler(CommandHandler("frase", frase))
app.add_handler(CommandHandler("dado", dado))
app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, mensaje))
print("Bot iniciado...")
app.run_polling()
Mejoras para ir más lejos: conectar el bot a una API del tiempo, crear un bot recordatorio que guarde tareas en SQLite, añadir un sistema de puntuación para un juego de trivia.
9. Seguidor de hábitos con gráficas
Lo que aprendes: visualización de datos con matplotlib, manipulación de fechas, almacenamiento estructurado, pensar en la experiencia del usuario.
Este proyecto combina todo lo anterior y añade el componente visual. Ver una gráfica de tu propio progreso generada por código que tú escribiste es uno de los momentos más gratificantes de aprender a programar.
# pip install matplotlib
import json
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from datetime import date, timedelta
from pathlib import Path
ARCHIVO = "habitos.json"
def cargar() -> dict:
if Path(ARCHIVO).exists():
return json.loads(Path(ARCHIVO).read_text(encoding="utf-8"))
return {"habitos": [], "registros": {}}
def guardar(datos: dict):
Path(ARCHIVO).write_text(
json.dumps(datos, indent=2, ensure_ascii=False),
encoding="utf-8"
)
def registrar_hoy(datos: dict):
hoy = str(date.today())
if hoy not in datos["registros"]:
datos["registros"][hoy] = []
print(f"\nHábitos para hoy ({hoy}):")
completados = []
for habito in datos["habitos"]:
hecho = input(f" ¿Completaste '{habito}'? (s/n): ").strip().lower()
if hecho == "s":
completados.append(habito)
datos["registros"][hoy] = completados
guardar(datos)
print(f"Registrados {len(completados)}/{len(datos['habitos'])} hábitos")
def graficar(datos: dict, dias: int = 30):
if not datos["habitos"] or not datos["registros"]:
print("No hay datos para graficar")
return
hoy = date.today()
fechas = [hoy - timedelta(days=i) for i in range(dias - 1, -1, -1)]
fig, ax = plt.subplots(figsize=(12, 5))
for i, habito in enumerate(datos["habitos"]):
y = []
for f in fechas:
registro = datos["registros"].get(str(f), [])
y.append(i + 0.9 if habito in registro else None)
x_puntos = [f for f, v in zip(fechas, y) if v is not None]
y_puntos = [v for v in y if v is not None]
ax.scatter(x_puntos, y_puntos, s=100, label=habito, zorder=5)
ax.set_yticks(range(len(datos["habitos"])))
ax.set_yticklabels(datos["habitos"])
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m"))
ax.xaxis.set_major_locator(mdates.WeekdayLocator(interval=1))
plt.xticks(rotation=45)
ax.set_title(f"Seguimiento de hábitos — últimos {dias} días")
ax.grid(axis="x", alpha=0.3)
plt.tight_layout()
plt.savefig("habitos.png", dpi=150)
plt.show()
print("Gráfica guardada en habitos.png")
datos = cargar()
if not datos["habitos"]:
print("Añade tus primeros hábitos (uno por línea, vacío para terminar):")
while True:
h = input("> ").strip()
if not h:
break
datos["habitos"].append(h)
guardar(datos)
registrar_hoy(datos)
graficar(datos)
Mejoras para ir más lejos: calcular rachas consecutivas, enviar un resumen semanal por email o Telegram, crear una versión web con Chart.js.
10. Clon de una app sencilla
Lo que aprendes: integrar frontend y backend, autenticación de usuarios, despliegue en la nube, trabajo con una base de datos real.
El último proyecto es el más abierto: elige una app sencilla que uses y haz tu propia versión simplificada. Un acortador de URLs, un gestor de marcadores, un diario personal privado. No el clon completo: una versión mínima que funcione de verdad.
# Ejemplo: acortador de URLs (estructura del proyecto)
# Backend en FastAPI + SQLite
# Frontend en HTML + JavaScript vanilla
# Despliegue en Render.com (gratuito)
# Funcionalidades mínimas:
# 1. POST /acortar → recibe URL larga, devuelve código corto
# 2. GET /{codigo} → redirige a la URL original
# 3. GET /estadisticas/{codigo} → cuántas veces se usó
# Estructura:
acortador/
├── main.py # FastAPI app + endpoints
├── database.py # conexión SQLite + funciones CRUD
├── static/
│ └── index.html # formulario HTML para acortar URLs
├── requirements.txt
└── README.md
# El flujo completo:
# Usuario pega URL en el formulario HTML
# JS hace fetch() a POST /acortar
# FastAPI genera un código único (ej: "aB3xZ")
# Guarda (codigo, url_original, clicks=0) en SQLite
# Devuelve la URL corta al frontend
# Cuando alguien visita /aB3xZ:
# FastAPI busca el codigo en la BD
# Incrementa el contador de clicks
# Redirige con status 302
# Para desplegar gratis:
# - Render.com: conectar repositorio de GitHub, despliegue automático
# - Railway.app: alternativa similar
# - El despliegue real, con una URL pública que puedes compartir,
# transforma el proyecto de ejercicio a producto real
Por qué este proyecto importa: es el primero que puedes mostrar a alguien que no sabe programar y que lo entienda. Tiene una URL real, funciona en internet, resuelve un problema concreto. Eso es lo que distingue un portfolio de una colección de ejercicios.
Consejos para sacar el máximo a cada proyecto
- No copies el código: lee el ejemplo, entiéndelo, ciérralo y escríbelo tú desde cero. Aunque quede peor al principio, aprenderás el triple.
- Rómpe las cosas a propósito: una vez que funciona, cambia algo para ver qué pasa. Así aprendes los límites del sistema.
- Sube cada proyecto a GitHub, aunque sea imperfecto. El repositorio es tu portfolio y también es un registro de tu progreso.
- Añade un README que explique qué hace el proyecto, cómo ejecutarlo y qué aprendiste construyéndolo. Escribir eso consolida el aprendizaje.
- No busques la perfección: un proyecto terminado al 80% que funciona vale más que un proyecto perfecto que nunca acabas.
No hay comentarios todavía. Sé el primero en compartir tu opinión.