Estrutura De Dados
No capítulo passado criamos o jogo da adivinhação, agora vamos criar o jogo da Forca. Vamos começar com os conhecimentos que temos até aqui para estruturarmos o nosso jogo. Vamos criar um arquivo chamado forca.py na pasta jogos:
|_ home
|_ jogos
|_ adivinhacao.py
|_ forca.py
Como no jogo da adivinhação, devemos adivinhar uma palavra secreta, então nada mais justo que defini-la em uma variável. Por enquanto, a palavra será fixa, com o valor banana:
print('\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*') print('\*\*\*Bem vindo ao jogo da Forca!\*\*\*') print('\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*')palavra_secreta = ‘banana’ print(‘Fim do jogo’)
Mais à frente deixaremos essa palavra secreta mais dinâmica.
Como estamos tratando de um jogo da forca, o usuário deve acertar uma palavra e chutar letras. Além disso, precisa saber se o usuário acertou ou errou e saber se foi enforcado ou não. Então precisaremos de 2 variáveis booleanas enforcou e acertou para guardar esta informação e o jogo continuará até uma delas for True ; para tal acrescentamos um laço while :
acertou = False enforcou= False
while(not acertou and not enforcou): print(‘Jogando…‘)
O usuário do jogo também vai chutar letras. Além disso, se o chute for igual a uma letra contida na palavra_secreta , quer dizer que o usuário encontrou uma letra. Podemos utilizar um laço for para tratar isso, assim como fizemos no jogo da adivinhação para apresentar as tentativas e rodadas:
while(not acertou and not errou): chute = input(‘Qual letra?’)
posicao =
for letra in palavra_secreta: if (chute == letra):print(f'Encontrei a letra {} na posição {} {letra, posicao}')posicao = posicao + 1 print(‘Jogando…‘)
Como uma string é uma sequência de letras, o loop for vai iterar por cada letra.
Nossa palavra_secreta é ‘banana’. E se o usuário chutar a letra ‘A’ ao invés de ‘a’? Vamos testar:
$python3 jogos/forca.py
*********************************
***Bem vindo ao jogo da Forca!***
********************************* Qual letra? A
Jogando… Qual letra?
O Python é case-sensitive, ou seja ‘a’ e ‘A’ são distintos para o interpretador. Será preciso acrescentar este tratamento e fazer o jogo aceitar como acerto tanto ‘a’ como ‘A’. String ( str ) é um tipo embutido no Python que possui algumas funções prontas e uma delas vai nos ajudar neste problema.
Existe uma função chamada upper() que devolve uma string com todas as letras maiúsculas.
Também possui a lower() que devolve uma string com todas as letras minúsculas:
texto = ‘python’
texto.upper() ‘PYTHON’
texto = ‘PYTHON’
texto.lower() ‘python’
Agora precisamos modificar a condição chute letra do if para chute.upper() letra.upper() :
if (chute.upper() == letra.upper()):print(f'Encontrei a letra {} na posição {} {letra, posicao}')Dessa maneira, o jogador pode chutar tanto ‘a’ como ‘A’ que o tratamento do if vai considerar todas como maiúsculas.
Agora podemos testar novamente com chute igual a ‘A’ (ou ‘a’) e vemos o programa funcionar como o esperado:
*********************************
***Bem vindo ao jogo da Forca!***
********************************* Qual letra? A
Encontrei a letra a na posição 1 Encontrei a letra a na posição 3 Encontrei a letra a na posição 5 Jogando…
Qual letra?
Atualmente, já dizemos ao jogador em que posição a letra que ele chutou está na palavra secreta, caso a letra exista na palavra. Mas em um jogo real de forca, o jogador vê quantas letras há na palavra
secreta. Algo como:
Qual letra? _ _ _ _ _ _
E se ele encontrar alguma letra, a mesma tem a sua lacuna preenchida. Ao digitar a letra “a”, ficaria:
_ a _ a _ a
Muito mais intuitivo, não? Vamos implementar essa funcionalidade. Para exibir as letras dessa forma, precisamos guardar os chutes certos do usuário, mas como fazer isso?
Para tal, o Python nos oferece um tipo de estrutura de dados que nos permite guardar mais de um valor. Essa estrutura é a list (lista). Para criar uma lista, utilizamos colchetes ([]):
valores = []
type(valores)
<class ‘list’>
Assim como a string, list também é uma sequência de dados. Podemos ver sua documentação através da função help() :
help(list)
Help on class list in module builtins:
class list(object)| list() → new empty list
| list(iterable) → new list initialized from iterable’s items
|
| Methods defined here:
|
| add (self, value, /)
| Return self+value.
|
| contains (self, key, /)
| Return key in self.
|
| delitem (self, key, /)
| Delete self[key].
|
| eq (self, value, /)
| Return self==value.
|
| ge (self, value, /)
| Return self>=value. código omitido
Vemos o que podemos fazer com uma lista. Podemos, por exemplo, verificar o seu valor mínimo com min e o seu máximo com max . Nossa lista ainda está vazia, mas já podemos iniciá-la com alguns valores e utilizarmos essas funções para verificarmos seus valores máximo e mínimo:
valores = [0, 1, 2, 3]
min(valores)
max(valores)
Para acessar um valor específico, podemos acessá-lo através do seu índice (posição). O primeiro
elemento da lista possui índice 0, o segundo possui índice 1 e assim por diante:
valores = [0, 1, 2, 3]
valores[2]
valores[0]
Para modificar um valor, basta usar o operador de atribuição em uma determinada posição:
valores[0] =
valores [4, 1, 2, 3]
É possível saber o tamanho da lista com a função len e verificar se determinado valor está guardado nela com o comando in :
valores = [0, 1, 2, 3]
len(valores)
0 in valores True
6 in valores False
Além disso, existem funções específicas da lista, que podem ser acessadas na documentação: https://docs.python.org/3.6/library/stdtypes.html#mutable-sequence-types.
Podemos adicionar elementos ao final da lista com a função append() , exibir e remover um elemento de determinada posição com a função pop() , entre diversas outras funcionalidades.
Agora que sabemos como guardar valores em uma lista, podemos voltar ao nosso jogo e guardar os acertos do usuário. Como queremos exibir os espaços vazios primeiro, criaremos uma lista com eles, na mesma quantidade de letras da palavra secreta:
palavra_secreta = ‘banana’
letras_acertadas = ['', '', '', '', '', '']
Já temos a posição da letra (também chamado de índice). Logo, caso o chute seja correto, basta guardar a letra dentro da lista, na sua posição correta e imprimir a lista após o laço for :
posicao =
for letra in palavra_secreta:if (chute.upper() == letra.upper()): letras_acertadas[posicao] = letraposicao = posicao + 1 print(letras_acertadas)
Ou seja, para cada letra na palavra secreta, o programa vai verificar se chute é igual a letra . Em caso afirmativo, adiciona a letra na posição correta e incrementa a posicao após o bloco do if .
Ao executar o jogo e chutar algumas letras, temos:
$ python3 jogos/forca.py
*********************************
***Bem vindo ao jogo da Forca!***
********************************* Qual letra? b
[‘b’, '', '', '', '', ’_’]
Jogando…
Qual letra? a
[‘b’, ‘a’, '', ‘a’, '', ‘a’]
Jogando… Qual letra?
A saída ainda não está visualmente agradável. Para ficar ainda melhor, vamos exibir a lista no início do jogo também e excluir o print(‘Jogando…’) para o código ficar mais limpo.
print(letras_acertadas)while(not acertou and not errou): chute = input(‘Qual letra?’)
código omitido