De cero a héroe: todo lo que necesitas para dominar los fundamentos de Python. Este manual acompaña al juego PyQuest — cada capítulo indica en qué nivel lo practicas. 🎮
¿Quieres escribir programas de verdad en tu ordenador? Solo necesitas 10 minutos:
python --version. Deberías ver algo como Python 3.12.0.hola.py y escribe: print("Hola desde mi PC")python hola.py en la terminal.Python es un lenguaje de programación famoso por ser fácil de leer: su código se parece al inglés. Se usa en videojuegos, inteligencia artificial, webs, ciencia y mucho más.
La función print() muestra un mensaje. El texto (llamado string) va entre comillas:
print("Hola, mundo")
Puedes usar comillas dobles "..." o simples '...', ambas valen. También puedes imprimir números y varias cosas separadas por comas:
print('Las comillas simples también sirven')
print(42)
print("Tengo", 25, "años")
Todo lo que va después de # lo ignora Python. Sirve para explicar tu código:
# Esto es un comentario, Python lo ignora
print("Esto sí se ejecuta") # comentario al final de la línea
Print con mayúscula falla (Python distingue mayúsculas), y olvidar un paréntesis o una comilla da SyntaxError.Una variable es una caja con nombre donde guardas un valor para usarlo después. Se crea con el signo =:
puntos = 100
nombre = "Ada"
print(puntos)
print(nombre)
puntos_totales. No pueden empezar por número ni llevar espacios o tildes.| Tipo | Nombre | Ejemplo |
|---|---|---|
int | Entero | 5, -3, 0 |
float | Decimal | 3.14, -0.5 |
str | Texto | "hola", 'x' |
bool | Verdadero/Falso | True, False |
La función type() revela el tipo de cualquier valor:
print(type(3.14))
print(type("hola"))
numero = int("42") # texto → entero
texto = str(100) # entero → texto
decimal = float("3.5") # texto → decimal
print(numero + 8) # 50
"5" + 3 da error (TypeError): no puedes sumar texto y número. ¡Convierte primero!| Operador | Significado | Ejemplo | Resultado |
|---|---|---|---|
+ | Suma | 5 + 2 | 7 |
- | Resta | 5 - 2 | 3 |
* | Multiplicación | 5 * 2 | 10 |
/ | División | 5 / 2 | 2.5 |
// | División entera | 7 // 2 | 3 |
% | Resto (módulo) | 7 % 2 | 1 |
** | Potencia | 2 ** 3 | 8 |
% es muy útil: n % 2 == 0 detecta si n es par. ¡Lo usarás en el jefe final!| Operador | Significado | Ejemplo |
|---|---|---|
== | Igual a | 5 == 5 → True |
!= | Distinto de | 5 != 3 → True |
> < | Mayor / menor | 5 > 3 → True |
>= <= | Mayor/menor o igual | 5 >= 5 → True |
== (doble igual), asignar es = (uno solo).edad = 20
tiene_entrada = True
print(edad >= 18 and tiene_entrada) # True: ambas se cumplen
print(edad < 18 or tiene_entrada) # True: al menos una se cumple
print(not tiene_entrada) # False: invierte el valor
puntos = 10
puntos += 5 # igual que: puntos = puntos + 5
puntos -= 3 # igual que: puntos = puntos - 3
puntos *= 2
print(puntos) # 24
Los strings sirven para mucho más que saludar. Puedes unirlos, repetirlos y medirlos:
saludo = "Hola, " + "Ada" # concatenar
eco = "ja" * 3 # repetir
print(saludo)
print(eco)
print(len(saludo)) # longitud: nº de caracteres
| Método | Hace | Ejemplo |
|---|---|---|
.upper() | Mayúsculas | "hola".upper() → HOLA |
.lower() | Minúsculas | "HoLa".lower() → hola |
.strip() | Quita espacios de los bordes | " x ".strip() → x |
.replace(a, b) | Sustituye texto | "hola".replace("o","0") → h0la |
.split(sep) | Divide en lista | "a,b".split(",") → ['a', 'b'] |
Y con in puedes comprobar si un texto contiene otro:
print("n" in "python") # True
print("x" in "python") # False
Pon una f antes de las comillas y mete variables entre {llaves}:
nombre = "Ada"
puntos = 150
mensaje = f"Hola, {nombre}. Tienes {puntos} puntos."
print(mensaje)
input() pausa el programa y espera que escribas algo. ⚠️ ¡Siempre devuelve texto! Convierte a número si lo necesitas:
nombre = input("¿Cómo te llamas? ")
edad = int(input("¿Cuántos años tienes? "))
print(f"Hola {nombre}, el año que viene tendrás {edad + 1}")
Con if tu programa decide: ejecuta un bloque de código solo si la condición es verdadera.
edad = 18
if edad >= 18:
print("Puedes entrar")
print("¡Bienvenido!")
if termina con dos puntos : y el bloque va indentado (4 espacios). Sin eso, Python se queja.puntos = 75
if puntos >= 90:
print("A")
elif puntos >= 60:
print("B")
else:
print("C")
Python prueba las ramas en orden y ejecuta solo la primera que sea verdadera. else es el plan B: se ejecuta si nada anterior cumplió.
if dentro de otro if (anidados), pero no abuses: más de 2 niveles se vuelve difícil de leer.Los bucles repiten código sin que tengas que escribirlo mil veces.
El compañero inseparable del for es range(), que genera secuencias de números:
for i in range(3):
print(i)
range(3) genera 0, 1, 2: empieza en 0 y excluye el final. Es la trampa más clásica.| Uso | Genera |
|---|---|
range(5) | 0, 1, 2, 3, 4 |
range(2, 6) | 2, 3, 4, 5 |
range(0, 10, 2) | 0, 2, 4, 6, 8 (de 2 en 2) |
El for también recorre textos y listas directamente:
for letra in "hola":
print(letra)
n = 3
while n > 0:
print(n)
n -= 1
print("¡Despegue!")
while nunca se vuelve False, el bucle es infinito y el programa se cuelga. Asegúrate de que algo cambie en cada vuelta (aquí, n -= 1).break → sale del bucle inmediatamente.continue → salta a la siguiente vuelta.for i in range(10):
if i == 3:
break
print(i)
Una lista guarda varios valores ordenados entre corchetes [ ]:
frutas = ["manzana", "banana", "cereza"]
print(frutas)
print(len(frutas)) # cuántos elementos hay
Cada posición tiene un número… ¡que empieza en 0! Y los negativos cuentan desde el final:
frutas = ["manzana", "banana", "cereza"]
print(frutas[0]) # primero
print(frutas[1]) # segundo
print(frutas[-1]) # último
frutas[0:2] → los dos primeros. El final se excluye, como en range().| Método | Hace |
|---|---|
.append(x) | Añade x al final |
.insert(i, x) | Inserta x en la posición i |
.remove(x) | Elimina la primera aparición de x |
.pop() | Saca y devuelve el último elemento |
.sort() | Ordena la lista |
.reverse() | Invierte el orden |
.count(x) / .index(x) | Cuenta apariciones / busca la posición |
nums = [3, 1, 2]
nums.append(4)
nums.sort()
print(nums)
print(2 in nums) # ¿está el 2? → True
frutas = ["manzana", "banana", "cereza"]
for f in frutas:
print(f"Hola, {f}")
Van entre paréntesis ( ). Una vez creadas, no se pueden modificar. Ideales para datos fijos (coordenadas, días…):
punto = (10, 20)
print(punto[0]) # 10
# punto[0] = 99 → ¡ERROR! Las tuplas son inmutables
Van entre llaves { }. Eliminan duplicados automáticamente:
colores = {"rojo", "azul", "rojo"}
print(colores) # {'rojo', 'azul'} → ¡sin repetidos!
colores.add("verde")
print("azul" in colores) # True
list(set([1, 2, 2, 3])) → [1, 2, 3]. ¡Así se quitan duplicados de una lista!Un diccionario guarda pares clave → valor entre llaves. Perfecto para fichas y datos con nombre:
jugador = {"nombre": "Ada", "nivel": 5, "vidas": 3}
print(jugador["nombre"])
print(jugador["nivel"])
jugador = {"nombre": "Ada", "nivel": 5}
jugador["nivel"] = 6 # modificar
jugador["puntos"] = 100 # añadir nuevo par
print(jugador.get("vidas", 0)) # .get: si no existe, devuelve 0 (sin error)
print("nivel" in jugador) # True
jugador["vidas"] daría KeyError si la clave no existe. Usa .get(clave, valor_por_defecto) para evitar sustos.notas = {"mat": 9, "lengua": 7}
for materia, nota in notas.items():
print(f"{materia}: {nota}")
.keys() da las claves, .values() los valores y .items() los pares. len() cuenta cuántos pares hay.Una función es un bloque reutilizable: recibe datos (parámetros), trabaja y puede devolver un resultado. Se crea con def:
def saludar(nombre):
return f"Hola, {nombre}"
print(saludar("Ada"))
print(saludar("Pip"))
print() → muestra algo en pantalla (para humanos). No sirve para calcular.return → devuelve un valor que el programa puede seguir usando.def doble(x):
return x * 2
resultado = doble(5) + doble(3)
print(resultado) # 10 + 6 = 16
def area(base, altura=1): # altura vale 1 si no la pasas
return base * altura
print(area(5, 3)) # 15
print(area(5)) # 5
return.La forma pitónica de crear listas en una sola línea. En vez de esto:
cuadrados = []
for x in range(5):
cuadrados.append(x ** 2)
…escribes esto (hace exactamente lo mismo):
cuadrados = [x ** 2 for x in range(5)]
print(cuadrados)
La fórmula es [expresión for variable in iterable]. ¡Y puedes añadir un filtro if!
pares = [x for x in range(10) if x % 2 == 0]
print(pares)
Todos los programadores cometen errores. La diferencia es que los buenos saben leerlos. Cuando Python falla, muestra un Traceback: léelo de abajo hacia arriba. La última línea dice qué pasó y dónde:
print(nombre)
# NameError: name 'nombre' is not defined. Did you mean: 'nombrar'?
| Error | Significa | Causa típica |
|---|---|---|
SyntaxError | Código mal escrito | Falta :, un paréntesis o una comilla |
IndentationError | Indentación incorrecta | Bloque sin sangrar o mezclando espacios y tabulador |
NameError | Nombre desconocido | Variable con errata o usada antes de crearla |
TypeError | Tipos incompatibles | "5" + 3 (texto + número) |
IndexError | Índice fuera de rango | Lista de 3 elementos y pides [5] |
ValueError | Valor inadecuado | int("hola"): no se puede convertir |
Con try puedes atrapar un error para que el programa no se cuelgue:
try:
numero = int("hola")
print("Todo bien")
except ValueError:
print("¡Error atrapado!")
Si el código del try falla, Python salta al except y el programa sigue vivo.
print(variable) para ver qué vale en cada punto.# para aislar el problema.:? ¿un ==? ¿la indentación?Ya conoces la teoría. Ahora úsalo todo junto con estos 3 programas completos. Cópialos, ejecútalos y modifícalos. 🚀
Usa: import, while, if/elif/else, input(), break.
import random
secreto = random.randint(1, 10)
intentos = 0
print("Adivina el número (del 1 al 10)")
while True:
numero = int(input("Tu número: "))
intentos += 1
if numero == secreto:
print(f"¡Correcto! Lo lograste en {intentos} intentos.")
break
elif numero < secreto:
print("Demasiado bajo…")
else:
print("Demasiado alto…")
Usa: input(), conversiones, if/elif/else.
a = float(input("Primer número: "))
op = input("Operación (+, -, *, /): ")
b = float(input("Segundo número: "))
if op == "+":
print(a + b)
elif op == "-":
print(a - b)
elif op == "*":
print(a * b)
elif op == "/":
print(a / b)
else:
print("Operación no válida")
Usa: listas, .append(), for, while True, f-strings.
tareas = []
while True:
print("\n1. Añadir 2. Ver 3. Salir")
opcion = input("Elige: ")
if opcion == "1":
tareas.append(input("Nueva tarea: "))
print("¡Añadida!")
elif opcion == "2":
if not tareas:
print("(sin tareas)")
for i in range(len(tareas)):
print(f"{i + 1}. {tareas[i]}")
elif opcion == "3":
print("¡Hasta luego!")
break
else:
print("Opción no válida")
** · haz que «Adivina el número» tenga máximo 3 intentos · permite borrar tareas con .pop().Hasta ahora usabas datos sueltos. La POO te permite crear tus propios tipos de datos que juntan datos y acciones. La idea en una frase:
class Perro:
def __init__(self, nombre):
self.nombre = nombre
mi_perro = Perro("Toby")
print(mi_perro.nombre)
class Perro: define el plano.__init__ es el constructor: se ejecuta solo al crear el objeto.self representa al propio objeto («yo mismo»). self.nombre = nombre guarda el dato dentro del objeto.Perro("Toby") construye un objeto; mi_perro.nombre lee su dato con un punto.Un método es una función dentro de la clase. Siempre recibe self como primer parámetro:
class Coche:
def __init__(self, marca):
self.marca = marca
def arrancar(self):
return "Coche en marcha"
mi_coche = Coche("Tesla")
print(mi_coche.arrancar())
class Robot:
energia = 100
r1 = Robot()
r2 = Robot()
r1.energia = 50
print(r1.energia, r2.energia)
Cambiar un dato de r1 no afecta a r2: cada objeto vive su propia vida. Por eso la POO es perfecta para videojuegos (jugadores, enemigos…), cada uno con su energía, posición, etc.
Perro, Coche. Y no olvides el self: ¡casi todos los errores POO de principiantes son por eso!¿Para qué reinventar la rueda? Un módulo es código que escribió otra persona y que puedes usar con import. Python trae cientos («baterías incluidas») y hay millones más en internet.
import random # 1. el módulo entero
print(random.randint(1, 10))
from random import choice # 2. solo lo que necesitas
print(choice(["cara", "cruz"]))
| Función | Hace |
|---|---|
randint(a, b) | Entero al azar entre a y b (ambos incluidos) |
choice(lista) | Elige un elemento al azar |
shuffle(lista) | Mezcla la lista (la modifica) |
from datetime import date
hoy = date.today()
print(hoy) # ej: 2026-09-21
print(hoy.year) # 2026
¿Necesitas algo que Python no trae (como telebot para el bot)? Se instala con pip en la terminal:
pip install pyTelegramBotAPI
pip list # ver lo instalado
random en el taller del bot 🤖 y telebot (instalado con pip). ¡Gran parte de programar es combinar piezas de otros!import van arriba del archivo, antes de tu código.Una clase puede heredar de otra: la hija recibe todo del padre gratis y puede mejorarlo. Se indica con paréntesis:
class Animal:
def __init__(self, nombre):
self.nombre = nombre
class Perro(Animal): # Perro hereda de Animal
def hablar(self):
return "¡Guau!"
p = Perro("Toby")
print(p.nombre) # heredado del padre
print(p.hablar()) # propio del hijo
Si la hija redefine un método del padre, se usa el suyo (override). Y con super() puedes llamar al método del padre desde la hija.
Con *args una función acepta tantos argumentos como quieras: Python los empaqueta en una tupla:
def sumar_todo(*numeros):
return sum(numeros)
print(sumar_todo(1, 2, 3, 4)) # 10
print(sumar_todo(5, 5)) # 10
Su primo **kwargs hace lo mismo con argumentos con nombre, empaquetados en un diccionario:
def ficha(**datos):
for clave, valor in datos.items():
print(f"{clave}: {valor}")
ficha(nombre="Ada", nivel=5)
Es hora de juntarlo TODO en un programa de verdad: una app de lista de tareas con menú, funciones y guardado en archivo. Si aún no tienes Python en tu PC, mira primero el capítulo 🖥️ Instala Python en tu PC.
| Pieza | En nuestra app |
|---|---|
| 💾 Datos | Lista de diccionarios: {"texto": ..., "hecha": ...} |
| ⚙️ Lógica | Funciones: mostrar, añadir, completar, borrar |
| 🖥️ Interfaz | Menú con while + input() |
| 💿 Guardado | Archivo tareas.txt (¡lo nuevo de este capítulo!) |
Con open() tu programa lee y escribe archivos. Siempre con with (se cierra solo) y encoding="utf-8" (para tildes y emojis):
# Escribir (modo "w" = write: crea el archivo o lo vacía)
with open("tareas.txt", "w", encoding="utf-8") as f:
f.write("[ ] Comprar pan\n")
f.write("[x] Estudiar Python\n")
# Leer (modo "r" = read)
with open("tareas.txt", "r", encoding="utf-8") as f:
for linea in f:
print(linea.strip())
| Modo | Significa |
|---|---|
"r" | Read: leer (falla si no existe → atrápalo con try/except FileNotFoundError) |
"w" | Write: escribir (crea el archivo o borra lo que había) |
"a" | Append: añadir al final sin borrar |
"w" vacía el archivo al abrirlo. Por eso nuestra app carga todo en memoria al empezar y guarda todo junto al salir.He preparado un taller interactivo: verás una demo funcionando, construirás la app en 6 pasos con mini-retos y al final descargarás tu mis_tareas.py listo para ejecutar.
Si prefieres ver el resultado final antes de empezar, aquí está mis_tareas.py entero:
# mis_tareas.py — ¡Mi primera app! 🎉
ARCHIVO = "tareas.txt"
def cargar_tareas():
tareas = []
try:
with open(ARCHIVO, "r", encoding="utf-8") as f:
for linea in f:
linea = linea.strip()
if linea:
hecha = linea.startswith("[x]")
texto = linea[3:].strip()
tareas.append({"texto": texto, "hecha": hecha})
except FileNotFoundError:
pass # primera vez: aún no hay archivo
return tareas
def guardar_tareas(tareas):
with open(ARCHIVO, "w", encoding="utf-8") as f:
for t in tareas:
marca = "[x]" if t["hecha"] else "[ ]"
f.write(f"{marca} {t['texto']}\n")
def mostrar_tareas(tareas):
if not tareas:
print("(sin tareas)")
return
for i in range(len(tareas)):
marca = "✓" if tareas[i]["hecha"] else "○"
print(f"{i + 1}. [{marca}] {tareas[i]['texto']}")
def pedir_numero(texto, maximo):
while True:
try:
n = int(input(texto))
if 1 <= n <= maximo:
return n
print(f"Escribe un número del 1 al {maximo}.")
except ValueError:
print("Eso no es un número, prueba otra vez.")
def main():
tareas = cargar_tareas()
print("=== MIS TAREAS ✅ ===")
while True:
print("\n1. Ver 2. Añadir 3. Completar 4. Borrar 5. Salir")
opcion = input("Elige: ")
if opcion == "1":
mostrar_tareas(tareas)
elif opcion == "2":
texto = input("Nueva tarea: ").strip()
if texto:
tareas.append({"texto": texto, "hecha": False})
print("¡Añadida!")
elif opcion == "3":
if not tareas:
print("(sin tareas)")
else:
mostrar_tareas(tareas)
n = pedir_numero("¿Cuál completaste? ", len(tareas))
tareas[n - 1]["hecha"] = True
print("¡Bien hecho! 🎉")
elif opcion == "4":
if not tareas:
print("(sin tareas)")
else:
mostrar_tareas(tareas)
n = pedir_numero("¿Cuál borras? ", len(tareas))
borrada = tareas.pop(n - 1)
print(f"Borrada: {borrada['texto']}")
elif opcion == "5":
guardar_tareas(tareas)
print("¡Hasta luego! Tus tareas están a salvo. 💾")
break
else:
print("Opción no válida.")
main()
mis_tareas.py.python mis_tareas.py (o ábrelo en VS Code y pulsa ▶).tareas.txt. 💾hecha == False).if).Vamos a crear un bot que vive en Telegram: responde a comandos (/start, /dado…), juega, suma y guarda notas. ¡Y hablarás con él desde tu móvil!
/newbot y sigue sus preguntas: nombre y usuario terminado en bot (ej: mi_primer_bot_123_bot).123456:ABC-DEF...). ¡Cópialo!t.me/...) y pulsa Iniciar..env en vez de pegarlo en el código. Así nunca se te escapa al compartir o subir tu programa:.env junto a mi_bot.py con tu token dentro:TELEGRAM_TOKEN=123456:ABC-DEF....gitignore con una línea que ponga .env (Git ignorará tu secreto para siempre)..env y úsalo así en tu código:pip install pyTelegramBotAPI python-dotenv
import os
from dotenv import load_dotenv
import telebot
load_dotenv() # lee el archivo .env
TOKEN = os.getenv("TELEGRAM_TOKEN")
bot = telebot.TeleBot(TOKEN)
TOKEN te sale vacío (None), tu .env está mal escrito o en otra carpeta: debe estar junto a mi_bot.py. Los otros talleres (app de tareas y web Flask) no usan secretos: no necesitan .env.En una terminal escribe: pip install pyTelegramBotAPI python-dotenv. En tu código telebot es el bot y dotenv lee tu secreto del .env.
Tu bot es un programa que pregunta sin parar «¿hay mensajes nuevos?» (bot.infinity_polling()). Con decoradores (esas líneas con @) dices qué función responde a cada cosa:
import telebot
bot = telebot.TeleBot("TU_TOKEN")
@bot.message_handler(commands=["start"]) # ← cuando escriban /start…
def saludar(mensaje): # …se ejecuta esta función
bot.reply_to(mensaje, "¡Hola! 🎉")
bot.infinity_polling() # ← escuchar sin parar
Cada mensaje trae datos útiles: mensaje.text (lo escrito) y mensaje.chat.id (quién lo escribe).
En el taller interactivo lo montamos en 5 pasos: primero chatea con una demo, luego añade comandos, juegos y memoria, y descarga tu mi_bot.py final.
# mi_bot.py — ¡Mi primer bot de Telegram! 🤖
import random
import telebot
TOKEN = "PON_AQUI_TU_TOKEN"
bot = telebot.TeleBot(TOKEN)
notas = {} # chat_id -> lista de notas
@bot.message_handler(commands=["start"])
def saludar(mensaje):
bot.reply_to(mensaje, "¡Hola! Soy tu primer bot 🎉\nEscribe /ayuda para ver lo que sé hacer.")
@bot.message_handler(commands=["ayuda"])
def ayuda(mensaje):
bot.reply_to(mensaje,
"Puedo hacer esto:\n"
"/start - Saludarme\n"
"/ayuda - Ver esta ayuda\n"
"/dado - Tirar un dado 🎲\n"
"/suma 5 3 - Sumar números ➕\n"
"/nota comprar pan - Guardar una nota 📝\n"
"/notas - Ver tus notas\n"
"Y si me hablas… ¡te respondo! 💬")
@bot.message_handler(commands=["dado"])
def dado(mensaje):
numero = random.randint(1, 6)
bot.reply_to(mensaje, f"🎲 ¡Un {numero}!")
@bot.message_handler(commands=["suma"])
def suma(mensaje):
try:
partes = mensaje.text.split()
a = float(partes[1])
b = float(partes[2])
bot.reply_to(mensaje, f"➕ {a} + {b} = {a + b}")
except (IndexError, ValueError):
bot.reply_to(mensaje, "Úsalo así: /suma 5 3")
@bot.message_handler(commands=["nota"])
def guardar_nota(mensaje):
texto = mensaje.text.replace("/nota", "", 1).strip()
if not texto:
bot.reply_to(mensaje, "Escribe algo: /nota comprar pan")
return
chat = mensaje.chat.id
if chat not in notas:
notas[chat] = []
notas[chat].append(texto)
bot.reply_to(mensaje, f"📝 Nota guardada ({len(notas[chat])} en total).")
@bot.message_handler(commands=["notas"])
def ver_notas(mensaje):
chat = mensaje.chat.id
if chat not in notas or not notas[chat]:
bot.reply_to(mensaje, "(sin notas)")
return
lineas = [f"{i + 1}. {n}" for i, n in enumerate(notas[chat])]
bot.reply_to(mensaje, "📝 Tus notas:\n" + "\n".join(lineas))
@bot.message_handler(func=lambda m: not m.text.startswith("/"), content_types=["text"])
def responder(mensaje):
texto = mensaje.text.lower()
if "hola" in texto:
bot.reply_to(mensaje, "¡Hola, humano! 👋")
elif "python" in texto:
bot.reply_to(mensaje, "¡Python es el mejor lenguaje! 🐍")
elif "gracias" in texto:
bot.reply_to(mensaje, "¡De nada! 😊")
else:
bot.reply_to(mensaje, f"Me has dicho: {mensaje.text}")
print("Bot en marcha… 🤖")
bot.infinity_polling()
.env (TELEGRAM_TOKEN=...) como se explica arriba — o, solo para probar rápido, pégalo en TOKEN = "..." — y guarda como mi_bot.py. Para compartir o subir tu código, usa siempre el .env.python mi_bot.py y deja la terminal abierta (si la cierras, el bot se duerme 😴)./start, /dado, /suma 5 3…random.choice(["cara", "cruz"]).Vamos a crear un muro de mensajes que funciona en el navegador: Python con Flask escucha peticiones y responde páginas. ¡El salto de programas para ti a apps para el mundo!
localhost:5000 («mi PC, puerta 5000»).@app.route(...) es una dirección: al visitarla, se ejecuta su función y devuelve una página.templates/) con huecos {{ ... }} que Python rellena.POST) que lees con request.form.En una terminal: pip install flask. Y esto ya es una web:
from flask import Flask
app = Flask(__name__)
@app.route("/")
def inicio():
return "<h1>¡Mi primera web con Python! 🐍</h1>"
if __name__ == "__main__":
app.run(debug=True)
Ejecuta python app.py, abre localhost:5000… ¡ahí está! 🎉 (debug=True recarga solo al guardar; se para con Ctrl + C.)
En el taller interactivo la montamos en 5 pasos: pruébala en un navegador simulado, añade rutas, plantillas, formularios y borrado, y descarga los archivos finales.
Estructura: app.py + carpeta templates/ con index.html dentro.
app.py:
# app.py — ¡Mi primera web con Flask! 🌐
from flask import Flask, render_template, request, redirect
app = Flask(__name__)
MENSAJES = ["¡Bienvenido al muro! 🎉"]
@app.route("/")
def inicio():
return render_template("index.html", mensajes=MENSAJES)
@app.route("/saludo/<nombre>")
def saludo(nombre):
return f"<h1>¡Hola, {nombre}! 👋</h1><p><a href='/'>Volver al muro</a></p>"
@app.route("/nuevo", methods=["POST"])
def nuevo():
texto = request.form.get("texto", "").strip()
if texto:
MENSAJES.append(texto)
return redirect("/")
@app.route("/borrar/<int:indice>", methods=["POST"])
def borrar(indice):
if 0 <= indice < len(MENSAJES):
MENSAJES.pop(indice)
return redirect("/")
if __name__ == "__main__":
app.run(debug=True)
templates/index.html:
<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="UTF-8">
<title>📌 Muro de mensajes</title>
<style>
body { font-family: system-ui, sans-serif; background: #0f172a; color: #f1f5f9; max-width: 600px; margin: 40px auto; padding: 0 16px; }
h1 { color: #ffd43b; }
.msg { background: #1e293b; border: 1px solid #334155; border-radius: 10px; padding: 10px 14px; margin: 8px 0; display: flex; justify-content: space-between; gap: 10px; }
form.add { display: flex; gap: 8px; margin: 16px 0; }
input[type=text] { flex: 1; padding: 10px; border-radius: 8px; border: 1px solid #334155; background: #0b1120; color: white; }
button { cursor: pointer; border: none; border-radius: 8px; padding: 10px 16px; font-weight: bold; background: #ffd43b; }
button.del { background: #ef4444; color: white; padding: 6px 12px; }
</style>
</head>
<body>
<h1>📌 Muro de mensajes</h1>
<form class="add" action="/nuevo" method="post">
<input type="text" name="texto" placeholder="Escribe un mensaje…" maxlength="140">
<button>Añadir</button>
</form>
{% for m in mensajes %}
<div class="msg">
<span>{{ m }}</span>
<form action="/borrar/{{ loop.index0 }}" method="post">
<button class="del">✕</button>
</form>
</div>
{% endfor %}
<p>Prueba también: <a href="/saludo/Ana" style="color:#ffd43b">/saludo/Ana</a></p>
</body>
</html>
mi_web con los dos archivos y ejecuta python app.py.localhost:5000. ¡Tu web vive! 🎉/api/mensajes que devuelva la lista con jsonify./about contando quién eres.Todo el manual en una página. ¡Guárdala en favoritos! 🔖
| Tema | Sintaxis |
|---|---|
| Imprimir / pedir datos | print("hola") · x = input("? ") |
| Comentario | # esto lo ignora Python |
| Variable / tipos | x = 5 · int float str bool |
| Convertir | int("5") str(5) float("5") |
| Aritmética | + - * / // % ** |
| Comparar | == != > < >= <= |
| Lógica | and or not |
| Atajos | x += 1 x -= 1 x *= 2 |
| f-string | f"Hola, {nombre}" |
| Condicional | if …: / elif …: / else: |
| Bucle for | for i in range(5): · for x in lista: |
| Bucle while | while cond: · break · continue |
| Lista | l = [1, 2] · l[0] · l.append(3) · len(l) |
| Diccionario | d = {"a": 1} · d["a"] · d.get("b", 0) |
| Función | def f(x): return x * 2 |
| Comprensión | [x**2 for x in range(5)] |
| Slicing | lista[1:4] (coge del índice 1 al 3) |
| Atrapar errores | try: … except ValueError: … |
| Clase / objeto | class Perro: … · p = Perro("Toby") |
| Método | def ladrar(self): … · p.ladrar() |
| Ficheros | open("a.txt", "r") · modos r w a |
| Bot (telebot) | @bot.message_handler(commands=["start"]) |
| Módulos | import random · from x import y · pip install algo |
| Herencia | class Perro(Animal): |
| *args / **kwargs | def f(*args, **kwargs): |
| Web (Flask) | @app.route("/") · render_template(...) |
| Formularios | request.form["x"] · redirect("/") |