Introdução
O problema de Monty Hall é um famoso quebra-cabeça de probabilidade baseado em um cenário de programa de jogos. No jogo, um concorrente é apresentado a três portas. Atrás de uma das portas está um prêmio (como um carro), enquanto as outras duas portas escondem cabras. O concorrente seleciona uma das portas. O apresentador, que sabe onde está o prêmio, então abre uma das outras duas portas para revelar uma cabra. O concorrente recebe então a opção de ficar com sua escolha original ou mudar para a outra porta não aberta. A questão é: Qual é a melhor estratégia, mudar ou ficar? Este projeto irá guiá-lo através da construção de uma aplicação GUI para simular o problema de Monty Hall usando a biblioteca Tkinter em Python.
👀 Pré-visualização
🎯 Tarefas
Neste projeto, você aprenderá:
- Como projetar e desenvolver uma interface gráfica do usuário (GUI) usando Tkinter.
- Como simular o problema de Monty Hall para entender seus resultados probabilísticos.
- Como implementar a lógica do jogo em Python para lidar com as escolhas do usuário e revelar os resultados.
- Como usar a biblioteca random do Python para alocar aleatoriamente o prêmio atrás de uma das portas.
- Como redefinir os estados do jogo para permitir várias rodadas de jogo sem reiniciar a aplicação.
🏆 Conquistas
Após concluir este projeto, você será capaz de:
- Aplicar princípios de design de GUI e implementá-los em Python com Tkinter.
- Entender a aplicação prática da probabilidade e estatística em simulações de jogos.
- Implementar programação orientada a eventos e lidar com interações do usuário em uma aplicação GUI.
- Utilizar técnicas avançadas de programação Python, como funções lambda e list comprehensions (compreensões de lista).
- Reconhecer a importância da experiência do usuário (UX) no design de jogos e fornecer mecanismos de feedback usando caixas de mensagem.
Criar Arquivos do Projeto
Primeiro, crie um arquivo Python chamado monty_hall_gui.py em ~/project. Em seguida, abra-o em um editor de texto ou em um ambiente de desenvolvimento integrado (IDE).
cd ~/project
touch monty_hall_gui.py
Importar as Bibliotecas Necessárias
Para começar, importaremos os módulos necessários.
import tkinter as tk
from tkinter import messagebox
import random
from typing import List, Optional
No código acima, estamos importando as bibliotecas Python necessárias. tkinter é para a criação da GUI, messagebox é para alertas pop-up, e random é para a lógica do jogo randomizada.
Inicializar a Classe MontyHallSimulation
Agora, criaremos a classe principal para gerenciar nossa simulação.
class MontyHallSimulation:
def __init__(self, root: tk.Tk) -> None:
"""
Inicializa a Simulação do Problema de Monty Hall.
:param root: A janela principal do tkinter
"""
## Configuração da Janela
self.root = root
self.root.title("Simulação do Problema de Monty Hall")
self.root.geometry("1200x800")
Nas instruções acima, começamos a definir nossa classe principal para a simulação.
Configurar Variáveis e Componentes da Interface do Usuário (UI)
Dentro da classe, inicialize as variáveis necessárias e os elementos da UI.
## Variáveis para rastrear a porta selecionada pelo usuário, a porta que é mostrada e a porta vencedora
self.selected_door: Optional[int] = None
self.show_door: Optional[int] = None
self.winning_door: int = random.randint(1, 3)
## Variáveis para rastrear as contagens de vitórias com base na decisão de mudar ou ficar
self.wins_change: int = 0
self.wins_stay: int = 0
## Instruções exibidas no topo
self.label = tk.Label(root, text="Selecione uma porta!", font=("Arial", 16))
self.label.pack(pady=5)
## Criando frame para os botões das portas
self.doors_frame = tk.Frame(root)
self.doors_frame.pack(pady=5)
As instruções acima guiam você através da inicialização de várias variáveis do jogo e da configuração dos principais elementos da UI para nossa simulação.
Configurar as Imagens das Portas e Botões
Carregue as imagens das portas e configure os botões das portas para permitir a interação do usuário.
## Carregar imagens das portas
self.door_imgs: List[tk.PhotoImage] = [
tk.PhotoImage(file="door_closed.png"),
tk.PhotoImage(file="door_opened_empty.png"),
tk.PhotoImage(file="door_opened_prize.png")
]
## Criar botões das portas com imagens e anexar a função de seleção de porta
self.door_buttons: List[tk.Button] = [
tk.Button(self.doors_frame, image=self.door_imgs[0], command=lambda: self.select_door(1)),
tk.Button(self.doors_frame, image=self.door_imgs[0], command=lambda: self.select_door(2)),
tk.Button(self.doors_frame, image=self.door_imgs[0], command=lambda: self.select_door(3))
]
for button in self.door_buttons:
button.pack(side=tk.LEFT, padx=5)
## Botões para escolher se deve trocar de porta
self.yes_button = tk.Button(self.root, text="Yes", command=self.switch_door)
self.yes_button.pack_forget()
self.no_button = tk.Button(self.root, text="No", command=self.stay_door)
self.no_button.pack_forget()
## Exibindo resultados
self.results_label = tk.Label(root, text="", font=("Arial", 14))
self.results_label.pack(pady=5)
No código acima, estamos carregando as imagens das portas que representam diferentes estados das portas. Em seguida, criamos e configuramos três botões representando as portas, que permitem ao usuário fazer sua escolha.
Implementar a Lógica de Seleção de Portas
Primeiramente, abordaremos a lógica para selecionar uma porta.
def select_door(self, door: int) -> None:
"""
Lidar com o evento quando uma porta é selecionada.
:param door: O número da porta selecionada
"""
## Assegurar que não haja re-seleção de portas
if self.selected_door:
return
self.selected_door = door
## Determinar quais portas não foram selecionadas
non_selected_doors = [d for d in [1, 2, 3] if d != self.selected_door]
## Decidir qual porta revelar
if self.selected_door == self.winning_door:
show_door = random.choice(non_selected_doors)
else:
non_selected_doors.remove(self.winning_door)
show_door = non_selected_doors[0]
self.show_door = show_door
self.door_buttons[show_door - 1].config(image=self.door_imgs[1])
## Solicitar ao usuário que decida se deseja trocar
self.label.config(text="Você gostaria de trocar?")
## Exibir os botões sim e não
self.yes_button.pack(side=tk.LEFT, padx=10, pady=20)
self.no_button.pack(side=tk.RIGHT, padx=10, pady=20)
No código acima, definimos o método select_door, que será usado quando um jogador escolher uma porta. O método lembrará a seleção do jogador e revelará uma das portas que não contém o prêmio.
Gerenciar a Lógica de Troca de Portas
Em seguida, mergulhamos na lógica de troca das escolhas de portas.
def switch_door(self) -> None:
"""Lidar com o evento quando o usuário decide trocar de porta."""
## Encontrar a porta que não foi selecionada e não foi revelada
remaining_doors = [d for d in [1, 2, 3] if d != self.selected_door and d != self.show_door]
new_door = remaining_doors[0]
## Verificar se houve vitória
if new_door == self.winning_door:
self.wins_change += 1
self.show_win(True)
else:
self.show_win(False)
Aqui, a função switch_door gerencia o que acontece quando um jogador opta por trocar de porta após o apresentador revelar uma cabra atrás de uma das portas não selecionadas.
Abordar a Lógica de Retenção de Portas
Agora, vamos abordar a lógica para reter a escolha inicial da porta.
def stay_door(self) -> None:
"""Lidar com o evento quando o usuário decide ficar com a seleção inicial da porta."""
## Verificar se houve vitória
if self.selected_door == self.winning_door:
self.wins_stay += 1
self.show_win(True)
else:
self.show_win(False)
Neste trecho, a função stay_door supervisiona o resultado quando o jogador decide permanecer com a sua escolha inicial da porta.
Ilustrar Vitória ou Derrota
Posteriormente, ilustre se o jogador garantiu uma vitória ou não.
def show_win(self, did_win: bool) -> None:
"""
Exibir os resultados após revelar todas as portas.
:param did_win: Booleano indicando se o usuário venceu ou não
"""
## Atualizar as imagens das portas com base nos resultados
for i, button in enumerate(self.door_buttons):
if i + 1 == self.winning_door:
button.config(image=self.door_imgs[2])
else:
button.config(image=self.door_imgs[1])
## Mostrar mensagem de vitória/derrota
if did_win:
messagebox.showinfo("Congratulations!", "You won!")
else:
messagebox.showinfo("Sorry!", "Better luck next time!")
## Atualizar as estatísticas de vitória
self.results_label.config(text=f"Wins (Switch): {self.wins_change} Wins (Stay): {self.wins_stay}")
## Preparar para a próxima rodada
self.reset_game()
Este método show_win revela os resultados. Se a seleção final da porta do jogador esconde o prêmio, ele é anunciado como vencedor; caso contrário, deseja-se boa sorte para a próxima vez.
Reiniciar Mecânicas do Jogo
Finalmente, certifique-se de que você pode reiniciar o jogo para outra rodada.
def reset_game(self) -> None:
"""Reiniciar o jogo para uma nova rodada."""
self.selected_door = None
self.winning_door = random.randint(1, 3)
for button in self.door_buttons:
button.config(image=self.door_imgs[0])
self.label.config(text="Select a door!")
self.yes_button.pack_forget()
self.no_button.pack_forget()
Esta função, reset_game, reinicia o estado do jogo, permitindo que os jogadores tentem outra rodada.
Executar a Aplicação
Finalmente, vamos inicializar e executar nossa aplicação.
if __name__ == "__main__":
root = tk.Tk()
sim = MontyHallSimulation(root)
root.mainloop()
Agora que concluímos todas as etapas, podemos executar o código usando o seguinte comando:
cd ~/project
python monty_hall_gui.py
Resumo
Parabéns! Você acabou de criar uma simulação baseada em GUI do problema de Monty Hall usando Tkinter. Para executar a simulação, execute o script monty_hall_gui.py e interaja com a interface gráfica. Lembre-se, o jogo demonstra a natureza contraintuitiva da probabilidade, e a melhor estratégia é sempre trocar de porta!
