Python para Iniciantes

Projeto: Jogo de Adivinhação

Aula 9 constrói um jogo de adivinhação em Python com random.randint, laço while, contador de tentativas, feedback de muito alto e muito baixo e validação de entradas inválidas.

joao • 03 Nov 2026 • 7 min de leitura • 102 • 0
Projeto: Jogo de Adivinhação | Usando Python
Publicidade

Ao final desta aula, você deverá ter construído um jogo de adivinhação completo, aplicando os conceitos das aulas anteriores em um projeto prático: geração de números aleatórios, laço de repetição, contador de tentativas e feedback ao usuário.

Esta aula é um projeto guiado. Diferente das aulas anteriores, o foco não é apresentar conceitos novos, mas integrar o que já foi aprendido em um programa funcional e envolvente. Vamos construir o jogo por partes, testando cada etapa antes de avançar.

1. O que o jogo vai fazer

Antes de escrever código, vale descrever o comportamento esperado:

  1. O programa escolhe um número secreto entre 1 e 100.

  2. O jogador tenta adivinhar o número.

  3. A cada tentativa, o programa informa se o palpite foi muito alto, muito baixo ou correto.

  4. O jogo continua até o jogador acertar.

  5. Ao final, o programa exibe quantas tentativas foram necessárias.

Esse é um projeto simples, mas que reúne vários conceitos: entrada de dados, conversão de tipos, condicionais, laços, contadores e geração de números aleatórios.

2. Gerando o número secreto com random

Para gerar um número aleatório, Python oferece o módulo random, que faz parte da biblioteca padrão. Não é necessário instalar nada.

A função mais adequada para o nosso caso é randint(inicio, fim), que retorna um inteiro entre os dois valores, incluindo ambos.

import random

numero_secreto = random.randint(1, 100)
print(numero_secreto)

Execute o programa algumas vezes e observe que o número muda a cada execução.

Detalhes importantes sobre random

  • import random deve vir no topo do arquivo, antes de qualquer uso.

  • randint(1, 100) inclui tanto 1 quanto 100. Isso é diferente de range(), que exclui o limite superior.

  • Para testes, é comum imprimir o número secreto durante o desenvolvimento. Depois, essa linha deve ser removida ou comentada.

Alternativa: random.choice()

Também é possível sortear a partir de uma sequência:

numero_secreto = random.choice([10, 20, 30, 40])

randint() é mais adequado para intervalos contínuos, e choice() para coleções específicas.

3. Loop até acertar

Agora que temos o número secreto, precisamos permitir que o jogador tente adivinhar. Como não sabemos quantas tentativas serão necessárias, o laço mais apropriado é o while.

Primeira versão do jogo

import random

numero_secreto = random.randint(1, 100)
palpite = 0

while palpite != numero_secreto:
    palpite = int(input("Digite seu palpite (1 a 100): "))

    if palpite == numero_secreto:
        print("Parabéns, você acertou!")

Vamos analisar o que acontece:

  1. O número secreto é gerado.

  2. palpite é inicializado com 0 para que a condição do while seja verdadeira na primeira verificação.

  3. O laço pede um palpite e compara com o número secreto.

  4. Se o palpite acertar, a mensagem de acerto é exibida.

  5. A condição palpite != numero_secreto é falsa e o laço encerra.

Problemas dessa versão

  • Não há feedback além de "acertou" ou "nada".

  • Não há contador de tentativas.

  • Se o usuário digitar algo que não é número, o programa trava com ValueError.

  • Se o usuário digitar um número fora do intervalo, nada o impede.

Vamos resolver esses problemas nas próximas seções.

4. Feedback: muito alto, muito baixo ou correto

O feedback é o que torna o jogo jogável. Sem ele, o jogador tenta no escuro. Adicionamos condicionais para comparar o palpite com o número secreto.

import random

numero_secreto = random.randint(1, 100)
palpite = 0

while palpite != numero_secreto:
    palpite = int(input("Digite seu palpite (1 a 100): "))

    if palpite < numero_secreto:
        print("Muito baixo, tente novamente.")
    elif palpite > numero_secreto:
        print("Muito alto, tente novamente.")
    else:
        print("Parabéns, você acertou!")

A estrutura if/elif/else aqui cobre as três possibilidades:

  • Palpite menor que o secreto: muito baixo.

  • Palpite maior que o secreto: muito alto.

  • Palpite igual: acertou.

Note que o else não precisa de condição explícita. Ele captura o único caso restante: igualdade.

5. Contador de tentativas

Para saber quantas tentativas foram necessárias, adicionamos um contador. Ele é incrementado a cada palpite e exibido ao final do jogo.

import random

numero_secreto = random.randint(1, 100)
palpite = 0
tentativas = 0

while palpite != numero_secreto:
    palpite = int(input("Digite seu palpite (1 a 100): "))
    tentativas += 1

    if palpite < numero_secreto:
        print("Muito baixo, tente novamente.")
    elif palpite > numero_secreto:
        print("Muito alto, tente novamente.")
    else:
        print(f"Parabéns, você acertou em {tentativas} tentativas!")

Onde colocar o incremento

O incremento precisa acontecer após a leitura do palpite e antes de qualquer mensagem, para que a contagem corresponda ao número de palpites válidos. Se estiver antes da leitura, conta uma tentativa a mais. Se estiver apenas no else, conta apenas as tentativas corretas — o que não é o que queremos.

6. Tratando entradas inválidas

Um programa real precisa lidar com entradas que não são o esperado. Se o usuário digitar "abc" no palpite, o int() gera ValueError e o programa trava. Podemos tratar isso com uma verificação simples antes da conversão, ou com try/except (que será visto em aula futura).

Por enquanto, uma verificação com .isdigit() resolve:

entrada = input("Digite seu palpite (1 a 100): ").strip()

if not entrada.isdigit():
    print("Erro: digite apenas números inteiros.")
    continue

palpite = int(entrada)

O continue faz com que a iteração atual seja interrompida e o laço volte ao topo. Como o contador só é incrementado depois da validação, tentativas inválidas não contam.

7. Versão final do jogo

Reunindo tudo, chegamos ao programa completo:

import random

print("Jogo de Adivinhação")
print("=" * 20)
print("Pensei em um número entre 1 e 100. Tente adivinhar!")

numero_secreto = random.randint(1, 100)
tentativas = 0

while True:
    entrada = input("\nDigite seu palpite: ").strip()

    if not entrada.isdigit():
        print("Erro: digite apenas números inteiros.")
        continue

    palpite = int(entrada)

    if palpite < 1 or palpite > 100:
        print("Erro: o palpite deve estar entre 1 e 100.")
        continue

    tentativas += 1

    if palpite < numero_secreto:
        print("Muito baixo, tente novamente.")
    elif palpite > numero_secreto:
        print("Muito alto, tente novamente.")
    else:
        print(f"\nParabéns, você acertou em {tentativas} tentativas!")
        break

Como o programa funciona

  1. Importa o módulo random e gera um número secreto entre 1 e 100.

  2. Inicializa o contador de tentativas em 0.

  3. Entra em um laço while True, controlado por break interno.

  4. Lê a entrada como texto e remove espaços.

  5. Verifica se a entrada é numérica. Se não, exibe erro e retorna ao topo com continue.

  6. Converte para inteiro e verifica se está no intervalo válido. Se não, exibe erro e retorna ao topo.

  7. Incrementa o contador apenas após validação bem-sucedida.

  8. Compara o palpite com o número secreto e fornece o feedback apropriado.

  9. Ao acertar, exibe o total de tentativas e encerra o laço com break.

Um detalhe sobre a estrutura

Usamos while True em vez de while palpite != numero_secreto. Essa escolha deixa o laço explicitamente infinito, com saída controlada pelo break. Facilita a leitura porque a condição de saída está visível no momento em que ocorre, e não no topo do laço. É um padrão muito comum em jogos e menus interativos.

8. Testes sugeridos

Antes de considerar o projeto concluído, vale testar as diferentes situações:

CenárioEntradaComportamento esperado
Palpite válido abaixo do númeronúmero menor"Muito baixo" e próxima tentativa
Palpite válido acima do númeronúmero maior"Muito alto" e próxima tentativa
Palpite corretonúmero igualMensagem de acerto e encerramento
Entrada com letras"abc"Erro de tipo, sem contar tentativa
Entrada fora do intervalo"200" ou "-5"Erro de intervalo, sem contar tentativa
Palpite com espaço" 50 "Tratado corretamente pelo .strip()

Testar cada caso é parte do processo. Programas que parecem funcionar frequentemente falham em cenários que não imaginamos.

9. Melhorias possíveis

O jogo está funcional, mas há várias formas de expandi-lo conforme o aprendizado avança:

  • Limite de tentativas: o jogador tem apenas 7 tentativas. Isso é possível com um for i in range(7) ou uma verificação do contador no while.

  • Níveis de dificuldade: fácil (1 a 50), médio (1 a 100), difícil (1 a 500). Basta pedir ao usuário e ajustar o randint().

  • Jogar novamente: após acertar, perguntar se quer jogar de novo. Um while externo resolve.

  • Histórico de palpites: guardar os palpites em uma lista e exibir ao final. Isso será possível com listas.

  • Tempo de jogo: medir quanto tempo o jogador levou. Será possível com o módulo time.

Não é necessário implementar todas agora. O importante é perceber que o projeto tem margem para crescer, o que é característico de qualquer software real.

Encerramento da aula

Nesta aula, você construiu um jogo de adivinhação completo, integrando geração de números aleatórios, laço de repetição, condicionais, contadores e validação de entrada. O programa funciona, é legível e segue os padrões das aulas anteriores.

O que merece destaque é a combinação de elementos: nenhum conceito aqui é novo, mas a integração deles produz um programa com comportamento real. Esse é o tipo de raciocínio que diferencia quem aprendeu a sintaxe de quem sabe programar.

Na próxima aula, veremos listas, a estrutura de dados mais usada em Python, e como armazenar e manipular coleções de valores.

Exercício sugerido

Modifique o jogo para limitar o número de tentativas a 7. Se o jogador não acertar em 7 tentativas, exiba o número secreto e encerre o jogo com uma mensagem de derrota.

Dica: substitua while True por while tentativas < 7, mantendo o break no acerto. Após o laço, verifique se o jogador acertou para decidir qual mensagem exibir.

📄 Direitos Autorais: Salvo indicação em contrário, todos os artigos são originais. Por favor, cite a fonte ao compartilhar.

🔗 Link: http://usandopy.com/python-para-iniciantes/projeto-jogo-de-adivinhacao/

Publicidade
Você ainda não está logado, por favor faça login ou registre-se para comentar
    0 pessoas participaram | 0 comentários
    Ainda não há comentários, fique à vontade para conversar!