Google+ Seguidores

sábado, 27 de enero de 2018

Jugando a Piedra, Papel o Tijera con nuestra computadora - Programas Python

Hola, en el presente artículo os propongo crear un sencillo programa para jugar a “piedra, papel o tijera”, con nuestra computadora. En donde, por una parte, al usuario se le pedirá que introduzca una de esas tres opciones (lo cual podrá hacer en minúsculas, mayúsculas o combinando ambas), y por otra, la computadora “elegirá” también su opción. En función de la combinación de ambas opciones se le dirá a nuestro usuario si ha ganado, perdido o empatado. A su vez, crearemos un marcador que llevará la cuenta del número de partidas jugadas, ganadas, perdidas y empatadas. A continuación se muestra un ejemplo de ejecución del programa que vamos a crear:
Para la correcta ejecución de nuestro programa, vamos a necesitar de dos archivos (aparte del correspondiente al programa principal): Por una parte, usaremos el modulo “VALID.py” (un paquete de funciones reutilizables en distintos programas, cuyo desarrollo expliqué en un artículo anterior), y por otra, un archivo que contendrá los campos relativos al marcador, y en donde se irán almacenando los resultados obtenidos en cada jugada.
De ese modo, antes de abordar la creación de nuestro programa principal, procederemos a crear un archivo compuesto por cuatro campos (que estará fuera del programa principal), en los que se irán almacenando el número de partidas jugadas, ganadas, perdidas y empatadas. Archivo el cual, se alojará en el disco duro de nuestra computadora. De modo que las modificaciones que se produzcan en el mismo, tras cada jugada, permanecerán intactas, aún cuando cerremos el programa o apaguemos la computadora.
Para la creación de dicho archivo, haremos uso de nuestro intérprete de python y del modulo “pickle” (que será el encargado de crear el archivo en el disco duro. En el cual, escribiremos lo siguiente:
Como se puede ver, lo primero que hemos hecho, ha sido importar el modulo “pickle”, el cual contiene las funciones que nos permitirán guardar datos en el disco duro y trabajar con ellos. Acto seguido, creamos una lista (a la que llamamos “puntos”) compuesta por cuatro números (a los que daremos un valor inicial de 0), los cuales se corresponderán con las “partidas jugadas”, partidas ganadas”, “partidas perdidas” y “empates”. Aunque, tal y como se puede ver, no realizamos esa asociación aquí, (lo haremos en el programa principal). Aquí lo único que vamos a hacer es reservar un espacio en el disco duro, donde se almacenarán los datos correspondientes a esos cuatro campos.
El modo en el que vamos a establecer dicho espacio, (y que también será el que empleemos para establecer las modificaciones sobre tales datos), es mediante la función “pickle.dump”, mediante el cual, pedimos que se almacene la lista creada (“puntos”) en un archivo el cual (tal y como se ve en la imagen de arriba) le hemos dado el nombre de “marcador.mio”.
Una vez completado este proceso ejecutamos el programa, (al que hemos llamado “marcador.py”):
Veremos, entonces, que aparece un archivo nuevo (“marcador.mio”) en nuestra carpeta de python.
Efectivamente si ahora (al ejecutar “marcador.py”) damos la orden de imprimir la lista “puntos” se muestra:
Lo que nos indica que nuestro marcador está ya listo para ser usado por nuestro programa principal para almacenar los resultados del juego de “piedra, papel o tijera”.
Hasta aquí la explicación de cómo hemos elaborado nuestro marcador. A continuación vamos a empezar a crear el programa principal (para jugar a “piedra, papel o tijera”).
Para iniciar la elaboración de nuestro programa principal, empezaremos importando aquellos módulos que contienen las funciones que necesitamos aplicar.
En este punto he de hacer una pequeña puntualización, consistente en que una de las funciones que vamos a emplear (“ns()”) se encuentran en el módulo “VALID.py”, cuya explicación fue objeto de un artículo anterior. De modo que aquellos lectores que tengan copiado el código de dicho modulo les bastará con importarlo al programa principal junto con el resto de módulos que si vienen instalados en python, del siguiente modo:
Sin embargo en el caso de que el lector no disponga de tal modulo (“VALID.py”), y puesto que del mismo solo vamos a usar una función (“ns()”), bastará con que (sin importar el módulo “VALID.py”), introduzca la siguiente función en el programa principal:
Hecha esta pequeña matización, procedemos a explicar nuestro programa. Como sabréis, el juego de “piedra, papel, tijera” se realiza entre dos personas, las cuales tienen que escoger entre una de dichas opciones (piedra, papel o tijera) a la vez. En este caso vamos a hacer que los jugadores sean el propio usuario y la computadora.
En este punto, lo primero que tenemos que hacer es idear un medio, mediante el cual, el usuario y la computadora “opten” por una de las tres posibilidades. En el caso del usuario, haremos que este escoja una de las opciones mediante un input mediante el cual, se la pedirá que escriba una de las opciones. Por su parte para establecer la “elección” de la computadora haremos uso de uno de los módulos antes importados (modulo “random”), el cual se encuentra ya instalado con Python.
De dicho modulo, haremos uso de la función “random.choice()”. Esta función, lo que hará será, escoger de forma aleatoria, un elemento de los presentes en una lista dada por el usuario. Para la mejor comprensión de cómo funciona esta función pondremos un sencillo ejemplo:
Como se ve, hemos creado una variable (llamada “opción”), la cual, será igual a la aplicación de la función “random.choice()” sobre una lista de elementos (en este caso las palabras “piedra”, “papel” y “tijera”) y mediante lo cual, dicha función devuelve (de forma aleatoria) solo uno de los elementos incluidos en la lista (en el ejemplo, hemos ejecutado tres veces la función para comprobar mejor el carácter aleatorio del resultado obtenido). De ese modo, este será el método mediante el cual, haremos que la computadora “escoja” su opción (opción de la computadora que almacenaremos en una variable, a la que llamaremos “Comp”) tal y como se aprecia a continuación.
Con ello ya tenemos establecido el método por el que se generará la “opción” de la computadora. Ahora es el turno de establecer la opción del usuario. Lo cual haremos mediante un input por el que le pediremos que escoja entre una de las tres opciones (dicha opción la almacenaremos en una variable que llevará por nombre “Tu”):
Vamos a programar nuestro juego de tal modo que el usuario pueda introducir su opción tanto en minúsculas como mayúsculas (o incluso combinando mayúsculas y minúsculas). Usando como único criterio para aceptar el input, que la palabra introducida se corresponda con una de las tres opciones posibles.
Para ello, utilizaremos la función “.lower ()” que lo que va hacer, es convertir el string que hayamos introducido a minúsculas, para continuación mediante un ciclo ”while”, asegurarnos de que nuestro jugador introduce una de las opciones (esto lo hacemos dando la instrucción de que “mientras la variable “Tu” sea distinta a “piedra”, “papel” y “tijera”, pedir de nuevo la introducción del input”). Finalmente (una vez que tengamos establecidas las “opciones” del jugador y de la computadora) visualizaremos ambas opciones, en mayúsculas, haciendo uso de la función “.upper ()”.
Una vez que tenemos establecidas las opciones del jugador y la computadora, es el momento de comparar ambas entradas, para decidir cuál de los dos (jugador o computadora) gana la partida. Como aquí es donde se decide cuando se gana, pierde o se empata (además de ir sumándose el número de partidas jugadas), es aquí donde los campos del marcador que creamos, tendrán que ir actualizándose. Por ello, lo primero que vamos a hacer dentro de este bloque del programa, va a ser “llamar” (o cargar), mediante “pickle”, a los datos que almacenamos en nuestro archivo permanente “marcador.mio”.
De este modo (a través de la variable “puntos”) ponemos a disposición de nuestro programa principal, la lista de cuatro campos, y que tenían un valor inicial de 0 (“[0,0,0,0]”). De modo que a partir de ahora se irá modificando en cada ejecución (jugada) de nuestro programa.
Antes de continuar, debemos de asignar a cada uno de los campos de nuestro marcador, que tipo de evento va a contabilizar (los eventos son: partidas jugadas, ganadas, perdidas y empatadas). Dicha asignación la ilustraremos de la siguiente manera:
Como se puede ver, el primer campo (posición 0 de la lista “puntos”) albergará el número total de partidas jugadas. Por su parte, el segundo campo (posición 1 de la lista “puntos”) registrará el número de partidas ganadas por el jugador. Las partidas perdidas se almacenarán en el tercer campo (correspondiente a la posición 2 de nuestra lista) y finalmente, a las partidas empatadas, reservaremos el cuarto campo (posición 3 en la lista).
A partir de ahora, en función de la opción introducida por el jugador y de la “opción” de la computadora (que como recordaremos, se genera de forma aleatoria mediante “random.choice()”), haremos que aparezca un mensaje en el que se nos dirá si hemos ganado perdido o empatado con la computadora (a su vez se sumará un punto al número de partidas jugadas, y otro al campo correspondiente al evento ocurrido). Veamos un ejemplo con la primera de las combinaciones posibles:
En esta imagen, presentamos la primera combinación posible de entradas. Concretamente, se expresa lo que ha de suceder en el caso de que la elección del jugado haya sido “papel” y la de la computadora (generada aleatoriamente), “tijera”. En ese caso se especifica que el programa ha de mostrar un texto (“PERDISTE: Las tijeras cortan el papel”), y acto seguido, se ha de sumar 1 tanto al elemento en posición 0 de la lista “puntos” (que expresaba el número de partidas jugadas) y otro punto al elemento en posición 2 (correspondiente al número de partidas perdidas). En las siguientes líneas seguiremos este esquema con el resto de combinaciones:
Hay que mencionar que este recorrido por las distintas combinaciones, lo realizaremos solo en el caso de que la “opción” de las variables “Tu” y “Comp”, no coincidan (“if Tu!=Comp:”), de modo que en caso contrario (“else:”)  se muestre el mensaje “EMPATE” y además de sumarse una nueva partida (lo que sucederá con cada ejecución del programa), se sume un nuevo punto al elemento 3 de la lista “puntos” (en donde dijimos que se guardaría el número de empates). Finalmente (como se ve en la última línea de la imagen) utilizaremos la misma función de “pickle”, (que usamos en su momento para crear nuestro marcador) para guardar los cambios operados por los distintos campos de la lista “puntos”.
Hasta aquí, hemos visto el desarrollo de dos bloques de código, dentro del programa principal: El primero, en el que se establecía las “opciones” del jugador (mediante el input) y de la computadora (con la función “random.choice()”). El segundo bloque, en el que se comparaban las opciones del jugador y el ordenador y en función de ello, se decía si habíamos ganado, perdido o empatado (en este bloque también se actualizaba la información contenido en la lista “puntos” del archivo “marcador.mio”. Pasamos a analizar el tercero y último bloque de código de nuestro programa principal, el cual, se encargará de darnos la opción de ver la puntuación acumulada de partidas anteriores, en nuestro marcador. Así tenemos:
Hay que apuntar  que si ejecutamos el archivo “marcador.py” (el cual usamos en su momento para crear el archivo permanente “marcador.mio”) los resultados (sean cuales sean en ese momento) del marcador se pondrán de nuevo a 0 (su valor inicial). Sin embargo, en nuestro programa principal, vamos a dar al jugador, la posibilidad de poner el marcador a cero, de forma directa (sin tener que ejecutar “marcador.py”), para lo cual el jugador tendrá que escribir “C”. Pero vayamos por partes:
Lo primero que vamos a hacer aquí es preguntarle al jugados si desea ver la puntuación actual (lo haremos mediante un input).
Tenemos así, una variable (a la que hemos llamado “Res”) la cual solo admitirá tres posibles respuestas: “s” (para indicar que queremos ver la puntuación actual), “n” (para indicar que no deseamos ver dicha puntuación) y “C” (para poner el marcador, otra vez a 0, como si no hubiésemos jugado ninguna partida). Para esto, vamos a hacer uso de la función “ns” (importada del modulo “VALID” o introducida directamente en el programa principal) la cual, se encarga de “asegurarse” de que el usuario-jugador solo introduce “n” (para “no”) o “s” (para “sí”), como respuesta. Sin embargo, hemos dicho que en este caso también vamos a aceptar “C” como respuesta (para poner el marcador a 0), de modo que solo aplicaremos la función “ns” para el caso en que la respuesta sea distinta a “C” (“if Res!=(“C”)), tal y como se muestra en la imagen de arriba.
Finalmente, para el caso de que el jugador haya contestado “s” (es decir: “si”) a la pregunta de si quiere que se visualice la puntuación acumulada de partidas anteriores, se mostrarán dichos resultados del siguiente modo: “print(“PARTIDAS JUGADAS:”,puntos[0],”PARTIDAS GANADAS:”,puntos[1],”PARTIDAS PERDIDAS:”,puntos[2],”EMPATES:”,puntos[3])” Lo que hemos hecho aquí ha sido mostrar los resultados acumulados de los distintos campos de los que constaba nuestro marcador, haciendo referencia a la posición que para cada evento (partida jugada, ganada, perdida y empatada) habíamos reservado dentro de la lista “puntos”.
Tras todo ello ya solo nos queda preguntar al usuario si desea volver a jugar otra partida, para lo que escribimos:
En donde “conti” es el nombre de la variable que albergará la respuesta (que, mediante la función “ns”, haremos que solo pueda ser “s” para afirmar, o “n” para negar). De modo que si “conti” es igual a “s” finalizará la ejecución del programa (hay que señalar que dicha finalización la llevaremos a cabo con “break”. Lo cual, es debido a que toda la ejecución del programa, se encuentra dentro de un ciclo “while” (el cual usa como formula “while True:”) del que solo saldremos haciendo uso de “break”. Por último, disponemos que de no ser así (por haber sido la respuesta “s”, para jugar otra vez) continúe la ejecución del ciclo, haciendo uso de la función “subprocess.call” la cual se encargará de “limpiar” la pantalla, dejándola lista para una nueva partida a “piedra, papel o tijera”.
Realizado todo este proceso ya solo nos queda guardar nuestro programa (al que yo he puesto el nombre de “PPT game.py”).
El código de los programas referidos en este artículo  puede verse, en mi perfil de GitHub, en la siguiente dirección: https://github.com/antonioam82/Piedra-papel-tijera
Escrito por Antonio Alfonso Martinez.

No hay comentarios :
Write comentarios

Tu comentario es importante y nos motiva a seguir escribiendo...

Powered by Blogger .