The Nerdy Apprentice: El Juego de la Vida de Conway en Python: una guía paso a paso (Writeups + CLI)

¿Cuántas veces viste una animación del Juego de la Vida de Conway o te lo encontraste como ejercicio de programación en algún curso y pensaste: "esto lo tengo que intentar" A mí me pasó un montón de veces.

"El Juego de la vida es un autómata celular diseñado por el matemático británico John Horton Conway en 1970. Es un juego de cero jugadores, en el que su evolución es determinada por un estado inicial, sin requerir intervención adicional. Se considera un sistema Turing completo que puede simular cualquier otra Máquina de Turing." Fuente: Wikipedia

Partiendo de reglas simples sobre una cuadrícula, surgen comportamientos y patrones caóticos que parecen tener vida propia. Sin embargo, cada vez que me sentaba a buscar cómo encararlo desde cero, me chocaba contra la misma pared: tutoriales incompletos, explicaciones que daban por obvios pasos fundamentales, o implementaciones que usaban librerías como NumPy con convoluciones matemáticas avanzadas, sin explicarte qué es realmente una célula, cómo se indexa la matriz o cómo se calculan los vecinos en una simple cuadrícula de dos dimensiones.

"Se trata de un juego de cero jugadores, lo que quiere decir que su evolución está determinada por el estado inicial y no necesita ninguna entrada de datos posterior. El "tablero de juego" es una malla plana formada por cuadrados (las "células") que se extiende por el infinito en todas las direcciones. Por tanto, cada célula tiene 8 células "vecinas", que son las que están próximas a ella, incluidas las diagonales. Las células tienen dos estados: están "vivas" o "muertas" (o "encendidas" y "apagadas"). El estado de las células evoluciona a lo largo de unidades de tiempo discretas..." Fuente: Wikipedia

El Juego de la Vida es un desafío de programación que siempre me costó llevar a cabo de forma limpia. Por eso decidí encararlo de otra manera, armando un camino pedagógico paso a paso, guiado, donde cada concepto se construyera sobre el anterior usando Python puro, usando solo librerías estándar.

Hoy les comparto el resultado de ese proceso: conway_writeups_cli_py, un proyecto que reúne una serie de cuadernos interactivos (Writeups en Jupyter) y una versión modular para jugar directamente desde la terminal (CLI).

Objetivos del proyecto

Aprender sin saltear pasos: Comprender la lógica del autómata usando estructuras de datos nativas de Python (listas de listas) antes de depender de paquetes externos.
Documentar el recorrido en fases: Escribir cuadernos interactivos de Jupyter que sirvan como guía de estudio paso a paso.
Construir una CLI modular y limpia: Separar responsabilidades en módulos independientes (lógica, visualización y bucle de control).
Entorno reproducible con uv: Facilitar que cualquiera pueda clonar el proyecto y probarlo en segundos sin lidiar con dependencias rotas.

Los Writeups en Jupyter

Para no saltar de golpe a un archivo de 150 líneas de código, dividí este desafío en tres cuadernos dentro de la carpeta writeups/:

Fase 1: Fundamentos y representación de matrices

Matrices bidimensionales. Acá arrancamos desde lo más básico:

Representar una cuadrícula con listas anidadas (list[list[int]]).
Comprender la relación entre coordenadas, filas y columnas.
Generar matrices con estados aleatorios iniciales (células vivas con 1 y muertas con 0).

Fase 2: Las reglas clásicas y la vecindad

El corazón de Conway reside en cómo interactúa una célula con su entorno:

Vecindad de Moore: Los 8 vecinos que rodean a cada posición.
Coordenadas relativas: Definir una constante con los desplazamientos (-1, -1), (0, 1), etc.
Control de bordes: Cómo evitar errores de índice (IndexError) cuando evaluamos células en los márgenes de la cuadrícula.
Reglas con match / case: Implementar de forma limpia las transiciones: una célula muerta nace con 3 vecinos vivos; una célula viva sobrevive con 2 o 3, y muere en cualquier otro caso por aislamiento o sobrepoblación.

Fase 3: La simulación en tiempo real

Con la lógica ya resuelta, tocaba darle movimiento:

Copiar matrices de forma segura para no mutar el estado durante el cálculo generacional.
Limpiar la consola entre fotogramas para generar la ilusión de animación.
Detectar cuándo la simulación se estanca (juego terminado).

De los cuadernos a la arquitectura modular (CLI)

Una vez que los cuadernos cumplieron su rol, el siguiente paso fue organizar el código como un proyecto formal. Dividiendo la versión CLI en tres archivos:

cli/logica.py: Contiene la lógica pura del juego. Agnóstico a la consola; no tiene ningún print ni dependencias del sistema operativo. Maneja la generación del tablero, el conteo de vecinos vivos y la evolución generacional.
cli/display.py: Se encarga de la vista. Transforma los números en caracteres visuales (. para células muertas y # para vivas), imprime el tablero y limpia la pantalla.
cli/main.py: El orquestador. Conecta la lógica con la vista, maneja la velocidad de la animación y permite salir limpiamente con Ctrl + C sin tirar errores en la terminal.

Estructura de archivos del repositorio

.
├── cli/               # Versión ejecutable por terminal
│   ├── display.py     # Manejo de pantalla y formato visual
│   ├── logica.py      # Lógica pura del juego y reglas
│   └── main.py        # Orquestador del bucle de simulación
├── writeups/          # Cuadernos de estudio paso a paso (Jupyter)
│   ├── fase1_fundamentos_matrices.ipynb
│   ├── fase2_reglas_juego.ipynb
│   └── fase3_simulacion_cli.ipynb
├── pyproject.toml     # Definición del entorno y dependencias
├── uv.lock            # Lockfile para reproducibilidad absoluta
└── LICENSE            # Licencia GNU GPL v3

¿Cómo probarlo en tu pc?

Últimamente estoy usando uv (gran herramienta para gestionar entornos en Python)

# 1. Clonás el repositorio
git clone https://github.com/mcattani/conway_writeups_cli_py.git
cd conway_writeups_cli_py

# 2. Sincronizás el entorno
uv sync

1. Para correr la simulación en la consola:

uv run python cli/main.py

(Podés detenerla apretando Ctrl + C).

2. Para explorar los cuadernos interactivos:

uv run jupyter lab
# o si preferís:
uv run jupyter notebook

¿Qué se viene? Próximo paso: versión gráfica con Pygame

Esta versión en consola y los writeups son el primer escalón. Me gustaría escribir una versión simple utilizando pygame (que nunca usé). Esa versión será el foco del próximo post.

Como siempre, les dejo todo el código (la versión cli y los writeups) en mi repo:

Repositorio: https://github.com/mcattani/conway_writeups_cli_py

Todos los comentarios son siempre bienvenidos. Saludos!

Y si este paso a paso te sirvió de ayuda o te pareció interesante, acordate que podés invitarme un cafecito para apoyar el blog: