Google+ Seguidores

domingo, 5 de abril de 2015

Juego en python: el ahorcado (parte 3)

    0

Juego El ahorcado (parte 3)
Juego El ahorcado (parte 3)
Continuamos con el análisis del juego: el ahorcado que hice ya algún tiempo y tenía medio abandonado.


Puedes ver las entradas anteriores aquí:

El ahorcado parte 1
El ahorcado parte 2

Métodos

Los métodos son como las funciones, pero siempre están asociados a un valor. Un ejemplo sería el método lower() de las cadenas, que devuelve la cadena en minúsculas. Pero para llamarlos no se utilizan como las funciones: lower("Hola"), sino con un punto, "Hola".lower()

El método lower() y upper() de las cadenas

Probemos escribir en el shell interactivo lo siguiente para comprobar los métodos:

>>> "Hola Mundo".lower() #Convierte la cadena en minúsculas
"hola mundo"
>>> "hola mundo".upper() #Convierte la cadena en mayúsculas
"HOLA MUNDO"

También podemos utilizar estos métodos con variables:

>>> nombre = "Elena"
>>> nombre.lower()
"elena"
>>> nombre.upper()
"ELENA"

Esto no cambia el valor de la variable (seguirá siendo "Elena).

El método reverse() y append() para listas

El tipo de datos listas también tiene métodos (puedes ver más sobre listas aquí: Listas en python). El método reverse() invierte el orden de los elementos de una lista.
Podemos probar en el shell interactivo:

>>> variable = [1,2,3,4,5,6,"perro","gato"]
>>> variable.reverse()
>>> variable
["gato","perro",6,5,4,3,2,1]

El método append() es uno de los más utilizados al trabajar con listas. Este método agrega elementos a las listas.

>>> frutas = []
>>> frutas.append("manzana")
>>> frutas
["manzana"]

>>> frutas.append("banana")
>>> frutas
["manzana","banana"]

Estos métodos hacen cambiar las listas (no devuelven una nueva lista).

El método split() para listas

Cuando definimos las palabras a utilizar en el juego, utilizamos el método split (que al igual que el método lower() y upper(), es un método para trabajar con cadenas).

palabras = 'sombra animal django oveja aprender ejercicios caballo perro vaca computadora python abeja diente conejo mantel mesa basura escritorio ubuntu gorro parque amuleto cama cuarto descargar curso diario pythondiario vaso cuadro foto revista esdrujula parlantes radio tutorial banana naranja manzana celular casco ventana silla pileta juegos televisor heladera modulos cocina timbre lavarropas estufa enchufe futbol pelota pizarron cargador factura papel impresora telefono remedio planta vegetal aves luna electricidad copa fernet google lenguaje internet esposa jarra microondas manual sarten cortina musica pato'.split()

La variable palabras, es una variable con muchas palabras separadas por un espacio y al final cuenta con una llamada al método split. Este método hará que la variable se convierta en una lista de palabras separadas por comas (en este caso el método separa las palabras en cada espacio).
En este ejemplo, el método nos ahorra tener que estar escribiendo una por una las palabras de una lista (palabras = ["sombra", "animal", "django", ...)

Veamos un ejemplo en el shell interactivo:

>>> frutas = "manzana banana pera pomelo limon naranja"
>>> frutas.split()

["manzana", "banana", "pera", "pomelo", "limon", "naranja"]

El resultado es una lista con 6 palabras (frutas), los espacios no son incluidos en ningunas de las palabras.
En nuestro juego puedes agregar o quitar las palabras que quieras, pero asegúrate de dejar un espacio en blanco entre ellas.

Como funciona el código

La primera función que definimos es buscarPalabraAleat(listaPalabras). A esta función se pasa como parametro (listaPalabras), la lista de palabras a utilizar en el juego. La función devolverá una sola palabra secreta de la lista (listaPalabras).

def buscarPalabraAleat(listaPalabras):
 # Esta funcion retorna una palabra aleatoria.
 palabraAleatoria = random.randint(0, len(listaPalabras) - 1)
        return listaPalabras[palabraAleatoria]

palabraAleatoria = random.randint(0, len(listaPalabras) -1)
La variable palabraAleatoria almacena un índice aleatorio de la lista listaPalabras. Esto se hace llamando al método randint() con dos argumentos. El primer argumento es 0 (el primer elemento de la lista) y el segundo argumento es el valor de la expresión: len(listaPalabras) -1 (que será el último valor posible de la lista de palabras).

El primer elemento de una lista tiene índice 0 y no 1. Si tenemos una lista con 3 elementos, el índice del valor 1 es 0, el del segundo es 1 y el del tercer elemento es 2. La cantidad de elementos es 3, pero el índice 3 sería después del último índice. Ésta es la razón de porque en la lista anterior se resta 1 (-1) a la expresión. Este código funcionará sin importar el tamaño de listaPalabras.

return listaPalabras[palabraAleatoria]
Se devolverá la palabra de listaPalabra, que tenga el índice aleatorio que se almacenó en palabraAleatoria.
Hagamos de cuenta que la función buscarPalabraAleat() es utilizada para la lista ["manzana", "banana", "pera", "pomelo", "limon", "naranja"], y que el índice aleatorio que busca desde 0 a 5 fue 2. Eso significa que la sentencia return listaPalabras[palabraAleatoria] devolverá: palabraAleatoria[2] en este caso "pera". Esta es la forma que utiliza la función buscarPalabraAleat() para devolver una palabra aleatoria.

Así que, la entrada para esta función es una lista de cadenas, y la salida será una cadena aleatoria de esta lista de cadenas. En nuestro juego será útil seleccionar una palabra al azar para que nuestro jugador adivine.

Luego, necesitamos una función que muestre el dibujo del ahorcado en pantalla. También se mostrará en pantalla los intentos correctos y erróneos del jugador.

def displayBoard(AHORCADO, letraIncorrecta, letraCorrecta, palabraSecreta):
    print(AHORCADO[len(letraIncorrecta)])
    print ""
    fin = " "
    print 'Letras incorrectas:', fin
    for letra in letraIncorrecta:
        print (letra, fin)
    print ""
    espacio = '_' * len(palabraSecreta)
    for i in range(len(palabraSecreta)): # Remplaza los espacios en blanco por la letra bien escrita
        if palabraSecreta[i] in letraCorrecta:
            espacio = espacio[:i] + palabraSecreta[i] + espacio[i+1:]
    for letra in espacio: # Mostrará la palabra secreta con espacios entre letras
        print (letra, fin)
    print ""

Este código define una nueva función llamada displayBoard(). Esta función tiene 4 parámetros:

AHORCADO - Una lista de cadenas (con múltiples líneas) que mostraran el dibujo del ahorcado. La variable global AHORCADO será utilizada para este parámetro
letraIncorrecta - Una cadena con las letras que el jugador haya utilizado pero que no estén en la palabra
letraCorrecta - Una cadena con las letras que el jugador haya utilizado y estén en la palabra
palabraSecreta - Una cadena con la palabra secreta que el jugador está tratando de adivinar

El primer print mostrará el tablero para comenzar a jugar. La variable AHORCADO será una lista de cadenas dependiendo de la cantidad de letras incorrectas. AHORCADO[0] - muestra una horca vacía. AHORCADO[1] - muestra la horca con la cabeza (cuando el jugador elige una letra incorrecta), AHORCADO[2] - muestra la cabeza y el cuerpo (cuando el jugador elige 2 letras incorrectas) y así sucesivamente hasta AHORCADO[6] - muestra el cuerpo completo (el jugador pierde).

El número de letras incorrectas letraIncorrecta reflejará la cantidad de letras incorrectas elegidas por el jugador. Sabemos la cantidad al llamar len(letraIncorrecta). Si el jugador lleva 4 letras incorrectas, se mostrará en pantalla la cadena AHORCADO[4]. Esto es lo que evalúa la sentencia: print (AHORCADO[len(letraIncorrecta)]).

En las siguientes lineas :

fin = " "
    print 'Letras incorrectas:', fin
    for letra in letraIncorrecta:
        print (letra, fin)

Se imprime la cadena: Letras incorrectas y un espacio vacío al final en lugar de una nueva linea.

Lo siguiente, es un nuevo tipo de bucle (llamado bucle for: puedes ver más aquí). Un bucle for utiliza comúnmente la función range(). Ambos se explican en las siguientes lineas.

La función range() y list()

Solo se verán algunos ejemplos, si quieres ver más sobre el módulo random puedes ir a la siguiente entrada: http://www.pythondiario.com/2013/06/modulo-random-en-python-con-ejemplos.html

Veamos un ejemplo en el shell interactivo:

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

La función list() es similar a la función str() e int(). Convierte los elementos pasados en una lista (en este caso un rango de 10 número que va desde 0 hasta 9). Es fácil generar una lista grande de número con la función range(). Probemos en el shell interactivo la sentencia: list(range(10000):

>>>list(range(10000))
[0, 1, 2, 3, 4, 5, .............9998, 9999]

La lista es tan grande que no se visualiza toda en la pantalla. Podemos almacenar toda esta lista de números en una variable:

>>> num = list(range(10000))

Si pasamos dos parámetros en la función range() se devolverá una lista desde el primer parámetro hasta el segundo sin ser incluido. Haremos lo siguiente en el shell interactivo:

>>> list(range(10,20))
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

La función range() es generalmente utilizada en los bucles for.

Ciclo for

El ciclo for es muy útil a la hora de recorrer elementos en una lista. Es diferente al bucle while, que se cumple mientras una condición sea verdadera. Una sentencia for comienza con la palabra clave for, seguido por un nuevo nombre de variable, seguido por la palabra clave in, seguido por un valor iterable.
Un valor iterable es un valor de tipo lista, de rango o datos de cadena.

Veamos un ejemplo en el shell interactivo:

>>> for i in range(5):
>>> ... print ("Ahora i vale:" + str(i))
>>> ...
Ahora i vale: 0
Ahora i vale: 1
Ahora i vale: 2
Ahora i vale: 3
Ahora i vale: 4

El range(5) equivale a la lista [0, 1, 2, 3, 4]. Sobre esta lista va a iterar el ciclo for. La primera vez que se ejecute este código la variable i tomara el valor 0. La siguiente ves i tendrá el valor 1 y así sucesivamente.
La sentencia for convierte automáticamente el range(5) en una lista, así que no hay necesidad de utilizar la sentencia list(range(5)) en la sentencia for.

Las listas y cadenas son también tipos de datos iterables. Probemos un ejemplo en el shell interactivo:

>>> for fruta in ["pera", "manzana", "naranja"]:
>>> ... print "Me gusta la" + fruta
>>> ...

Me gusta la pera
Me gusta la manzana
Me gusta la naranja

>>> for i in "Python Diario":
>>> ... print i
>>> ...

P
y
t
h
o
n

D
i
a
r
i
o

El resto de la función displayBoard() muestra las letras incorrectas y crea la cadena de la palabra secreta con las letras aún no adivinadas en espacios en blanco.

print 'Letras incorrectas:', fin
    for letra in letraIncorrecta:
        print (letra, fin)
    print ""

El bucle for itera sobre las letras incorrectas y las muestra en pantalla.

Porción de lista

Podemos crear una lista con una porción de otra lista. Lo que hacemos en el código es especificar los índices (comienzo y final) entre corchetes después de una lista. Veremos un ejemplo en el shell interactivo:

>>> fruta = ["banana", "manzana", "pera", "melon"]
>>> fruta[1:3]
["manzana", "pera"]

La expresión fruta[1:3] da como resultado una lista que va desde el índice 1 (sin incluir) hasta el índice 3. Si se omite el primer índice, Python supone que arranca desde el índice 0.

>>> fruta = ["banana", "manzana", "pera", "melon"]
>>> fruta[:2]
["banana", "manzana"]

Si se omite el segundo índice, Python supone que va hasta el final de la lista:

>>> fruta = ["banana", "manzana", "pera", "melon"]
>>> fruta[2:]
["pera", "melon"]

Esta es una forma sencilla de obtener una porción de una lista. Podemos también utilizar las porciones en las cadenas como lo hacemos con las listas. Cada caracter de una cadena es como un elemento de una lista. Veamos un ejemplo en el shell interactivo:

>>> blog = "Mi Diario Python"
>>> blog[3:12]
"Diario Py"

>>> blog[:9]
"Mi Diario"

>>> blog[3:]
"Diario Python"

En la siguiente parte del código de nuestro juego, utilizamos porciones de listas.

Palabra secreta con espacios en blanco

Ahora viene el código que muestra la palabra secreta, pero con líneas en blanco para las letras que no han sido adivinadas.

espacio = '_' * len(palabraSecreta)

Lo que hacemos acá es multiplicar la cantidad de letras de la palabra secreta por el "_" (guión bajo), así de esta forma sustituimos los caracteres de la palabra secreta por los guiones. Recordar que el operador * se puede utilizar tanto para los números como los caracteres.

for i in range(len(palabraSecreta)): # Remplaza los espacios en blanco por la letra bien escrita
        if palabraSecreta[i] in letraCorrecta:
            espacio = espacio[:i] + palabraSecreta[i] + espacio[i+1:]

Este ciclo for pasa por cada letra de la palabra secreta y remplaza el guión por la letra real si existe una letra correcta.

Las siguientes lineas de código imprimen el nuevo valor con espacios en blanco entre cada letra.

for letra in espacio: # Mostrará la palabra secreta con espacios entre letras
        print (letra, fin)
    print ""


En el próximo artículo terminaremos con el juego. Saludos

No hay comentarios:
Write comentarios

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

Entradas más recientes

© 2014 Mi diario Python. Designed by Bloggertheme9 | Distributed By Gooyaabi Templates
Powered by Blogger.