100 Días de Código en Python — Día 84: Proyecto de portafolio — Tres en línea (Tic Tac Toe) en consola

📝 Contenido original del curso#

Usando lo que aprendiste de programación en Python, construye una versión de texto del juego Tres en línea (Tic Tac Toe). Debe poder jugarse en la línea de comandos, igual que el Blackjack del Día 11. Es un juego de 2 jugadores: uno es "X" y el otro "O".

Puedes ver cómo funciona el juego buscando "tic tac toe" en Google. Tú eliges cómo se ve: lo más simple es dibujar el tablero con los símbolos | y _, pero el diseño es tuyo. (El enunciado incluye una imagen de ejemplo de un tablero dibujado con esos símbolos.)

Si tienes más tiempo, rétate a construir un jugador de IA que juegue contra ti.

Pregunta de la tarea — Momento de reflexión: escribe cómo abordaste el proyecto; qué fue difícil y qué fácil; cómo mejorarías en el próximo; cuál fue tu mayor aprendizaje; y qué harías distinto si lo hicieras de nuevo.

Prerequisitos: variables y input() (Días 1–2), condicionales (Día 3), listas (Día 4), ciclos for y while (Día 5), funciones con parámetros y retorno (Días 8 y 10), el juego de consola del Día 11 (Blackjack), depuración (Día 13).

🔍 Antes de programar#

Diagrama de flujo del juego#

          ┌──────────────┐
          │ Crear tablero│
          │ turno = "X"  │
          └──────┬───────┘
                 ▼
     ┌───► Mostrar tablero
     │           ▼
     │     Pedir casilla ◄────────┐
     │           ▼                │
     │     ¿Es válida? ── No ─────┘ (mostrar el motivo)
     │           │ Sí
     │           ▼
     │     Colocar el símbolo
     │           ▼
     │     ¿Hay ganador? ── Sí ──► Anunciar ganador ──► FIN
     │           │ No
     │           ▼
     │     ¿Tablero lleno? ── Sí ──► Anunciar empate ──► FIN
     │           │ No
     │           ▼
     └──── Cambiar de turno

📝 Divide y vencerás: cada caja del diagrama se convierte en una función pequeña que puedes probar por separado. Es la misma estrategia del Blackjack (Día 11).

🎯 Objetivo de aprendizaje#

Elegir una estructura de datos adecuada para el tablero y justificar la elección.

📖 Explicación conceptual#

Hay varias formas válidas. Compararlas es parte del trabajo de un desarrollador:

En este tutorial usamos una lista de 9 elementos, numerada así para el jugador:

 1 | 2 | 3
---+---+---
 4 | 5 | 6
---+---+---
 7 | 8 | 9

🔎 Ejemplo explicado#

def crear_tablero():
    return [" "] * 9

def dibujar(tablero):
    filas = []
    for i in range(0, 9, 3):
        filas.append(f" {tablero[i]} | {tablero[i+1]} | {tablero[i+2]} ")
    return "\n---+---+---\n".join(filas)

print(dibujar(crear_tablero()))

• [" "] * 9 crea una lista con 9 espacios: todas las casillas vacías.
• range(0, 9, 3) produce 0, 3 y 6: el primer índice de cada fila.
• dibujar devuelve el texto en lugar de imprimirlo. Así puedes probarla (comparar el texto) y decidir después dónde mostrarlo.
• "\n---+---+---\n".join(filas) pone la línea separadora entre filas, no al final.

⚠️ Errores frecuentes#

🎯 Objetivo de aprendizaje#

Usar datos (una lista de tuplas) en lugar de código repetido para comprobar las 8 líneas ganadoras.

📖 Explicación conceptual#

Hay 8 formas de ganar: 3 filas, 3 columnas y 2 diagonales. Podrías escribir 8 condiciones, pero es fácil equivocarse en una. Mejor: guarda las 8 líneas como datos y recórrelas con un ciclo.

LINEAS = [
    (0, 1, 2), (3, 4, 5), (6, 7, 8),   # filas
    (0, 3, 6), (1, 4, 7), (2, 5, 8),   # columnas
    (0, 4, 8), (2, 4, 6),              # diagonales
]

def ganador(tablero):
    for a, b, c in LINEAS:
        if tablero[a] != " " and tablero[a] == tablero[b] == tablero[c]:
            return tablero[a]
    return None

Cómo funciona:

• for a, b, c in LINEAS desempaqueta cada tupla: en la primera vuelta, a = 0, b = 1, c = 2.
• tablero[a] == tablero[b] == tablero[c] es una comparación encadenada: equivale a tablero[a] == tablero[b] and tablero[b] == tablero[c].
• La condición tablero[a] != " " es imprescindible (ver errores frecuentes).
• Devuelve "X", "O" o None. Un valor que "significa nada" es más claro que devolver False o una cadena vacía.

Tu turno: escribe tablero_lleno(tablero), que devuelva True si no queda ninguna casilla vacía. Pista: el operador in (Día 4) la resuelve en una línea.

⚠️ Errores frecuentes#

Tres niveles de "inteligencia"#

📖 La idea de minimax#

La IA ("O") imagina cada jugada posible, luego cada respuesta del humano ("X"), y así hasta el final de la partida. A cada final le asigna un puntaje: +1 si gana O, −1 si gana X, 0 si hay empate. Supone que el rival juega lo mejor posible: en el turno de O se escoge el máximo; en el de X, el mínimo.

def minimax(tablero, turno):
    g = ganador(tablero)
    if g == "O":
        return 1
    if g == "X":
        return -1
    if tablero_lleno(tablero):
        return 0
    puntajes = []
    for i in range(9):
        if tablero[i] == " ":
            tablero[i] = turno                          # probar la jugada
            siguiente = "X" if turno == "O" else "O"
            puntajes.append(minimax(tablero, siguiente))  # la función se llama a sí misma
            tablero[i] = " "                            # deshacer la jugada
    return max(puntajes) if turno == "O" else min(puntajes)

Prerequisito nuevo — recursión: una función recursiva se llama a sí misma con un problema más pequeño (aquí, un tablero con una casilla menos) hasta llegar a un caso base (partida terminada). Sin caso base, se llamaría para siempre.

Tu turno: escribe mejor_jugada(tablero): para cada casilla vacía, coloca "O", calcula minimax(tablero, "X"), deshaz la jugada y quédate con la casilla de mayor puntaje.

Observa: en un tablero vacío, minimax explora cientos de miles de posiciones y tarda un momento. ¿Cómo lo acelerarías? (Ideas: jugar el centro sin calcular en la primera jugada; guardar resultados ya calculados en un diccionario.)

Problema#

Construir un Tres en línea jugable en consola por dos personas.

Contexto#

Quieres un juego para los descansos que funcione en cualquier computador del aula, sin internet ni instalaciones.

Objetivo#

Un programa de consola, organizado en funciones, que dos personas puedan jugar de principio a fin sin que se cierre por errores.

Requisitos funcionales#

1. Muestra el tablero en cada turno y dice a quién le toca.
2. Pide una casilla del 1 al 9 y rechaza entradas no válidas con un mensaje claro.
3. Detecta victoria (8 líneas) y empate.
4. Al terminar, pregunta si se quiere jugar otra vez.

Restricciones técnicas#

• Una función por responsabilidad (dibujar, leer jugada, detectar ganador, detectar empate, cambiar turno).
• Las líneas ganadoras como datos (sección 4), no como 8 if.
• Sin variables globales modificadas dentro de funciones (Día 12): pasa el tablero como parámetro.

Planificación#

1. Comprender el juego (juega una partida en papel). 2. Entradas: el número de casilla. 3. Procesos: el diagrama de la sección 2. 4. Salidas: el tablero y los mensajes. 5. Dividir en funciones. 6. Diseñar el tablero en texto. 7. Implementar por versiones. 8. Probar con la tabla de pruebas. 9. Corregir. 10. Mejorar (retos).

Construcción paso a paso#

• Versión 1 — Tablero: crear y dibujar el tablero; colocar una "X" a mano en el código y verla.
• Versión 2 — Turnos: ciclo que alterna X y O y pide casillas (todavía sin validar ni detectar final; el ciclo termina tras 9 jugadas).
• Versión 3 — Validación: leer_casilla y el ciclo que repite la pregunta.
• Versión 4 — Final de partida: ganador, tablero_lleno y los mensajes.
• Versión 5 — Revancha y marcador: jugar varias partidas y llevar la cuenta de victorias de cada símbolo.
• Versión final — Pulido: limpiar la pantalla entre turnos (opcional), README.md y diario.

Pruebas#

Escríbelas con assert en un archivo pruebas.py (se verificaron todas con las funciones de este tutorial):

assert ganador(["X", "X", "X", " ", " ", " ", " ", " ", " "]) == "X"
assert ganador(crear_tablero()) is None

🧪 Prueba y depuración#

Este programa tiene cuatro errores. Encuéntralos antes de ejecutarlo:

tablero = [" "] * 9
turno = "X"
while not tablero_lleno(tablero):
    casilla = int(input(f"Turno de {turno}: "))
    tablero[casilla] = turno
    if turno == "X":
        turno = "O"
    if turno == "O":
        turno = "X"
    if ganador(tablero):
        print(f"Gana {turno}")

Pistas: ¿qué pasa si escribo "9"? ¿Cambia realmente el turno? ¿De quién es el turno cuando se anuncia el ganador? ¿El ciclo termina cuando alguien gana?

⭐ Extensión del proyecto#

• 🟢 Reto 1 — Aplicación: que cada jugador escriba su nombre y el marcador los muestre.
• 🟡 Reto 2 — Ampliación: modo 1 jugador contra la IA "fácil" o "media" (sección 6), elegido en un menú.
• 🟠 Reto 3 — Desafío: IA perfecta con minimax; mide cuánto tarda la primera jugada con time.perf_counter() y acelérala con un diccionario de posiciones ya calculadas (memoización).
• 🔴 Reto 4 — Pensamiento computacional: generaliza el juego a un tablero de N × N donde gana quien alinea N símbolos. Ya no puedes escribir LINEAS a mano: diseña cómo generarlas con ciclos y pruébalo con N = 3 (deben salir exactamente 8 líneas) y N = 4 (¿cuántas deben salir?).

Situación#

El club de juegos de mesa del colegio quiere una versión digital de Conecta 4: un tablero de 6 filas × 7 columnas donde las fichas caen hasta la posición libre más baja de la columna elegida. Gana quien alinea 4 fichas en horizontal, vertical o diagonal.

Requisitos#

1. El jugador elige una columna (1–7), no una casilla.
2. La ficha cae a la fila libre más baja; si la columna está llena, se rechaza la jugada.
3. Se detectan las victorias en las 4 direcciones y el empate.

Decisiones que debes tomar (y justificar)#

• ¿Lista de 42 elementos o lista de listas? (Aquí la comparación de la sección 3 cambia: ¿por qué?)
• ¿Generas todas las líneas de 4 posibles (como LINEAS) o revisas solo alrededor de la última ficha? ¿Cuál es más eficiente?

Casos de prueba#

• Cuatro fichas seguidas en la fila de abajo ganan.
• Una diagonal que sube hacia la derecha gana (y otra que baja, también).
• La 7.ª ficha en una columna se rechaza.

Conceptuales#

1. ¿Por qué conviene que dibujar devuelva un texto en lugar de imprimirlo?
2. ¿Qué ventaja tiene guardar las líneas ganadoras en una lista de tuplas?
3. ¿Qué es un caso base en una función recursiva y qué pasa si falta?
4. ¿Por qué hay que revisar el ganador antes que el empate?

Análisis de código#

for a, b, c in LINEAS[3:6]:
    print(a, b, c)

¿Qué líneas del tablero imprime y qué representan?

Predicción#

t = [[" "] * 3] * 3
t[0][0] = "X"
print(t)

¿Qué se imprime? ¿Por qué no es lo que esperabas?

Depuración#

Un estudiante dice: "Mi juego anuncia 'Gana ' (con espacios) apenas empieza". ¿Qué le falta a su función ganador?

Modificación#

Cambia dibujar para que las casillas vacías muestren su número (1–9) como guía para el jugador.

Creación#

Escribe casillas_libres(tablero), que devuelva la lista de números de casilla (1–9) aún disponibles. Úsala en la IA "fácil".