🎮 Volver al juego ✉️ Contacto
📖

Manual de Python

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

📚

Cómo usar este manual

💡 La regla de oro: no aprendas Python solo leyendo. Escribe cada ejemplo, cámbialo, rómpelo y arréglalo. ¡Programar se aprende programando!
🖥️

Instala Python en tu PC

¿Quieres escribir programas de verdad en tu ordenador? Solo necesitas 10 minutos:

1️⃣ Instala Python

  1. Entra en python.org → Descargas → descarga Python 3.
  2. Instálalo. ⚠️ En Windows, marca la casilla «Add python.exe to PATH» antes de darle a Instalar.
  3. Comprueba que funciona: abre una terminal y escribe python --version. Deberías ver algo como Python 3.12.0.

2️⃣ Instala un editor (VS Code)

  1. Descarga Visual Studio Code (gratis) desde code.visualstudio.com.
  2. Instala la extensión Python de Microsoft (pestaña de extensiones).

3️⃣ Tu primer archivo

  1. Crea un archivo hola.py y escribe: print("Hola desde mi PC")
  2. Ejecútalo con el botón ▶ de VS Code o con python hola.py en la terminal.
💡 A partir de aquí, prueba todos los ejemplos de este manual y los mini-proyectos del capítulo 13 en tu propio ordenador. ¡Ese es el verdadero siguiente nivel! 🚀
📗 · PARTE 1 — FUNDAMENTOS ·
1

Tu primer programa

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.

🖨️ print(): mostrar cosas en pantalla

La función print() muestra un mensaje. El texto (llamado string) va entre comillas:

print("Hola, mundo")
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")
Las comillas simples también sirven 42 Tengo 25 años

💬 Comentarios: notas para humanos

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
⚠️ Errores típicos: Print con mayúscula falla (Python distingue mayúsculas), y olvidar un paréntesis o una comilla da SyntaxError.
2

Variables y tipos de datos

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)
100 Ada
💡 Nombra tus variables en minúsculas y con guion bajo: puntos_totales. No pueden empezar por número ni llevar espacios o tildes.

📦 Los 4 tipos básicos

TipoNombreEjemplo
intEntero5, -3, 0
floatDecimal3.14, -0.5
strTexto"hola", 'x'
boolVerdadero/FalsoTrue, False

La función type() revela el tipo de cualquier valor:

print(type(3.14))
print(type("hola"))
<class 'float'> <class 'str'>

🔄 Convertir entre tipos

numero = int("42")      # texto → entero
texto = str(100)        # entero → texto
decimal = float("3.5")  # texto → decimal
print(numero + 8)       # 50
50
⚠️ "5" + 3 da error (TypeError): no puedes sumar texto y número. ¡Convierte primero!
3

Operadores

➕ Aritméticos

OperadorSignificadoEjemploResultado
+Suma5 + 27
-Resta5 - 23
*Multiplicación5 * 210
/División5 / 22.5
//División entera7 // 23
%Resto (módulo)7 % 21
**Potencia2 ** 38
💡 El módulo % es muy útil: n % 2 == 0 detecta si n es par. ¡Lo usarás en el jefe final!

⚖️ Comparación (devuelven True o False)

OperadorSignificadoEjemplo
==Igual a5 == 5 → True
!=Distinto de5 != 3 → True
> <Mayor / menor5 > 3 → True
>= <=Mayor/menor o igual5 >= 5 → True
⚠️ ¡El error más famoso! Comparar es == (doble igual), asignar es = (uno solo).

🔗 Lógicos: combinar condiciones

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
True True False

⚡ Atajos de asignación

puntos = 10
puntos += 5   # igual que: puntos = puntos + 5
puntos -= 3   # igual que: puntos = puntos - 3
puntos *= 2
print(puntos)  # 24
24
4

Textos: strings en profundidad

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
Hola, Ada jajaja 10

🧰 Métodos útiles (van con punto)

MétodoHaceEjemplo
.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
True False

✨ f-strings: mezclar texto y variables

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)
Hola, Ada. Tienes 150 puntos.

⌨️ input(): pedir datos al usuario

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}")
5

Decisiones: if, elif, else

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!")
Puedes entrar ¡Bienvenido!
⚠️ Dos reglas de oro: el if termina con dos puntos : y el bloque va indentado (4 espacios). Sin eso, Python se queja.

🔀 Varios caminos: elif y else

puntos = 75
if puntos >= 90:
    print("A")
elif puntos >= 60:
    print("B")
else:
    print("C")
B

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

💡 Puedes poner if dentro de otro if (anidados), pero no abuses: más de 2 niveles se vuelve difícil de leer.
6

Bucles: for y while

Los bucles repiten código sin que tengas que escribirlo mil veces.

🔁 for: repetir un nº conocido de veces

El compañero inseparable del for es range(), que genera secuencias de números:

for i in range(3):
    print(i)
0 1 2
⚠️ ¡Ojo! range(3) genera 0, 1, 2: empieza en 0 y excluye el final. Es la trampa más clásica.
UsoGenera
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)
h o l a

⏳ while: repetir MIENTRAS se cumpla algo

n = 3
while n > 0:
    print(n)
    n -= 1
print("¡Despegue!")
3 2 1 ¡Despegue!
⚠️ Si la condición del 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 y continue

for i in range(10):
    if i == 3:
        break
    print(i)
0 1 2
7

Listas

Una lista guarda varios valores ordenados entre corchetes [ ]:

frutas = ["manzana", "banana", "cereza"]
print(frutas)
print(len(frutas))  # cuántos elementos hay
['manzana', 'banana', 'cereza'] 3

🎯 Índices: acceder a un elemento

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
manzana banana cereza
💡 También puedes cortar trozos (slicing): frutas[0:2] → los dos primeros. El final se excluye, como en range().

🧰 Métodos más usados

MétodoHace
.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
[1, 2, 3, 4] True

🔁 Recorrer una lista

frutas = ["manzana", "banana", "cereza"]
for f in frutas:
    print(f"Hola, {f}")
Hola, manzana Hola, banana Hola, cereza
8

Tuplas y conjuntos

🔒 Tuplas: listas que no cambian

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
10

🎲 Sets (conjuntos): sin repetidos ni orden

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
{'rojo', 'azul'} True
💡 Truco famoso: list(set([1, 2, 2, 3])) → [1, 2, 3]. ¡Así se quitan duplicados de una lista!
9

Diccionarios

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"])
Ada 5

✏️ Añadir, cambiar y leer con seguridad

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
0 True
⚠️ jugador["vidas"] daría KeyError si la clave no existe. Usa .get(clave, valor_por_defecto) para evitar sustos.

🔁 Recorrer un diccionario

notas = {"mat": 9, "lengua": 7}
for materia, nota in notas.items():
    print(f"{materia}: {nota}")
mat: 9 lengua: 7
💡 .keys() da las claves, .values() los valores y .items() los pares. len() cuenta cuántos pares hay.
10

Funciones

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"))
Hola, Ada Hola, Pip

🖨️ return vs print (¡importantísimo!)

def doble(x):
    return x * 2

resultado = doble(5) + doble(3)
print(resultado)  # 10 + 6 = 16
16

⚙️ Varios parámetros y valores por defecto

def area(base, altura=1):  # altura vale 1 si no la pasas
    return base * altura

print(area(5, 3))  # 15
print(area(5))     # 5
15 5
💡 Las variables creadas dentro de una función solo existen ahí dentro (ámbito local). Si las necesitas fuera, devuélvelas con return.
11

Comprensión de listas

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)
[0, 1, 4, 9, 16]

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)
[0, 2, 4, 6, 8]
12

Errores y debugging 🐛

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'?

🚨 Los 6 errores más comunes

ErrorSignificaCausa típica
SyntaxErrorCódigo mal escritoFalta :, un paréntesis o una comilla
IndentationErrorIndentación incorrectaBloque sin sangrar o mezclando espacios y tabulador
NameErrorNombre desconocidoVariable con errata o usada antes de crearla
TypeErrorTipos incompatibles"5" + 3 (texto + número)
IndexErrorÍndice fuera de rangoLista de 3 elementos y pides [5]
ValueErrorValor inadecuadoint("hola"): no se puede convertir

🛡️ try/except: atrapar errores

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!")
¡Error atrapado!

Si el código del try falla, Python salta al except y el programa sigue vivo.

🔍 Técnicas de detective

  1. Lee el mensaje completo: dice la línea exacta del fallo.
  2. Imprime sospechosos: mete print(variable) para ver qué vale en cada punto.
  3. Comenta por partes: desactiva medio código con # para aislar el problema.
  4. Revisa lo clásico: ¿falta un :? ¿un ==? ¿la indentación?
13

Mini-proyectos: ¡a programar!

Ya conoces la teoría. Ahora úsalo todo junto con estos 3 programas completos. Cópialos, ejecútalos y modifícalos. 🚀

🎲 1. Adivina el número

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…")

🧮 2. Calculadora

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")

✅ 3. Lista de tareas

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")
💡 Retos extra: añade a la calculadora la potencia ** · haz que «Adivina el número» tenga máximo 3 intentos · permite borrar tareas con .pop().
📘 · PARTE 2 — SUBE DE NIVEL ·
14

Programación orientada a objetos (POO)

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:

🏗️ Crear una clase y objetos

class Perro:
    def __init__(self, nombre):
        self.nombre = nombre

mi_perro = Perro("Toby")
print(mi_perro.nombre)
Toby

⚙️ Métodos: lo que sabe hacer un objeto

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())
Coche en marcha

👯 Cada objeto tiene sus propios datos

class Robot:
    energia = 100

r1 = Robot()
r2 = Robot()
r1.energia = 50
print(r1.energia, r2.energia)
50 100

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.

⚠️ Los nombres de clase empiezan por mayúscula por convención: Perro, Coche. Y no olvides el self: ¡casi todos los errores POO de principiantes son por eso!
15

Módulos, pip y librerías 📦

¿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: dos formas

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"]))

🎲 El módulo random

FunciónHace
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)

📅 Otro ejemplo: fechas

from datetime import date
hoy = date.today()
print(hoy)       # ej: 2026-09-21
print(hoy.year)  # 2026

🌍 pip: la tienda de módulos

¿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
💡 Ya usaste módulos sin darte cuenta: random en el taller del bot 🤖 y telebot (instalado con pip). ¡Gran parte de programar es combinar piezas de otros!
⚠️ Instala solo módulos conocidos y necesarios. Y ojo: los import van arriba del archivo, antes de tu código.
16

Sube de nivel: herencia y *args 🚀

👪 Herencia: clases hijas

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
Toby ¡Guau!

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.

📦 *args: infinitos argumentos

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
10 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)
nombre: Ada nivel: 5
🔨 · PARTE 3 — PROYECTOS ·
17

Tu primera app: lista de tareas ✅

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.

🧩 Las 4 piezas de (casi) toda app

PiezaEn nuestra app
💾 DatosLista de diccionarios: {"texto": ..., "hecha": ...}
⚙️ LógicaFunciones: mostrar, añadir, completar, borrar
🖥️ InterfazMenú con while + input()
💿 GuardadoArchivo tareas.txt (¡lo nuevo de este capítulo!)

📄 Lo nuevo: archivos

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())
[ ] Comprar pan [x] Estudiar Python
ModoSignifica
"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
⚠️ El modo "w" vacía el archivo al abrirlo. Por eso nuestra app carga todo en memoria al empezar y guarda todo junto al salir.

🔨 Constrúyela conmigo, paso a paso

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.

🔨 Ir al taller: construye tu primera app

📦 El código completo (para curiosos)

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()

▶️ Cómo ejecutarla

  1. Guarda el código en un archivo llamado mis_tareas.py.
  2. Abre una terminal en esa carpeta y escribe python mis_tareas.py (o ábrelo en VS Code y pulsa ▶).
  3. Usa el menú: añade tareas, complétalas, sal… ¡y vuelve a entrar! Tus tareas seguirán ahí gracias a tareas.txt. 💾

🚀 Retos de ampliación

  1. Contador: al salir, muestra «Te quedan X pendientes» (cuenta las de hecha == False).
  2. Editar: añade la opción 6 para cambiar el texto de una tarea.
  3. Limpiar hechas: opción que borre de golpe todas las completadas (pista: comprensión con if).
  4. Prioridades: guarda también una prioridad ⭐ y ordénalas.
  5. ¡Sueña! ¿Y si fuera una app de notas, de gastos o de contraseñas? La estructura es la misma.
💡 Cuando domines esta app, ya sabes hacer programas que guardan datos. Tus próximos mundos por conquistar: interfaces con ventanas (CustomTkinter), webs (Flask). ¡Y ya tienes un taller para crear bots 🤖!
18

Tu primer bot de Telegram 🤖

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!

🤖 1. Crea tu bot con BotFather (5 min)

  1. Abre Telegram y busca @BotFather (el verificado ✓).
  2. Envíale /newbot y sigue sus preguntas: nombre y usuario terminado en bot (ej: mi_primer_bot_123_bot).
  3. Te dará un token (algo como 123456:ABC-DEF...). ¡Cópialo!
  4. Abre tu bot (te da un enlace t.me/...) y pulsa Iniciar.
⚠️ El token es la contraseña de tu bot: quien la tenga lo controla. No lo publiques, no lo subas a GitHub ni lo compartas en capturas.
🔐 Profesional: guarda el token en un archivo .env en vez de pegarlo en el código. Así nunca se te escapa al compartir o subir tu programa:

1️⃣ Crea un archivo llamado .env junto a mi_bot.py con tu token dentro:
TELEGRAM_TOKEN=123456:ABC-DEF...

2️⃣ Crea un archivo .gitignore con una línea que ponga .env (Git ignorará tu secreto para siempre).

3️⃣ Instala el lector de .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)
💡 Si 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.

📦 2. Instala la librería

En una terminal escribe: pip install pyTelegramBotAPI python-dotenv. En tu código telebot es el bot y dotenv lee tu secreto del .env.

🧠 3. La idea: decoradores que escuchan

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

🔨 Constrúyelo conmigo

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.

🤖 Ir al taller: construye tu primer bot

📦 El código completo

# 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()

▶️ Cómo ponerlo en marcha

  1. Guarda tu token en el archivo .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.
  2. Ejecuta python mi_bot.py y deja la terminal abierta (si la cierras, el bot se duerme 😴).
  3. Habla con tu bot en Telegram: /start, /dado, /suma 5 3…

🚀 Retos de ampliación

  1. /moneda: cara o cruz con random.choice(["cara", "cruz"]).
  2. /chiste: guarda una lista de chistes y envía uno al azar.
  3. Notas eternas: guárdalas en un archivo (¡como en el taller de la app!).
  4. Más charla: responde a «adiós», «quién eres» o tu nombre.
19

Tu primera web con Flask 🌐

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!

🧠 La idea en 30 segundos

📦 Instalación y hola mundo

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

🔨 Constrúyela conmigo

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.

🌐 Ir al taller: construye tu primera web

📦 El código completo

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>

▶️ Cómo ejecutarla y publicarla

  1. Crea la carpeta mi_web con los dos archivos y ejecuta python app.py.
  2. Abre localhost:5000. ¡Tu web vive! 🎉
  3. Para que la vea todo el mundo, súbela a un hosting gratuito (Render, PythonAnywhere…): cada uno tiene su guía paso a paso.

🚀 Retos de ampliación

  1. Memoria: guarda los mensajes en un archivo para no perderlos al reiniciar.
  2. API JSON: crea /api/mensajes que devuelva la lista con jsonify.
  3. Más páginas: añade /about contando quién eres.
⚡ · REPASO FINAL ·
⚡

Chuleta final

Todo el manual en una página. ¡Guárdala en favoritos! 🔖

TemaSintaxis
Imprimir / pedir datosprint("hola") · x = input("? ")
Comentario# esto lo ignora Python
Variable / tiposx = 5 · int float str bool
Convertirint("5") str(5) float("5")
Aritmética+ - * / // % **
Comparar== != > < >= <=
Lógicaand or not
Atajosx += 1 x -= 1 x *= 2
f-stringf"Hola, {nombre}"
Condicionalif …: / elif …: / else:
Bucle forfor i in range(5): · for x in lista:
Bucle whilewhile cond: · break · continue
Listal = [1, 2] · l[0] · l.append(3) · len(l)
Diccionariod = {"a": 1} · d["a"] · d.get("b", 0)
Funcióndef f(x): return x * 2
Comprensión[x**2 for x in range(5)]
Slicinglista[1:4] (coge del índice 1 al 3)
Atrapar errorestry: … except ValueError: …
Clase / objetoclass Perro: … · p = Perro("Toby")
Métododef ladrar(self): … · p.ladrar()
Ficherosopen("a.txt", "r") · modos r w a
Bot (telebot)@bot.message_handler(commands=["start"])
Módulosimport random · from x import y · pip install algo
Herenciaclass Perro(Animal):
*args / **kwargsdef f(*args, **kwargs):
Web (Flask)@app.route("/") · render_template(...)
Formulariosrequest.form["x"] · redirect("/")
💡 ¿Y ahora qué? Sigue practicando en PyQuest 🎮, ¡completa los talleres 🔨🤖, consigue las 3 estrellas en todos los niveles ⭐ y apunta a lo grande: interfaces con ventanas (Tkinter), web (Flask), datos (pandas) o IA. ¡El límite lo pones tú! 🚀