En clase, el juego empieza rápido; el programa, en cambio, puede declarar inválida una jugada por un espacio de más o una mayúscula. Con Python puedes crear una versión sencilla contra el ordenador, aunque el resultado dependerá de cómo valides lo que escribe cada jugador.

Una partida breve sirve para practicar decisiones, azar y control de errores
- Azar: `random.choice()` escoge la jugada del ordenador entre las opciones disponibles.
- Reglas: una estructura de datos puede expresar qué jugada vence a cada otra.
- Entradas: `strip()` y `lower()` evitan rechazar respuestas por espacios o mayúsculas.
- Ampliación: el marcador y las pruebas con casos límite convierten el juego en una actividad de programación más completa.
El código completo cabe en una actividad corta
Una versión de consola permite concentrarse en el flujo del programa: pedir una jugada, generar otra al azar y decidir quién gana. Creo que es un buen primer proyecto porque cada línea tiene un propósito que se puede comprobar jugando.
import random
opciones = ("piedra", "papel", "tijera")
vence_a = {
"piedra": "tijera",
"papel": "piedra",
"tijera": "papel"
}
while True:
jugador = input("Elige piedra, papel o tijera: ").strip().lower()
if jugador not in opciones:
print("Opción no válida. Escribe piedra, papel o tijera.")
continue
ordenador = random.choice(opciones)
print(f"El ordenador eligió {ordenador}.")
if jugador == ordenador:
print("Empate.")
elif vence_a[jugador] == ordenador:
print("¡Ganas!")
else:
print("Gana el ordenador.")
repetir = input("¿Otra ronda? (s/n): ").strip().lower()
if repetir != "s":
breakPara jugar, guarda el código en un archivo, por ejemplo `juego.py`, y ejecútalo con Python. La función choice() elige un elemento de una secuencia; aquí, esa secuencia es la tupla con las tres jugadas, tal como explica la documentación del módulo random de Python.
Normalizar la respuesta evita errores que parecen fallos del juego
Si alguien escribe ` Piedra `, una comparación directa con `"piedra"` no coincide: los espacios y la mayúscula cambian el texto. `strip().lower()` limpia ambos detalles antes de comprobar la jugada, así el programa acepta entradas habituales sin añadir complejidad.
La tabla ayuda a decidir qué hacer con cada entrada. En una práctica guiada, también permite separar el problema en dos preguntas: «¿es una opción válida?» y «¿quién gana?». Esa separación facilita encontrar errores.
| Situación | Qué ocurre | Qué hacer |
|---|---|---|
| Se introduce ` Papel ` | Sin limpiar la entrada, no coincide con `papel`. | Aplicar strip().lower() antes de comparar. |
| Se escribe `lagarto` | La respuesta no pertenece a las opciones del juego. | Mostrar un aviso y pedir otra jugada con continue. |
| Jugador y ordenador eligen lo mismo | La ronda termina en empate. | Comprobar la igualdad antes de evaluar quién vence. |
| Una jugada gana a la otra | La relación se consulta en el diccionario. | Si vence_a[jugador] == ordenador, gana quien juega. |
El aviso y la repetición tienen una función didáctica: muestran que una entrada incorrecta no tiene por qué cerrar el programa. Y ese pequeño detalle conduce a una pregunta útil: ¿cómo se comprueba que las reglas estén bien codificadas?
El diccionario permite revisar las tres reglas de un vistazo
La estructura vence_a guarda una relación por jugada: piedra vence a tijera, papel a piedra y tijera a papel. Así se evita repetir una cadena de condicionales para cada combinación, y resulta más fácil revisar si falta alguna regla o si se ha escrito al revés.
Antes de usar el azar, se puede comprobar la lógica con una tabla pequeña. El orden de los resultados importa: cada fila representa la jugada del jugador y cada columna, la del ordenador.
| Jugador | Ordenador: piedra | Ordenador: papel | Ordenador: tijera |
|---|---|---|---|
| Piedra | Empate | Gana ordenador | Gana jugador |
| Papel | Gana jugador | Empate | Gana ordenador |
| Tijera | Gana ordenador | Gana jugador | Empate |
Si una casilla no coincide con las reglas del juego, el error está en la lógica, no en el azar. Probar estos nueve cruces antes de añadir funciones nuevas ahorra confusiones cuando aparezcan el marcador o más opciones.
Una prueba fija ayuda a separar la lógica del azar
Cuando una ronda da un resultado inesperado, cuesta saber si falla la regla o si simplemente ha salido una jugada distinta. Para depurar, se puede probar cada cruce de forma controlada, asignando temporalmente una jugada al ordenador en vez de generarla al azar. Así se comprueban las reglas sin depender de lo que salga en esa ejecución.
También existe la posibilidad de fijar una semilla con random.seed() para repetir una secuencia pseudoaleatoria durante una prueba. La documentación de Python advierte que las secuencias pueden depender de la versión y de las condiciones de ejecución; por eso, para revisar todas las reglas, es más claro probar directamente las combinaciones.
En una actividad de aula, una ampliación natural consiste en añadir un marcador con variables como puntos_jugador y puntos_ordenador. Para que el recuento sea correcto, el empate no debe sumar puntos y la puntuación se actualiza después de decidir el resultado de cada ronda.
El mismo juego puede crecer hasta una micro:bit
La versión de consola enseña entrada de texto y condicionales; una placa cambia la interacción. En el proyecto educativo de micro:bit sobre piedra, papel o tijera, el movimiento de la placa permite elegir una opción al azar y mostrarla mediante sus LED. La mecánica del juego se mantiene, pero el alumnado conecta código con sensores y salida visual.
Para ampliar el programa de consola, se puede añadir un marcador o pedir que dos personas jueguen en el mismo dispositivo. Yo empezaría por el marcador: obliga a conservar el estado entre rondas y permite explicar por qué una variable debe actualizarse únicamente cuando hay victoria. Después, trasladar la elección a un botón o sensor hace visible cómo una entrada física puede sustituir al teclado.
La próxima vez que aparezca un espacio de más o una jugada imposible, el programa ya no tendrá por qué detenerse: puede limpiar la respuesta, validarla y continuar la partida. Ese recorrido, de una entrada imperfecta a una decisión correcta, contiene buena parte de lo que hace útil este pequeño proyecto.