Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

INTRO - Programando un juego de Ahorcado en Python - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 2 de abril de 2024 por Miguel R.

92 visualizaciones

Más información Transcripción

Descargar la transcripción

Hola, en este video vamos a programar en Python un juego de ahorcado 00:00:00
Es el juego común y corriente que la gente juega con papel y lápiz 00:00:05
donde una persona piensa en una palabra o un texto 00:00:09
y la otra persona le toca ir diciendo letras a ver si adivina por completo el texto 00:00:13
pero tiene una cantidad de intentos limitada 00:00:19
por lo tanto si falla muchas veces entonces es ahorcado y pierde el juego 00:00:22
Si no, adivina y gana el juego 00:00:27
Vamos a dividir el programa de abarcado en una serie de subrutinas 00:00:30
Que nos van a ayudar a resolver el problema 00:00:44
Vamos a dividir el problema en subproblemas 00:00:46
Las subrutinas son de dos tipos 00:00:49
Una son de interfaz, otra son de lógica 00:00:51
Las subrutinas que son de interfaz se encargan de imprimir cosas en la pantalla 00:00:53
De leer de la consola, de hacer validaciones 00:00:58
Mientras que las subrutinas de lógica se encargan de hacer algún trabajo que es necesario para la lógica del programa 00:01:02
Pueden ver, hay muchas subrutinas que son de interfaz y unas cuantas que son parte de la lógica 00:01:08
Entonces esto es lo que vamos a implementar 00:01:15
Ya estamos aquí en el ambiente de programación de Python 00:01:18
Vamos a iniciar con una subrutina principal que no va a recibir ningún parámetro 00:01:21
Y es la que se va a encargar de ser el programa principal 00:01:28
Voy a aprovechar para indicarles cómo elaborar un tipo de documentación que se llama Python Docs 00:01:31
Que se trata de poner un string justo después de la declaración de la función 00:01:38
Es decir, justo después del def 00:01:42
Este string sirve como documentación interna de la función o de la subrutina 00:01:44
Y en Python existe un comando que sirve para ver la ayuda de las diferentes funciones 00:01:49
Para ver qué es lo que hacen 00:01:54
Entonces ya lo voy a hacer y vamos a ver cómo funciona 00:01:56
Entonces acá voy a ponerle una descripción, esta es la subrutina principal del juego de ahorcado 00:01:58
Vean que estoy usando el string con triple comilla, lo cual me deja cambiar de línea 00:02:04
Entradas, ninguna, salidas, el juego de ahorcado y restricciones 00:02:08
Esa es la documentación de nuestra función principal 00:02:15
No quiero que haga nada por ahora esta subrutina, entonces voy a ponerle aquí pass para que no haga nada 00:02:19
y voy a irme al intérprete para probarlo 00:02:24
entonces vean, si yo pongo aquí Orcado, pues obviamente no pasa nada 00:02:28
porque la subrutina no tiene nada que hacer 00:02:31
pero existe esta función que se llama Help 00:02:32
o procedimiento que se llama Help 00:02:35
que sirve para ver cómo funciona una función 00:02:36
o una subrutina en general 00:02:40
entonces Help de Orcado 00:02:42
y nos va a imprimir en pantalla 00:02:43
eso que escribimos en el encabezado 00:02:45
o después del encabezado de la función 00:02:49
entonces para eso sirve esto 00:02:51
Para poder acceder a la documentación de la subrutina 00:02:53
Ahora sí, entonces vamos a hacer nuestro juego de arcado 00:02:56
Primero que todo vamos a usar una variable global 00:03:01
Que nos va a servir para guardar cuál es la cantidad máxima de intentos 00:03:04
Que va a tener el jugador a la hora de jugar 00:03:08
Entonces va a poder hacer 7 intentos 00:03:10
Si en 7 intentos no ha adivinado, entonces pierde 00:03:13
Esa variable es variable global 00:03:15
Pero en Python para poder usar una variable que está declarada fuera de una función 00:03:17
entonces hay que hacer esto, global intentos max, esto hace que Python entienda que la variable cuando se refiere al nombre intentos max 00:03:22
es a la variable global que se encuentra definida afuera y no una variable local, recuerden que en Python cuando uno asigna un valor 00:03:31
entonces la variable se crea, por lo tanto si lo primero que hacemos es asignarle un valor a intentos max lo que va a pasar es que cree que es una variable local 00:03:39
En fin, si queremos usar una variable global en Python tenemos que usar global y el nombre de la variable que está declarada fuera de la subrutina 00:03:46
¿Qué va a hacer este programa? Bueno, primero lo que vamos a hacer es limpiar la pantalla 00:03:53
Para quitar lo que haya en la consola y esto es algo estético, nada más, no es necesario 00:03:59
Y vamos a imprimir un mensaje de entrada 00:04:05
esta subrutina de limpiar pantalla lo que va a hacer es imprimir un montón de líneas en blanco 00:04:09
para que no se vea lo que había antes en la consola 00:04:15
y esta otra imprimir entrada lo que va a hacer es imprimir un rótulo que dice 00:04:18
abarcado, bienvenido al juego de abarcado, taca taca, esas cosas 00:04:22
es como una bienvenida 00:04:26
después vamos a usar una variable que se llama continuar 00:04:27
el juego de abarcado se va a repetir muchas veces 00:04:32
Yo puedo jugar una vez y al final del juego decir quiero jugar de nuevo 00:04:36
Entonces este ciclo que vamos a hacer es ese que permite jugar varias veces seguidas 00:04:39
Entonces mientras continuar sea true 00:04:43
Entonces vamos a hacer una serie de cosas 00:04:48
Y cuando el usuario diga que ya no quiere jugar más 00:04:50
Entonces a continuar le vamos a asignar false 00:04:55
Para que se salga de la subrutina 00:04:58
¿Qué es lo que va a pasar dentro de este ciclo? 00:05:00
Un juego consiste en primero tenemos que leer el texto original 00:05:01
Entonces el otro jugador va a escribir el texto original 00:05:05
Y para eso vamos a hacer una subrutina que se encarga de leer ese texto 00:05:10
Entonces esta subrutina leer texto original le va a imprimir al usuario 00:05:14
Por favor indique el texto 00:05:18
Y el usuario escribe el texto, el texto tiene que cumplir con ciertas reglas 00:05:19
Esas reglas, esas restricciones las va a vigilar esta misma subrutina 00:05:23
Entonces la subrutina retorna como resultado el texto que el usuario escribió 00:05:27
Este texto original puede tener tildes, mayúsculas y otras cosas 00:05:33
Letras en general, pero puede tener mayúsculas y puede tener tildes 00:05:37
Lo que pasa es que esas mayúsculas y tildes posteriormente no nos van a interesar 00:05:43
Bueno, justo después de que leemos el texto original hay que limpiar otra vez la pantalla 00:05:50
Para que el nuevo jugador no vea que fue lo que escribió, si no sería muy fácil 00:05:56
Y ahora sí, entonces vamos a inicializar nuestras variables 00:06:01
Vamos a necesitar una variable texto 00:06:04
Esta variable texto va a ser el texto que hay que adivinar 00:06:06
Pero sin tildes y sin mayúsculas 00:06:09
Entonces vamos a hacer una subrutina 00:06:11
Que se encarga de preparar el texto original 00:06:13
Se lo enviamos por parámetro 00:06:16
Ese texto original puede traer tildes y mayúsculas 00:06:19
Como les dije antes 00:06:23
Y preparar se encarga de devolver el texto limpio 00:06:24
Sin esas cosas 00:06:27
Sin tildes y sin mayúsculas 00:06:29
Y también le quita espacios al inicio y al final 00:06:31
Por aquello de que el usuario le haya metido espacios 00:06:33
Que no nos interesa adivinar 00:06:35
Luego vamos a llevar una variable 00:06:37
Que se llama intentadas 00:06:40
Que es un string con las letras que el usuario ya usó 00:06:41
Hayan servido o no hayan servido 00:06:44
Las letras que ya usó 00:06:46
Porque el usuario no puede repetir letras 00:06:47
Eso va a ir ahí, por eso empieza como un string vacío 00:06:49
Porque al principio no ha intentado nada 00:06:52
Luego una variable que nos dice 00:06:53
Cuantos intentos ha hecho el usuario 00:06:55
Eso lo vamos a empezar en cero 00:06:58
Esta es la variable que vamos a ir viendo 00:07:00
Tiene que ser menor que la cantidad máxima de intentos 00:07:01
Para que sean solo 7 oportunidades 00:07:04
Y también vamos a llevar el número de ronda por el que vamos 00:07:06
El número de ronda empieza en 1 00:07:10
Esas son nuestras variables principales 00:07:12
Ahora tenemos otro ciclo 00:07:15
Este ciclo se va a repetir mientras el usuario está adivinando letras 00:07:16
Entonces dice letras 00:07:20
Si es verdad, si es correcta le va a decir 00:07:22
Y si es incorrecta también le va a decir 00:07:25
Pero este ciclo se va a repetir hasta que el usuario pierda o gane alguna de las dos 00:07:27
Entonces, ¿cuál es la condición para perder? 00:07:32
La condición para perder es gastar todos los intentos 00:07:34
Entonces, mientras intentos sea menor que intentos max, que es la cantidad máxima de intentos 00:07:37
Podemos seguir jugando, si no ya perdimos 00:07:43
Y además, mientras no haya adivinado 00:07:45
Entonces lo que vamos a hacer es crear una función que se llama adivinó 00:07:49
Esta función nos dice si el jugador ya ganó o no ganó 00:07:54
Para eso le tenemos que mandar el texto 00:07:58
Que hay que adivinar 00:08:00
Y además las letras intentadas 00:08:01
Entonces con eso podemos saber 00:08:05
Esta subrutina se va a encargar de devolver true o false 00:08:08
True si todas las letras de texto 00:08:12
Están ya en las intentadas 00:08:15
Porque si es así ya adivinó 00:08:17
Entonces este ciclo se va a repetir 00:08:19
Mientras se cumpla esta condición 00:08:21
En cada una de las rondas lo primero que vamos a hacer es limpiar la pantalla 00:08:24
Esto no es necesario, de nuevo, es algo estético, pero no sé, lo voy a dejar así 00:08:28
Y vamos al inicio de la ronda, después de limpiar la pantalla 00:08:34
Lo que vamos a hacer es imprimir una serie de información 00:08:38
Vamos a decir por cuál ronda vamos, cuáles son las letras que ya usó 00:08:40
Cuántos intentos ha fallado y cómo se ve la palabra 00:08:44
Cómo están los espacios ahí, cuáles son las letras que le faltan 00:08:48
Entonces para eso vamos a hacer una subrutina que se va a llamar imprimir ronda 00:08:51
Que va a recibir el texto que hay que adivinar, va a recibir las letras intentadas 00:08:56
Va a recibir cuantos intentos ha hecho y va a recibir el número de ronda por el que vamos 00:09:01
Toda esa información se la mandamos por parámetro 00:09:06
Luego de que ya imprimimos ese mensaje en pantalla lo que tenemos que hacer es leer 00:09:09
Cual es la letra que el usuario quiere intentar, entonces vamos a decir letra intento 00:09:12
Y lo vamos a obtener de una subrutina también de interfaz 00:09:17
Que se va a encargar de leer el intento 00:09:21
Y le vamos a pasar todas las letras que ya ha usado 00:09:24
Para que no le permita repetir letras que ya ha usado antes 00:09:27
Vamos a hacer que el juego sea buena gente 00:09:30
Porque podríamos dejar que repita letras que ya fallaron 00:09:32
Y simplemente perdió un intento más 00:09:37
Pero no, somos un juego bueno, un juego familiar 00:09:38
que no va a dejar que la gente se equivoque repitiendo letras 00:09:43
ok, entonces luego de que lee esta función entonces nos devuelve 00:09:47
la letra que el usuario quiere intentar, entonces la guardamos en esa variable 00:09:51
y luego necesitamos saber si adivinó o no adivinó 00:09:55
si esa letra que acaba de intentar está o no está dentro de la palabra 00:09:59
o del texto que se tiene que adivinar, entonces también vamos a hacer 00:10:03
una función que nos va a decir si el intento es bueno 00:10:07
o es malo, si adivinó o no adivinó 00:10:11
entonces eso se va a llamar acierta intento 00:10:13
es una función booleana, nos dice true o false 00:10:16
recibe el texto y además 00:10:18
recibe la letra del intento 00:10:20
si acertó el intento 00:10:22
lo que vamos a hacer es imprimir un mensaje 00:10:24
que diga, felicidades 00:10:26
adivinó una letra 00:10:28
esto lo podríamos poner aquí mismo, podríamos hacer 00:10:29
print, podríamos escribir un print con el mensaje 00:10:32
pero no vamos a hacer eso, vamos a hacer 00:10:34
una subrutina también 00:10:36
imprimir mensaje de acierto 00:10:37
¿Por qué una subrutina? ¿Por qué no el print? 00:10:40
Porque si posteriormente quisiéramos complicar o modificar algo de esa impresión de ese mensaje 00:10:43
Por ejemplo hacer que el mensaje salga diferente siempre 00:10:49
Que escoja un mensaje de una serie de posibles mensajes para que el juego no sea tan repetitivo 00:10:51
Es más fácil modificar esa subrutina que venir a modificar la lógica del programa principal 00:10:56
Entonces así si tenemos que hacer alguna modificación en el mensaje o algo nuevo surge 00:11:01
Entonces es mejor tenerlo dentro de una subrutina 00:11:06
Luego, si no adivinó el intento, entonces no acertó el intento 00:11:08
Entonces vamos a imprimir un mensaje de no acierto 00:11:12
No se me ocurrió una mejor palabra, pero un mejor nombre 00:11:18
Lo mismo, una subrutina que se encarga de imprimir qué es lo que pasó 00:11:22
Pero además cuando no acertó el intento, aparte de imprimir ese mensaje 00:11:26
Tenemos que aumentar la cantidad de intentos fallidos que ha hecho 00:11:31
Entonces a la variable intentos le vamos a sumar un 00:11:34
Ok, después de haber impreso ese mensaje, se adivinó o no adivinó la letra, necesitamos agregar a la variable que lleva las letras que ya hemos intentado, la letra que acaba de intentar. 00:11:37
No importa si adivinó o no adivinó, la letra ya se usó, entonces la vamos a agregar aquí. 00:11:50
Y también vamos a aumentar la ronda por la que vamos porque eso fue todo. 00:11:55
Le dijimos si adivinó o no adivinó y además pasamos a la siguiente ronda. 00:11:59
Hasta aquí ya básicamente se está dando el juego 00:12:03
El jugador está intentando letras, está viendo que adivina y que no adivina 00:12:07
Cuando salgamos de este ciclo, de este while 00:12:14
Vamos a haber perdido o ganado, cualquiera de las dos, no sabemos 00:12:17
Entonces es necesario aquí preguntar si ganó o perdió 00:12:21
Entonces lo más fácil es preguntar si adivinó la última letra 00:12:25
Si salió del ciclo y adivinó, fue un acierto correcto 00:12:28
Entonces vamos a asumir que el usuario ganó 00:12:31
Entonces vamos a imprimir un mensaje de victoria 00:12:34
Le vamos a mandar el texto original para que se imprima 00:12:38
Para que el usuario vea que era lo que habían puesto 00:12:42
Aunque ya lo adivinó 00:12:43
Y si no, entonces vamos a imprimir mensaje de derrota 00:12:44
También con el texto original para que el usuario vea 00:12:49
Que fue lo que tenía que adivinar 00:12:53
Después de esto, todavía estamos en el ciclo grande 00:12:55
En el ciclo que permite jugar una y otra vez 00:12:58
Entonces acá al final necesitamos preguntarle al usuario si quiere jugar de nuevo o no 00:13:00
Entonces vamos a usar la variable continuar 00:13:05
Esta variable va a estar en true o en false, si queremos seguir o no queremos seguir 00:13:07
Entonces aquí vamos a hacer una subrutina también de interfaz 00:13:12
Que se llama leer jugar nuevamente 00:13:15
Que le va a decir al usuario si quiere jugar de nuevo o sí o no 00:13:18
Y entonces nos devuelve un valor booleano, un true o un false 00:13:21
Que se lo asignamos de una vez a esa variable 00:13:24
Entonces si el usuario dice que no quiere jugar más, la variable es false y nos salimos del ciclo 00:13:26
Si el usuario dice que sí quiere jugar, entonces la variable es true, continúa y juega de nuevo 00:13:30
Si salimos del ciclo principal de este ciclo grande, entonces ya el juego se acabó 00:13:34
Lo que vamos a hacer es imprimir un mensaje de despedida y listo, se acabó 00:13:39
Entonces este es nuestro programa principal 00:13:44
Obviamente falta mucho por hacer, faltan muchas subrutinas 00:13:48
Pero vamos a ir haciéndolas todas poco a poco, agregándoles su documentación 00:13:51
y viendo a ver si es necesario hacer chequeo de restricciones o no en las diferentes funciones 00:13:57
vamos a empezar con la primera que se usa por acá que es limpiar pantalla 00:14:04
vamos a definir aquí def, limpiar pantalla 00:14:09
vamos a hacerle la documentación a la función o al procedimiento de limpiar la pantalla 00:14:13
entonces esta es una subrutina que imprime líneas en blanco para limpiar la pantalla 00:14:19
entradas ninguna, salidas 40 líneas en blanco y restricciones ninguna 00:14:29
listo, esta es la documentación de esta subrutina 00:14:39
En realidad esta subrutina no hace mucha cosa 00:14:43
Gastamos más tiempo escribiendo la documentación que lo que en realidad va a hacer 00:14:46
Porque lo que va a hacer es imprimir un enter 00:14:51
Ahí está el enter, lo va a imprimir 40 veces 00:14:56
Eso es todo lo que hace la subrutina 00:15:00
Esa fue la primera, ya está lista 00:15:02
Limpiar pantalla, ya la tenemos por acá 00:15:04
Estamos aquí, limpiar pantalla 00:15:07
Ahora vamos con la de imprimir entrada 00:15:09
Entonces esta subrutina se va a encargar de imprimir la entrada del juego 00:15:12
Entonces cuando entremos al juego se va a imprimir un rótulo que dice 00:15:20
Bienvenido al juego de Orcado 00:15:24
Y lo va a poner creado por Mauricio 00:15:26
Pero ustedes le pueden poner cualquier otro mensaje que quieran ponerle 00:15:28
Entonces aquí va a poner la documentación 00:15:32
Subrutina que imprime un mensaje de bienvenida 00:15:34
Entradas, ninguna 00:15:40
Salidas, mensaje de bienvenida 00:15:43
Y restricciones, ninguna 00:15:46
Ahí está, nuestra documentación 00:15:49
Entonces, esto ya lo tengo preparado 00:15:51
Porque no lo voy a hacer aquí en vivo 00:15:54
Pero básicamente es esto lo que voy a imprimir 00:15:57
Vean que bonito 00:15:59
Esto lo hice con una página de internet 00:16:01
Que permite hacer algo que se llama ASCII Art 00:16:03
Es decir, esto que voy a escribir aquí 00:16:06
ASCII Art 00:16:07
Entonces uno escoge entre varios tipos de letra y puede copiar y pegar 00:16:09
Y pueden buscar en internet diferentes sitios y aplicaciones que hacen este tipo de cosas 00:16:14
Entonces yo agarré eso de una aplicación en línea y lo pegué por acá para hacer las letras de ahorcado 00:16:20
Este va a ser el mensaje de bienvenida, eso es todo 00:16:26
Ya tenemos la subrutina de imprimir entrada lista 00:16:29
Ahora, ¿qué más nos hace falta? 00:16:33
Nos hace falta una subrutina que nos permita leer el texto original 00:16:35
Vamos a hacer la subrutina que se llama leer texto original 00:16:40
Esta subrutina no recibe ningún parámetro, no recibe ninguna entrada 00:16:45
Y vamos a hacer la documentación 00:16:50
La documentación dice función, es una función que lee de la consola la palabra o frase a ser adivinada y retorna como resultado el texto leído 00:16:52
Entradas, tiene como entradas el texto del usuario, salidas, texto ingresado, restricciones, ninguna 00:17:10
No vamos a requerir ningún tipo de datos 00:17:21
Pero si vamos a hacer que la frase sea válida 00:17:25
No se vale leer cosas que no se pueden adivinar 00:17:28
Como números o símbolos raros 00:17:34
Entonces para eso vamos a necesitar una función cita auxiliar 00:17:35
Que vamos a declarar ahorita 00:17:40
Entonces texto va a ser el input 00:17:41
Y le damos el mensaje que es 00:17:45
Ingrese la palabra o frase a adivinar 00:17:47
Solo puede contener letras y espacios 00:17:53
Entonces ese va a ser nuestro mensaje para leer el texto 00:17:58
Vamos a necesitar que eso que el usuario ingresó sea algo válido 00:18:03
No lo vamos a revisar aquí, vamos a hacer una función que se encarga de ver si un texto es válido 00:18:06
Pero si no es válido, entonces vamos a quedarnos en un ciclo 00:18:13
Pidiéndole al usuario hasta que escriba un texto válido 00:18:17
O sea, vamos a dejarlo atrapado hasta que escriba algo que sea correcto 00:18:20
Con lo que se pueda jugar 00:18:24
Entonces, mientras no sea 00:18:25
Entonces vamos a hacer una subrutina que se llama 00:18:29
Es texto válido 00:18:32
Y le mandamos por parámetro el texto que acabamos de leer 00:18:34
Mientras el texto no sea válido 00:18:37
Lo que vamos a hacer es decirle 00:18:40
A ver, por favor usuario, el texto solo puede contener letras y espacios 00:18:41
El programa regaña al usuario y después vuelve a hacer el input 00:18:49
Que es igual a este que está aquí, texto 00:18:55
Ese ciclo se encarga de leer el texto hasta que sea válido 00:18:57
Si no es válido, si el usuario no escribe cosas válidas, entonces va a repetir 00:19:04
Se va a quedar atrapado ahí 00:19:08
ahora hagamos la función esa es texto válido entonces recibe un texto por parámetro si esta 00:19:10
función cita es es una función booleana que dice si un string es un texto válido para adivinar 00:19:19
adivinar en el juego si entonces entradas texto a analizar salidas true si el texto es contiene 00:19:31
solo letras letras espacios y tiene al menos un carácter sí porque no se va al escribir un string 00:19:45
vacío eso no es un texto válido para adivinar false sino que esas son las salidas y las 00:19:57
restricciones son que texto debe ser un string que hay aquí termina la documentación de esta 00:20:07
función y vamos a chequear restricciones primero si el tipo de texto es diferente de string entonces 00:20:15
vamos a lanzar una raceException, texto debe ser un string, listo y si no entonces lo que vamos a 00:20:25
hacer es chequear cada uno de los caracteres que se encuentran en el texto, entonces vamos a 00:20:35
preguntar por cada letra que se encuentre en el texto, vamos a preguntar si la letra pasándola 00:20:41
a minúsculas porque no nos interesa si son mayúsculas o minúsculas, si la letra no está 00:20:48
en las letras del abecedario 00:20:53
pero hay que tener cuidado aquí 00:20:57
escoger cuáles letras si son válidas y cuáles no 00:20:59
pero básicamente 00:21:01
primero el espacio si se permite para separar palabras 00:21:02
la A se vale 00:21:06
la A tildada también 00:21:07
B, C, D, E 00:21:08
la E tildada también 00:21:10
F, G, H, I 00:21:11
la I tildada también 00:21:12
J, K, L, M, N 00:21:14
la O tildada también 00:21:19
P, Q, R, S, T 00:21:20
u, u tildada 00:21:23
v, w, x, y, z 00:21:25
esas son 00:21:27
las letras, ah no, en español también se vale 00:21:28
la u con diéresis, entonces ahí está 00:21:31
la u con diéresis también 00:21:33
entonces 00:21:34
si la letra se 00:21:35
encuentra, vamos a hacer esto para arriba 00:21:39
ahí está, si no 00:21:41
se encuentra en estas que pusimos 00:21:43
entonces no es un texto válido, por lo tanto 00:21:45
decimos return false 00:21:47
y listo, de otro modo 00:21:48
cuando salgamos del ciclo 00:21:51
ya habríamos revisado todas las letras que se venían en el texto, todas se encuentran en las letras válidas que pusimos ahí 00:21:52
por lo tanto es un texto válido, decimos return true 00:21:59
ok, aquí ya hemos escrito varias funciones, lo que voy a hacer es probar cada una de ellas, de las funciones que estamos terminando 00:22:02
entonces por ejemplo voy a probar aquí, limpiar pantalla, eso es lo que hace, lo que hace es imprimir un montón de enter 00:22:09
Por lo tanto queda la pantalla limpia o vacía 00:22:18
Pareciera, pero en realidad aquí está todo lo que estaba antes 00:22:21
La otra que vamos a probar es imprimir entrada 00:22:26
¿Qué hace esto? 00:22:31
Bueno, imprime esto 00:22:32
Bienvenido al juego de Orcado creado por Mauricio 00:22:34
Muy bien, ahora vamos a probar la subrutina que se llama leer texto original 00:22:36
Nos recibe parámetros y nos va a decir ingrese la palabra o frase adivinar 00:22:44
Solo puede contener letras y espacios 00:22:48
Voy a probar mandándole un string vacío 00:22:49
Debería decirme que 00:22:52
Oh, falló, está malo 00:22:53
Texto válido 00:22:55
Es texto válido 00:22:56
Hizo falta aquí que 00:22:59
En texto válido diga que 00:23:01
Tiene que 00:23:03
Tener 00:23:04
Al menos un carácter 00:23:06
Aquí deberíamos agregar 00:23:10
Leng de 00:23:13
O simplemente componer 00:23:14
Que si texto es igual 00:23:17
A string vacío 00:23:19
Entonces return false 00:23:21
Ok, ya bueno, vamos a probarla de nuevo 00:23:23
Porque había un pequeño problema 00:23:26
Leer texto original 00:23:27
Ok, espacio vacío 00:23:29
Ok, me dice 00:23:32
El texto solo puede contener letras y espacios 00:23:33
Ingrese la palabra o frase adivinar 00:23:35
Solo puede contener letras y espacios 00:23:37
Está repetido aquí el mensaje 00:23:38
Está muy feo, voy a borrarle algunas cosas 00:23:41
Leer texto original, ingrese la frase adivinar 00:23:43
Nada más esto 00:23:45
probar de nuevo, listo, leer texto original, ingrese la palabra o frase adivinar, solo puede contener que hay espacio vacío 00:23:46
entonces me dice que no, si escribo números y cosas raras me dice que no, pero cuando escribo algo que sí es válido 00:23:57
por ejemplo voy a poner la palabra ahorcado, me la retorna, aquí se ve que me retornó, este es el valor, me retorna un string con esa palabra 00:24:05
También podría hacer cosas con frases largas, por ejemplo, ahorcado es el juego que estamos programando 00:24:13
Ahí está, entonces también se permite 00:24:21
Hasta ahora tenemos eso, ya probamos leer texto original y leer texto original nos ayuda a probar esta otra que se llama texto válido 00:24:23
Vamos a regresar por acá para ver qué más hay que hacer 00:24:33
Ya hicimos leer texto original, limpiar pantalla, ahora vamos con la subrutina que se llama preparar 00:24:36
Para preparar, habíamos dicho que lo que va a hacer es eliminar del texto original cosas que no nos sirven, por ejemplo, tildes, mayúsculas, espacios que el usuario escriba al inicio o al final, todo eso lo vamos a eliminar para comparar las letras que escribe el usuario contra este texto que vamos a producir aquí. 00:24:42
Entonces esta subrutina convierte el texto a minúsculas, sustituye acentos y elimina espacios al inicio y al final. 00:25:02
Entradas, texto a procesar, salidas, texto sin mayúsculas, acentos y espacios al inicio o al final. 00:25:15
Restricciones, texto debe ser un string. 00:25:27
Primero vamos a chequear restricciones 00:25:30
Si el tipo de texto es diferente de string 00:25:33
Entonces vamos a lanzar una excepción 00:25:38
RaiseException 00:25:40
Y le vamos a decir texto debe ser un string 00:25:41
Después de eso, si sí es un string 00:25:45
Entonces tenemos que pasarlo a minúscula 00:25:50
Entonces lo que vamos a hacer es a texto 00:25:52
Le asigno texto.lower 00:25:53
Eso pasa todo a minúscula 00:25:55
Luego hay un método de los string 00:25:57
Que le quita espacios al inicio y al final 00:26:00
Sería texto.strip 00:26:03
Luego queremos quitar tildes 00:26:05
Por lo tanto hay que hacer replace con cada una de las tildes 00:26:08
Por ejemplo texto.replace 00:26:10
Entonces sustituya la A tildada con una A normal 00:26:14
Igual con las demás vocales y las demás acentos 00:26:18
Entonces voy a copiar aquí esto varias veces 00:26:21
La E por una E 00:26:25
La I tildada por una I 00:26:26
La O tildada por una O 00:26:28
Y la U tildada por una U 00:26:31
La U también puede tener diéresis 00:26:35
Entonces con diéresis va sin diéresis 00:26:37
Y esto ya, ya con esto tenemos todo 00:26:40
Una vez que hicimos esto, entonces retornamos la variable texto 00:26:42
Vean que estamos quitando tildes, mayúsculas y espacios al inicio y al final 00:26:45
Eso es todo 00:26:48
Vamos a probar si esto sirve 00:26:49
Preparar 00:26:50
Y entonces le mandamos un texto 00:26:52
Por ejemplo, hola estamos 00:26:54
probando esta 00:26:56
función, vean que 00:26:59
estoy usando mayúsculas 00:27:01
estoy usando tilde, voy a ponerle 00:27:03
aquí un espacio al final 00:27:05
y también voy a ponérselo al inicio para probar de una vez 00:27:07
que hace, ahora estamos probando esta función 00:27:09
le quito la tilde, le quito las mayúsculas 00:27:11
y le quito los espacios, luego 00:27:13
si yo trato de probarla con algo que no es 00:27:14
un string, bueno me tira mi excepción 00:27:17
esto debe ser un string, excelente 00:27:19
ahora vamos a ver que otras subrutinas 00:27:21
necesitamos, ya tenemos 00:27:23
preparar texto, adivinó 00:27:25
not adivinó, entonces ahora 00:27:27
necesitamos hacer la subrutina 00:27:29
que nos dice si el usuario 00:27:31
ya adivinó la palabra 00:27:33
o el texto que estaba adivinando, adivinó 00:27:35
recibe por parámetro el texto y recibe 00:27:37
por parámetro las letras 00:27:39
intentadas, esta 00:27:41
es una 00:27:43
función booleana 00:27:45
lo que va a hacer es darnos true si el 00:27:47
usuario adivinó el texto 00:27:49
entradas, ok, tiene varias 00:27:51
entradas, lo voy a escribir así 00:27:53
El texto es el texto preparado sin tildes ni acentos, después intentadas son las letras que el usuario ha intentado, que ya usó, y salidas sería true si todas las letras del texto ya han sido intentadas, false si no. 00:27:54
Esas serían las salidas, luego tenemos restricciones, a ver que restricciones hay en estas 00:28:19
Bueno, texto debe ser un string que no debería tener letras y acentos 00:28:24
Eso lo podemos chequear aquí o podríamos dejarlo sin chequear porque ya sabemos que 00:28:31
La única función que va a llamar este texto es la función principal 00:28:36
Esta función es la función principal, la que se llama ahorcado 00:28:40
Si nosotros estamos seguros de que esa función solo le va a mandar parámetros válidos 00:28:44
Entonces no es necesario chequear las restricciones 00:28:48
Sin embargo, si uno quiere hacer un programa realmente robusto 00:28:51
Tiene que chequear siempre las entradas de las funciones para que ninguna de esas falle 00:28:55
Entonces depende del nivel de robustez que queramos 00:29:00
Bueno, vamos a hacerlo bien robusto 00:29:03
Entonces el texto debe ser un string de letras sin acentos 00:29:04
Y por otro lado, intentadas también debe ser un string de letras sin acentos 00:29:10
Entonces esa es la documentación de esta función 00:29:16
Y bueno, primero vamos a chequear restricciones 00:29:20
Si el tipo de texto es diferente de string 00:29:22
O el tipo de intentadas que también son string 00:29:27
Es diferente de string 00:29:30
Entonces tenemos que lanzar el error 00:29:32
De que el texto y las letras intentadas deben ser strings 00:29:35
La otra restricción es que solo pueden venir letras 00:29:40
no puede venir en acentos y todo tiene que estar en minúsculas 00:29:45
entonces ya tenemos esa función que chequea que el texto sea válido o no 00:29:48
entonces si no es texto válido, ya lo habíamos hecho antes 00:29:53
vean que la documentación que le pusimos a la función con Python Docs 00:29:58
aquí se ve, para eso es útil usar este tipo de documentación 00:30:02
entonces si el texto no es válido o tampoco es válido las intentadas 00:30:05
O sea, tiene tildes o tiene mayúsculas, otras cosas 00:30:11
Entonces vamos a lanzar una excepción 00:30:15
El texto y las intentadas contienen caracteres no valios 00:30:18
Estamos en la función adivinó 00:30:24
Y ya chequeamos todas las restricciones 00:30:27
Ahora necesitamos ver cada una de las letras que vienen en el texto 00:30:30
Y corroborar si todas están en intentadas 00:30:35
Si alguna no está en intentadas, entonces no ha adivinado 00:30:38
Entonces lo que vamos a hacer por cada letra que esté en el texto 00:30:41
Si la letra es diferente de espacio, eso sí, porque las diferentes palabras pueden venir separadas por espacios 00:30:44
Eso no nos interesa, entonces si la letra es diferente de espacio, es cualquier otra cosa 00:30:52
Si esa letra no está en las intentadas, entonces todavía no ha adivinado 00:30:57
Porque todavía no ha usado esa letra, no ha intentado con esa letra 00:31:03
entonces si la letra no está en intentadas entonces decimos no, no ha adivinado 00:31:07
pero si el ciclo continúa y vemos que todas las letras que son diferentes de espacio no están en las intentadas 00:31:13
entonces quiere decir que ya adivinó porque ya dijo todas las letras que están en el texto 00:31:21
entonces en ese caso diríamos return true, listo 00:31:26
esa sería la función de adivinó 00:31:29
Esta la podemos probar, entonces por ejemplo, quiero ver si adivinó, cuál era el texto, hola, cómo estás, sin tildes 00:31:33
Y las letras que he probado son A, B, C y D, esto debería decirme que no, ok, me dijo que no, está bien 00:31:42
Para ver si adiviné, debería haber probado la O, la H, la L, la A, la C, la M, la E, la S y la T 00:31:49
Si he probado esas, entonces ya adiviné 00:31:59
True, excelente 00:32:02
Ahora, pues esto debería causar un error si le mando algo con tilde 00:32:03
Oh, no lo hizo 00:32:08
Texto válido, que era texto válido 00:32:09
Vamos a revisar un toque 00:32:12
Ah, solo letras, espacios y se aceptan tildes, por supuesto 00:32:13
Entonces debería darme un error si aquí le mando un número 00:32:17
Sí, ahí sí 00:32:20
Sí está en blanco 00:32:21
Tienen caracteres no válidos 00:32:23
Ok, entonces pareciera que está funcionando bien 00:32:25
Ahora vamos a regresar aquí al programa principal para ver qué sigue, ya tenemos esta función de adivinó, ya tenemos el de limpiar pantalla, ahora vamos a imprimir ronda, def imprimir ronda, va a recibir por parámetro el texto que hay que adivinar, va a recibir la cantidad, las letras intentadas, va a recibir la cantidad de intentos y va a recibir por cuál ronda vamos, toda esta información la necesita para poder imprimir. 00:32:28
¿Cuál es la documentación de esta subrutina? 00:32:56
Esta función imprime los mensajes requeridos para cada ronda del juego. 00:32:59
Imprime el número de ronda actual, un mensaje que indica las letras que ya fueron utilizadas, cantidad de intentos fallidos y también escribe el texto. 00:33:07
vamos a decirle entre comillas enmascarado 00:33:25
es decir, vamos a imprimir un espacio, un guión bajo por cada letra que no ha adivinado 00:33:28
va a imprimir una letra por cada letra que sí ha adivinado 00:33:35
y va a imprimir un guión normal en caso de que hayan varias palabras 00:33:40
todo esto lo vamos a escribir separado por espacios para que se quede claro qué es lo que está sucediendo 00:33:45
entonces a eso le vamos a decir texto enmascarado 00:33:50
es para no escribir todo eso que acabo de decir 00:33:52
Entradas, texto, es el texto preparado, sin tildes ni acentos 00:33:55
Intentadas, que son las letras que el usuario ha intentado 00:34:03
Los intentos, cantidad de intentos fallidos que lleva el usuario, que lleva el jugador 00:34:09
Y la ronda, número de ronda por la que va el juego 00:34:15
Salidas, pues entre las salidas tenemos la impresión en pantalla de la información de la ronda 00:34:19
Restricciones, ninguna, vamos a dejarlo como ninguna 00:34:27
Ya sabemos que aquí podemos probar si el texto es un string, si el otro es un entero 00:34:30
Todo eso lo podemos probar, ustedes deciden que tanto nivel de robustez quieren 00:34:35
Pero ya para este nivel yo creo que esta función, ya las restricciones se han chequeado antes en otras partes del juego 00:34:39
Entonces sabemos muy bien que aquí vamos a recibir datos correctos 00:34:47
Entonces tal vez no es necesario hacerlo 00:34:50
Pero depende de cada uno 00:34:51
¿Qué vamos a hacer acá? 00:34:53
Bueno, vamos a imprimir primero por cuál ronda vamos 00:34:53
Le ponemos aquí por cuál ronda vamos 00:34:56
Vamos a imprimir otra cosa que sea letras que ya fueron utilizadas 00:34:59
Para que el usuario sepa con cuáles falló 00:35:04
Eso está en intentadas 00:35:06
Cantidad de intentos fallidos 00:35:08
Y le mandamos aquí intentos 00:35:10
Vamos a dejar un espacio ahí, una línea en blanco 00:35:13
Y vamos a imprimir aquí el texto enmascarado que les decía anteriormente 00:35:15
Bueno, no lo vamos a hacer aquí, vamos a hacer una subrutina 00:35:19
Que se va a encargar de enmascarar el texto 00:35:22
Pero para poder hacer eso necesita el texto que hay que adivinar 00:35:24
Y además cuáles fueron las letras que han sido intentadas 00:35:28
Vamos a imprimir lo que nos devuelva esa subrutina 00:35:31
Va a ser una función que nos devuelve un string 00:35:33
E imprimimos también otra línea en blanco 00:35:35
Ese sería imprimir ronda 00:35:37
Vamos a necesitar la otra subrutina que es enmascarar 00:35:39
Que recibe el texto, también recibe las intentadas 00:35:43
¿Qué va a hacer esta subrutina? 00:35:46
Retorna un string con un guión bajo por cada letra que no ha sido adivinada 00:35:48
Si una letra del texto aparece en las letras intentadas 00:35:56
Entonces le agrega como tal en lugar del guión 00:36:03
Si el texto original tiene espacios, los sustituye con guiones normales 00:36:07
Entradas, va a ser el texto a adivinar 00:36:16
Intentadas, son las letras que el usuario ha intentado 00:36:20
Y salidas, vamos a tener un string con el texto enmascarado 00:36:25
Texto enmascarado, suena como un superhéroe 00:36:31
Superhero es muy raro, por cierto, no va a tener ningún tipo de éxito 00:36:34
Restricciones ninguna 00:36:38
Aquí podríamos de nuevo chequear que texto sea string, que intentadas también 00:36:39
Pero eso ya lo hemos hecho antes en las funciones que llaman a esta 00:36:44
Entonces ya sabemos que viene por ahí 00:36:48
Primero que todo, necesitamos separar el texto en palabras 00:36:49
Entonces para eso vamos a usar el split 00:36:54
El split es así, si yo tengo un texto que dice 00:36:57
Este es el texto a probar 00:37:00
Y a esto le llamo .split 00:37:03
Lo que va a devolverme es una lista con cada una de las palabras que hay acá 00:37:05
¿Cómo sabe cuáles son las palabras? Porque están separadas por espacios 00:37:10
Se separa por espacios y me devuelve una lista que tiene cada una de las palabras que estaban en el string original 00:37:13
Eso es lo primero que vamos a necesitar aquí 00:37:19
Dividir el texto en palabras 00:37:22
Split 00:37:24
Entonces tengo una lista de palabras 00:37:25
Porque vamos a escribir en pantalla cada una de las diferentes palabras 00:37:27
las vamos a poner por separado, entonces por ejemplo, si el texto es hola, adiós, si fuera esto, 00:37:32
entonces nuestra función de enmascarar debería dejar un espacio para cada una de las letras, 00:37:38
después este guión que significa que hay un espacio, adiós, debería devolvernos esto que está acá, 00:37:44
este es el texto enmascarado, suponiendo que no ha adivinado ninguna letra, pero si por ejemplo ya hubiera adivinado la A, 00:37:51
entonces debería venir así, hola, adiós, eso es lo que debería devolvernos la subrutina de enmascarar 00:37:57
necesitamos recorrer por palabra y vamos a ir armando un string nuevo 00:38:04
entonces ese string nuevo va a ser la variable resultado, vamos a hacer que inicie con un string vacío 00:38:08
por cada palabra que se encuentre en la lista de palabras, vamos a iterar a través de la lista de palabras 00:38:15
Lo que vamos a hacer es revisar cada una de las letras que se encuentra en esa palabra 00:38:22
Entonces por cada letra que se encuentre en la palabra 00:38:28
Vamos a preguntar si la letra está entre las intentadas 00:38:31
Entonces hay que mostrarla como está aquí 00:38:35
Si no, hay que mostrar un guión 00:38:37
Entonces eso es lo que vamos a preguntar acá 00:38:40
Si la letra está en intentadas 00:38:42
Entonces al resultado lo que le voy a agregar es la letra 00:38:44
Perdón, la letra y un espacio 00:38:49
Así como está aquí, la letra y un espacio 00:38:52
Ahí, la letra y un espacio, eso es lo que estamos haciendo 00:38:55
Si no, lo que voy a hacer es agregarle un guión bajo y un espacio 00:38:59
Al final de cada palabra voy a separar las palabras con ese guión que está acá 00:39:05
Entonces vamos a separar las palabras con un guión normal 00:39:10
Al final de revisar cada palabra le agrega un guión para separar palabras 00:39:13
Cuando ya terminamos de aquí, return resultado 00:39:17
Va a pasar algo, esto no está bien, pero vamos a probarlo así 00:39:21
Enmascarar, le mandamos el texto 00:39:24
Por ejemplo, ese que dice 00:39:26
Este es el texto a probar 00:39:28
Y digamos que no he adivinado nada 00:39:30
O sea, probé la, qué sé yo, la A 00:39:32
O probé la, cuál letra no está ahí 00:39:34
La X, para que no esté 00:39:37
Entonces probé la X 00:39:39
Oh, hay un error 00:39:39
Intentadas 00:39:41
Taipo, salvaje, aparece 00:39:42
Ahí está, ven 00:39:44
Ah, sí, había una X 00:39:46
Este es el texto a probar 00:39:47
Vean que feo quedó esto aquí 00:39:52
Siempre le deja al final un guión adicional 00:39:53
Le voy a poner más aquí 00:39:56
A, B, C, D, E, F, G 00:39:57
Entonces eso es lo que había adivinado 00:39:58
Está funcionando bien 00:40:00
Excepto por esto 00:40:01
Siempre le está agregando al final esto 00:40:02
Entonces tal vez aquí se lo podemos quitar 00:40:04
Debemos decir que quite 00:40:06
Que vaya desde el inicio hasta los últimos dos elementos 00:40:07
Así está mejor 00:40:11
Este es el texto a probar 00:40:12
Muy bien, entonces ya funciona enmascarar 00:40:15
Ahora lo que tenemos que hacer es probar el de imprimir ronda 00:40:17
Imprimir ronda 00:40:20
Que recibe un montón de cosas 00:40:22
Recibe el texto que queremos adivinar 00:40:23
Voy a poner algo corto 00:40:27
Hola, era la palabra adivinar 00:40:28
Las intentadas son, digamos que A, B y C 00:40:29
La cantidad de intentos va a ser por ahora dos 00:40:32
Vamos a probar con cualquier cosa 00:40:35
Y la ronda va a ser la uno 00:40:36
O la dos, no sé 00:40:38
Eso es lo que va a salir 00:40:39
Ronda número dos 00:40:40
Letras que ya fueron utilizadas 00:40:41
A, B y C 00:40:43
cantidad de intentos fallidos 2 y así es como vamos se ve aquí hola pero no sabemos que es 00:40:43
hola con la única letra que ha adivinado excelente entonces estamos está funcionando bien ahora que 00:40:49
sigue ya tenemos bastantes subrutinas creo que quedan las quedan pocas o quedan bastantes no 00:40:54
sé ahora sigue leer intento esta subrutina se encarga entonces de pues leer una letra de el 00:41:00
usuario y enviarla de vuelta es una función entonces leer intento pero recibe por parámetros 00:41:08
las letras que fueron intentadas para que para que si el usuario vuelve a usar una letra que ya había 00:41:14
usado entonces se la vuelve a pedir vamos a decir aquí esto es una función que pide al usuario que 00:41:20
escriba una letra para adivinar si ya se encuentra en las intentadas o no es una letra debe imprimir 00:41:26
un mensaje de error y volver a pedir la letra 00:41:37
aquí no vamos a lanzar una excepción, aquí lo que vamos a hacer es que pedimos de nuevo 00:41:41
el dato para que se quede el usuario ahí hasta que ingrese 00:41:45
un dato válido, entradas, las entradas son, bueno las intentadas 00:41:49
son letras que el usuario ha intentado 00:41:53
salidas, un string con la letra elegida 00:41:57
por el usuario, restricciones, pues ninguna 00:42:01
esta es nuestra documentación 00:42:05
para leer un intento, bueno voy a dejar aquí 00:42:07
un espacio en blanco, una línea ahí 00:42:09
para separar un poco las cosas, para que no salga 00:42:11
todo tan pegado y voy a guardar 00:42:13
en la variable letra lo que el usuario 00:42:15
escriba, input, digite 00:42:17
una letra, vamos a pasar la letra 00:42:19
a minúsculas para evitar cualquier 00:42:21
problema con esto, lower 00:42:23
ahora tenemos que hacer un ciclo 00:42:24
que le pida, si el usuario aquí escribió cualquier 00:42:26
cosa, si el usuario escribió un número por ejemplo 00:42:29
entonces hay que volverlo a pedir, las letras 00:42:31
que puede escribir solo son de la 00:42:33
hasta la zeta incluyendo la ñ si no me equivoco mientras largo de letra el string sólo puede ser 00:42:35
de 1 entonces si es diferente a 1 o la letra es menor que la minúscula de a o la letra es mayor 00:42:43
que la mayúscula minúscula de z o la letra ya está en las intentadas cualquiera de esos casos 00:42:53
tenemos que volver a pedir de nuevo 00:43:00
lo que dudo ahorita es si esto sirva 00:43:02
con una ñ, bueno ya lo probamos 00:43:04
por favor ingrese 00:43:06
una letra que no 00:43:08
haya intentado 00:43:10
y le podemos imprimir aquí las intentadas 00:43:12
para que mire que es lo que está pasando 00:43:14
intentadas, luego de eso 00:43:16
a letra le vamos a asignar el input 00:43:18
otra vez de digite 00:43:20
una letra y de nuevo 00:43:22
pasamos la letra a minúscula 00:43:24
letra.lower 00:43:26
Luego dejamos de nuevo una línea en blanco y return letra 00:43:28
Vamos a probar a ver si esto funciona 00:43:32
Supongamos que solo había intentado la A 00:43:35
Digite una letra, quiero probar con la Ñ porque tengo mil dudas 00:43:37
Por favor ingrese una letra que no haya intentado 00:43:40
No sirve con la Ñ, tenemos problemitas porque la Ñ sí es importante 00:43:42
Ahí está, probé con la D y la D sí funcionó 00:43:47
La A no me la aceptó porque ya estaba entre las intentadas 00:43:50
Aquí tenemos que cambiar, vamos a hacer lo siguiente 00:43:54
Si la letra no está en este string 00:43:57
Vamos a hacer parecido como hicimos antes 00:44:00
A, B, C, D, E, F, G, H, I, J, K, L, M, N, Ñ, O, P, Q, R, S, T, U, W, X, Y, Z 00:44:02
Ahí están todos 00:44:09
Si la letra no está ahí, no la vamos a aceptar 00:44:11
Vamos a probar de nuevo 00:44:13
Leer intento de A 00:44:14
Ya probamos la A 00:44:16
Entonces si le digo A, no 00:44:17
Si le digo un número, no 00:44:19
Si le digo estos símbolos raros, no 00:44:20
Si le digo una Ñ, ya me la aceptó 00:44:23
leer intento de B 00:44:25
parece que está bien, vamos a dejarlo así 00:44:27
ya está aceptando, tuve que hacer esto 00:44:30
el otro estilo era 00:44:32
como un poco más elegante 00:44:33
porque decía entre cuáles 00:44:36
no debía estar, pero no funcionó 00:44:38
con la ñ, así que estamos poniendo 00:44:39
explícitamente cuáles son las letras que sí se están 00:44:41
incluyendo, que sí se están aceptando 00:44:44
regresamos aquí al programa 00:44:45
para ver por dónde 00:44:48
vamos, ya hicimos el de leer 00:44:50
intentos, ahora hay que hacer 00:44:51
esta función cita que nos dice si acertó o no acertó un intento esta función de acierta intento 00:44:53
recibe por parámetro un texto y una letra y esto es una función booleana que dice si un intento es 00:45:01
correcto o no entradas texto que se está adivinando y letra que intentó el usuario salidas retorna 00:45:11
true si la letra 00:45:22
se encuentra en el texto 00:45:24
a adivinar, false 00:45:26
si no, restricciones 00:45:28
ninguna 00:45:30
no vamos a chequear restricciones 00:45:31
esta función en realidad es muy 00:45:34
sencilla porque simplemente hay que decir 00:45:36
si la letra está en texto 00:45:38
eso es una expresión booleana 00:45:40
¿cierto? nos va a decir si 00:45:42
la letra que estamos poniendo, si el string 00:45:43
que está en esta variable está dentro de este otro 00:45:46
eso es básicamente lo que queremos devolver 00:45:48
Tal vez esta función no era tan necesaria 00:45:50
Pero sí le agrega como un significado al asunto 00:45:52
Ahora dice que acierta el intento 00:45:56
Mientras que letra y texto no nos dicen mucha cosa 00:45:57
Entonces regresamos por acá 00:46:00
Y estamos, creo que ya vamos terminando 00:46:01
Acierta intento 00:46:05
Esta es la función que nos dice si acertó 00:46:06
Ahora nos queda imprimir mensaje de acierto 00:46:09
Imprimir mensaje de no acierto 00:46:11
Adivino, ya la hicimos 00:46:13
Imprimir mensaje de victoria 00:46:14
Mensaje de derrota 00:46:15
Leer, jugar nuevamente 00:46:16
Nos quedan un montón de subrutinas que son de interfaz 00:46:17
Entonces ahora vamos a hacerlas todas seguidas aquí 00:46:21
Para estas no voy a hacer documentación 00:46:25
Porque son cosas muy sencillas 00:46:28
Pero todas deberían tenerlo 00:46:30
Primir, mensaje, acierto 00:46:32
Este mensaje sale cuando adivino una letra 00:46:34
Ha adivinado 00:46:37
Y una cara feliz 00:46:38
Vean que muy sencillo 00:46:40
Pero si queremos después que este programa sea un poco más complejo 00:46:42
Podemos agregarle aquí más funcionalidad 00:46:45
después imprimir mensaje de no acierto, cuando el usuario no adivina la letra entonces vamos a decirle al usuario letra no encontrada, que triste has fallado, letra no encontrada y bueno una carita triste porque no encontré esa letra y lo van a ahorcar, es que hay que pensar también en las implicaciones de este juego, es muy violento entonces por eso al menos merece una cara triste 00:46:47
Imprimir mensaje de Victoria 00:47:17
Entonces nos dan el texto original 00:47:21
Y vamos a imprimir un mensaje que diga 00:47:22
Felicidades, ha adivinado el texto 00:47:25
Y le imprimimos el texto original que hemos puesto para adivinar 00:47:28
Y la otra subrutina es imprimir mensaje de Rota 00:47:33
También tiene el texto original por parámetro 00:47:38
Y vamos a decir print 00:47:40
Ya no son felicidades, vamos a ser un poco más solemnes 00:47:42
ha perdido el texto 00:47:45
a adivinar, era 00:47:46
y le vamos a imprimir aquí texto 00:47:48
original, listo 00:47:50
¿qué nos queda? nos queda una subrutina 00:47:54
que se llama leer jugar 00:47:56
nuevamente, esta subrutina 00:47:58
lo que hace es preguntarle 00:48:00
al usuario si desea jugar 00:48:02
de nuevo o no, ya esta es una de las últimas 00:48:04
leer jugar nuevamente 00:48:07
si, a esta si le voy a hacer 00:48:09
documentación, es una función 00:48:10
booleana que pregunta 00:48:12
al usuario si desea 00:48:14
jugar de nuevo, solo acepta S o N como respuesta, si el usuario escribe alguna cosa que no sea un 00:48:17
sí o no, una S o N, entonces sigue preguntando, entradas pues no tiene ninguna entrada, salidas, 00:48:25
TRUE si el usuario escribe S, FALSE si no, restricciones, ninguna, entonces qué va a 00:48:32
hacer esta subrutina, pues primero vamos a imprimir hay una línea en blanco para dejar 00:48:41
espacio y vamos a preguntarle la respuesta es input desea jugar de nuevo y le ponemos aquí 00:48:45
sn tal vez ustedes no tienen la costumbre o nunca jugaron con juegos que fueran todos hechos en 00:48:53
consola pero cuando yo estaba pequeñillo yo recuerdo que muchos de los juegos que habían 00:48:59
eran sólo en texto sólo era consola entonces todo eran este tipo de preguntas así como sí o no desea 00:49:04
continuar, desea hacer tal cosa 00:49:10
entonces es curioso 00:49:12
pero bueno, ustedes tal vez no han jugado 00:49:14
juegos así, pero todavía hay juegos de consola 00:49:16
lo que vamos a hacer ahora es pasar 00:49:18
respuesta a minúscula por aquello 00:49:20
que el usuario haya escrito en mayúscula 00:49:22
y mientras la respuesta 00:49:24
que el usuario escribió no esté 00:49:26
en esta lista 00:49:28
que tiene una S y tiene 00:49:29
una N, para que sólo pueda 00:49:32
aceptar esas dos cosas 00:49:34
respuesta le vamos a asignar 00:49:36
input de 00:49:38
Desea jugar de nuevo 00:49:40
Sí o no, o sea, estamos preguntándole de nuevo 00:49:42
La misma cosa, y cuando salimos 00:49:44
De este ciclo ya tuvo que haber 00:49:46
Escrito o una S o una N 00:49:47
No le queda de otra, vamos a hacer 00:49:50
Respuesta es igual a 00:49:52
Respuesta.lower 00:49:54
Otra vez 00:49:56
Y respuesta es igual a 00:49:57
Sí 00:50:00
Leemos la respuesta del usuario 00:50:01
La pasamos a minúscula, si no está en S o N 00:50:04
Entonces seguimos otra vez 00:50:06
Volvemos a preguntarle, volvemos a guardarlo 00:50:07
y la volvemos a pasar a minúscula, hasta que escriba una S o una N y nos salimos de este ciclo 00:50:09
si la respuesta es igual a S, entonces esto va a retornar true 00:50:13
si no, va a retornar false, entonces por eso aquí estamos diciendo que retorne esta expresión 00:50:17
probemos esta subrutina, bueno no hemos probado esas otras 00:50:21
de imprimir, pero son tan sencillas que las vamos a dejar así, y también la de acierta 00:50:25
intento, es muy sencilla, esperemos que no haya ningún error ahí 00:50:29
pero creo que no, leer, jugar nuevamente 00:50:33
Desea jugar de nuevo 00:50:37
G, 4, Y 00:50:40
Naruto, no, no acepta nada 00:50:42
Pero si pongo una S, me vuelve true 00:50:45
Más cosas ahí, no me va a aceptar 00:50:46
Si pongo una N, me retorna false 00:50:48
Eso es justamente lo que queremos 00:50:50
Ahora nos falta, si no me equivoco 00:50:52
Solamente nos falta imprimir el mensaje 00:50:54
Despedida, que es cuando el jugador 00:50:56
Ya termina el juego 00:50:59
Entonces vamos a imprimir aquí 00:51:01
Imprimir 00:51:02
Mensaje despedida 00:51:04
Este es un mensaje que simplemente dice 00:51:06
Gracias por jugar 00:51:08
Gracias por jugar a Orcado 00:51:10
Nos vemos pronto 00:51:12
Alguna tontera así 00:51:14
Ya está listo 00:51:16
Ahora básicamente es probarlo y ver que 00:51:18
Funcione correctamente 00:51:20
Voy a ponerle aquí al final del archivo 00:51:21
Una llamada a la función 00:51:24
Principal para que cuando 00:51:26
Le de F5 aquí 00:51:28
Se ejecute de una vez el juego 00:51:30
Bienvenido al juego de Orcado creado por Mauricio 00:51:31
Ingrese la palabra o frase a adivinar 00:51:34
Solo puede contener letras y espacios 00:51:37
Bueno, entonces se supone que aquí una persona 00:51:39
Viene y escribe cuál es la frase a adivinar 00:51:42
Y le voy a poner, no sé, ser o no ser 00:51:45
Ah, hay un problema 00:51:48
Dice el texto, el problema se dio a ver en la función adivinó 00:51:50
Ajá, en la función adivinó, intentadas está vacía 00:51:55
Entonces el texto y las intentadas contienen caracteres no válidos 00:51:58
Vamos a regresar aquí a la función adivinó 00:52:03
La función adivinó está cayéndose porque le pusimos que no puede aceptar strings vacíos 00:52:07
Pero la verdad es que intentadas sí puede ser un string vacío 00:52:13
Lo que voy a hacer es quitarle esta parte en las restricciones 00:52:19
Que solo chequee que el texto sea válido 00:52:23
Como ya dijimos, más bien tenemos un código que está chequeando demasiadas restricciones 00:52:26
porque cuando escribimos acá nuestra frase ya esa frase se está pasando a minúsculas 00:52:32
se le están quitando los acentos entonces el texto ya a partir de ahí es válido 00:52:37
entonces estar chequeando por todas partes si el texto es válido más bien es contraproducente 00:52:40
porque es demasiado y en este caso hasta nos está causando problemas 00:52:44
entonces vamos a hacer esta opción que es quitarle lo que hice que fue quitarle el chequeo de restricciones 00:52:48
a esa función de adivinó entonces ingrese la palabra o la frase adivinar ser o no ser 00:52:55
Ok, ahí está, ahora sí lo aceptó 00:53:00
Dice ronda número 1, letras que ya fueron utilizadas 00:53:02
Ninguna, cantidad de intentos fallidos 00:53:04
Cero, y ahí está nuestra frase 00:53:06
Enmascarada, entonces supongamos 00:53:08
Que soy otra persona y que no sé que estoy adivinando 00:53:10
Entonces yo digo, bueno, la letra más 00:53:13
Común en el idioma español es la E 00:53:14
Entonces me sale 00:53:17
Un error, tenemos letra 00:53:18
Intento is not defined 00:53:20
En la función ahorcado 00:53:22
En la línea 24 00:53:24
Entonces vamos a venir acá 00:53:27
es esta, letra intento 00:53:28
no está, ah bueno es que aquí me equivoqué 00:53:31
le puse letra 00:53:33
letra intento 00:53:34
bueno ya lo corrigí, esta variable 00:53:36
estaba mal escrita, va de nuevo 00:53:38
aquí vamos a ir chequeando todos los 00:53:40
errorcitos que van a ir saliendo 00:53:42
ser o no ser, ok 00:53:44
entonces digite una letra, había dicho que quería 00:53:46
usar la e, de nuevo hay 00:53:48
otro error, dice intentas 00:53:50
eso está en la línea 29 00:53:52
entonces vamos a ir a la línea 29 00:53:54
intentos, no intentas 00:53:57
ya, corregido ese error 00:54:00
vamos a ver si ya funciona 00:54:02
ser o no ser, digite una letra 00:54:03
la e, otra vez 00:54:06
hay un problema, ah es que que tonto 00:54:08
aquí cambié intentadas 00:54:10
es que era intentadas 00:54:12
así se llama verdad, intentadas 00:54:14
intentadas, le vamos a agregar la letra 00:54:16
intento, no a los intentos 00:54:18
los intentos le sumamos, intentos es un entero 00:54:20
claro, aquí el error dice que no se puede 00:54:22
sumar entero con string, porque 00:54:24
Aquí yo tenía intentos 00:54:26
Que es un string y letra de intentos 00:54:28
Que era un entero 00:54:30
Y letra de intentos que es un string 00:54:32
Entonces eso no funcionó, pero ya lo corrigí 00:54:34
Eso fue que me equivoqué en el nombre de la variable 00:54:36
Y va de nuevo 00:54:38
La frase es ser o no ser 00:54:39
La letra E 00:54:42
Si adiviné algo, está funcionando 00:54:43
Voy a probar aquí con cualquier cosa 00:54:46
Ponerle un número, no, pues ingrese una letra 00:54:48
Esto ya lo habíamos probado, pero es para que vean que sí 00:54:50
Las intentadas ha sido solo la E 00:54:52
Creo que voy a probar la A 00:54:54
La A no está, entonces intentos fallidos 1 00:54:55
Ingreso una letra, la B, he fallado 00:54:58
La A, no, la A ya la hice 00:55:02
¿Qué pasa si le pongo A? Ok, me dice que no 00:55:03
S, ¿qué era? Ser o no ser 00:55:05
Ah bueno, la O, lo malo es que ya sé qué dice 00:55:08
Pero tal vez con letras, palabras tan cortas está un poco difícil 00:55:10
Voy a ganar, ok, voy a hacer ser o no ser 00:55:14
Adivinado, felicidades, adivinado el texto ser o no ser 00:55:17
Ahí está, entonces ya me dijo que gané el juego 00:55:21
¿Desea jugar de nuevo? Voy a decirle que sí 00:55:23
Ingrese la palabra o frase adivinar 00:55:25
Solo puede contener letras o espacios 00:55:27
Entonces ahora podríamos poner otra frase 00:55:28
El sol se pone por el oeste 00:55:31
No sé, no se pregunten de dónde saco estas palabras 00:55:34
Pero bueno, estas frases 00:55:37
Digito una letra, la A 00:55:38
No hay A's, voy a poner una E 00:55:40
Si hay E, una O 00:55:42
También hay O, una I 00:55:43
No hay I 00:55:45
Estoy dándome cuenta que el mensaje 00:55:46
De que si la encontró o no la encontró 00:55:48
Está quedando justamente después 00:55:50
o antes de imprimir este montón de espacios en blanco, entonces no se ve, esto es un error que hay que corregir, vamos a tenerlo por ahí, mientras seguimos probando, voy a perder, la B, la C, la D, la E, la F, la G, hay un error aquí, ya perdió, ya hizo los intentos, ya falló 7 veces, letra no encontrada, ha perdido, 00:55:54
El texto adivinar era texto original 00:56:21
No quiero jugar de nuevo 00:56:23
Gracias por jugar Orkado, nos vemos pronto 00:56:25
Entonces vamos a ir un toque a este 00:56:27
Subrutina que dice 00:56:29
Que están los mensajes aquí 00:56:31
Finales, ven si había un error 00:56:33
En las subrutinas que supuestamente 00:56:34
Eran tan simples que no podían tener errores 00:56:37
Bueno, ahí está, eso me pasa por no probarlo 00:56:39
Probarlo de nuevo 00:56:42
Ah, vamos a corregir lo otro 00:56:43
Que se está imprimiendo 00:56:44
El mensaje de letra no encontrada 00:56:46
O letra adivinada y después se borra 00:56:49
todo lo que hay en la pantalla eso es porque aquí precisamente limpiamos la pantalla apenas va a 00:56:51
empezar la ronda para evitar problemas voy a quitarle esto más bien no se imprima en esos 00:56:57
espacios porque nos están causando problemas y creo que habría que cambiar un poco la lógica 00:57:03
de ese ciclo otra frase para adivinar la frase es a qué hora termina este vídeo si ahí está 00:57:07
intentos fallidos, digite una letra 00:57:15
A, E, I, O 00:57:17
O, y hay U también 00:57:19
B, fallé 00:57:22
ahora si ven, aquí se ve si fallé 00:57:23
o no fallé, antes no se veía 00:57:25
letra no encontrada 00:57:27
tal vez a la hora de imprimir la ronda 00:57:28
sería todavía dejar un pequeño espacio 00:57:31
ahí para que no salga pegado 00:57:34
entonces antes de esto aquí 00:57:35
imprimir una línea en blanco, así como está 00:57:37
ya casi termina 00:57:39
el video 00:57:41
A, E, I, O 00:57:42
Ya fallé la U 00:57:45
Letra no encontrada 00:57:47
B, V, D, C, S 00:57:48
Ahí está 00:57:52
Llevamos dos intentos fallidos 00:57:54
La D, ya la intenté 00:57:56
La F 00:57:57
Fallé en la G 00:57:58
La H tampoco, ya llevo 5 00:58:01
La I, ya le he hecho la J 00:58:04
Volví a fallar 00:58:06
La K va a fallar 00:58:07
Letra no encontrada, ha perdido 00:58:09
El texto de divinar era, ya casi termino el video 00:58:11
¿Desea jugar de nuevo? No 00:58:13
Listo, pues este video se hizo un poco largo 00:58:14
Pero si quería compartir con ustedes el proceso de creación de algo 00:58:18
Desde cero hasta tener el programita 00:58:23
Aquí todavía puede tener errores, hay que probarlo más 00:58:26
La lógica principal la hicimos de primero 00:58:29
Definimos que era lo que había que hacer en términos de subrutinas que todavía no existían 00:58:32
Y después nos pusimos a programar cada una de las subrutinas 00:58:36
Probándolas por separado, viendo que funcionaran bien 00:58:39
y finalmente probamos de forma integral ya todo el programa funcionando 00:58:42
vimos que surgen nuevos errores que son parte de la interacción entre las diferentes subrutinas 00:58:47
pero ya una vez corregidos esos pequeños problemas tenemos el programa completo 00:58:53
entonces listo, si tienen alguna duda o si tienen alguna pregunta me lo pueden enviar 00:58:58
o dejar en los comentarios, como sea, muchas gracias, nos vemos pronto 00:59:05
Gracias. 00:59:12
Valoración:
  • 1
  • 2
  • 3
  • 4
  • 5
Eres el primero. Inicia sesión para valorar el vídeo.
Idioma/s:
es
Idioma/s subtítulos:
es
Materias:
Tecnología, Tecnologías de la Información
Etiquetas:
Tutorial
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Bachillerato
    • Primer Curso
    • Segundo Curso
Autor/es:
Muricio Avilés
Subido por:
Miguel R.
Licencia:
Reconocimiento - No comercial - Compartir igual
Visualizaciones:
92
Fecha:
2 de abril de 2024 - 12:22
Visibilidad:
Público
Enlace Relacionado:
https://www.youtube.com/watch?v=jtg9NO-GEcU
Centro:
IES PRINCIPE FELIPE
Duración:
59′ 29″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
190.25 MBytes

Del mismo autor…

Ver más del mismo autor

Comentarios

Para publicar comentarios debes entrar con tu nombre de usuario de EducaMadrid.

Comentarios

Este vídeo todavía no tiene comentarios. Sé el primero en comentar.


EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid