Piedra, papel o tijera en Python - código, reglas y pruebas

6 de noviembre de 2026

Ilustración de "piedra papel o tijera python" con puño cerrado, mano abierta y dos dedos levantados.

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.

Un juego de estrategia tipo

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":
        break

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

Preguntas frecuentes

Aplica strip().lower() al texto introducido. Así se eliminan los espacios sobrantes y se convierten las mayúsculas a minúsculas antes de comprobar si la respuesta pertenece a piedra, papel o tijera. Si no pertenece a esas opciones, el programa muestra un aviso y usa continue para pedir otra jugada.
El diccionario vence_a relaciona cada jugada con la que puede vencer: piedra gana a tijera, papel a piedra y tijera a papel. Primero se comprueba si ambas jugadas son iguales para detectar un empate; después, si vence_a[jugador] == ordenador, gana el jugador. En cualquier otro caso, gana el ordenador.
Para revisar la lógica, asigna temporalmente una jugada fija al ordenador y comprueba los nueve cruces posibles entre las tres jugadas del jugador y las tres del ordenador. También se puede usar random.seed() para repetir una secuencia, aunque las secuencias pueden variar según la versión y las condiciones de ejecución. Por eso, probar directamente las combinaciones resulta más claro para validar todas las reglas.
Se puede añadir un marcador con variables como puntos_jugador y puntos_ordenador, sin sumar puntos en los empates y actualizando la puntuación después de decidir cada ronda. También es posible trasladar la interacción a una micro:bit, donde el movimiento de la placa permite elegir una opción al azar y los LED muestran el resultado.
Calificar artículo

Promedio: 5.0 / 5 · 4 calificaciones

Etiquetas

python juegos validación depuración micro:bit
Comentarios (0)
Añadir comentario