Läsare som du hjälper till att stödja MUO. När du gör ett köp med hjälp av länkar på vår webbplats kan vi tjäna en affiliate-provision. Läs mer.

Om du är ett 70-talsbarn kanske du har vuxit upp med att titta på den populära spelserien Let's Make a Deal. Sedan dess diskuterar folk livligt Monty Hall-pusslet och har roligt med att replikera det. Den häpnadsväckande spänningen och dramatiken som skapas när den tävlande väljer en av de tre dörrarna är kul att se varje gång.

Med hjälp av matematik och lite programmering kommer du att bygga en Monty Hall Simulator med Python. Med hjälp av detta kommer du att kunna bestämma en gång för alla att byte av dörr ökar dina chanser att vinna.

Vad är Monty Hall-problemet?

Monty Hall-problemet är en brain teaser uppkallad efter spelvärden Monty Hall. Det finns tre dörrar, varav endast en innehåller ett önskat pris. När du väl har valt en dörr öppnar Monty – vem vet vad som finns bakom dem – en annan dörr och avslöjar en get. Du har nu möjlighet att hålla fast vid ditt ursprungliga beslut eller byta till den andra dörren.

På grund av dess överraskande och oförutsägbara karaktär är Monty Hall-pusslet väldigt populärt. Även om det handlar om sannolikheter, trotsar lösningen intuitionen. Det fungerar som en utmärkt demonstration av hur förvirrande sannolikhetsberäkningar kan vara. Pusslet lär oss hur vi kan ignorera intryck av till synes slumpmässiga händelser och istället fokusera på resonemang och fakta.

Modulerna Random och Tkinter

För att bygga en Monty Hall-simulering i Python, börja med modulerna Random och Tkinter.

Det finns flera funktioner för att ta fram slumptal i modulen Random. Du kan använda dessa algoritmer för att generera blandade sekvenser, spelrörelser och pseudo-slumpmässiga heltal. Det används ofta i spel som handcricket, eller ett enkelt skrivtest, samt att simulera tärningskast och att blanda listor.

Tkinter är standard GUI-biblioteket för Python. Med hjälp av det kan du bygga fantastiska GUI-applikationer. Du kan skapa en att göra-lista-app, textredigerare eller en enkel kalkylator. Du kan omsätta dina kunskaper i praktiken och finslipa dina programmeringsfärdigheter med Python och Tkinter för att konstruera grundläggande skrivbordsappar.

Öppna en terminal och kör följande kommando för att lägga till Tkinter till ditt system:

pip installera tkinter

Hur man bygger en Monty Hall-simulator med Python

Du kan hitta källkoden för Monty Hall Simulator i denna GitHub-förråd.

Importera slumpmässiga och Tkinter-modulerna. StringVar-funktionen gör det lättare att kontrollera värdet på en widget som en etikett eller entry. Du kan använda en etikett för att visa lite text på skärmen och en post för att hämta användarinmatning.

Initiera Tkinter-instansen och visa rotfönstret. Ställ in måtten på fönstret till 600 pixlar brett och 200 pixlar högt med hjälp av geometri() metod. Ställ in en lämplig fönsterrubrik och förbjud storleksändring.

importera slumpmässig
från tkinter importera StringVar, Label, Tk, Entry
fönster = Tk()
window.geometry("600x200")
window.title("Monty Hall Simulering")
window.resizable(0, 0)

Ställ sedan in två par widgets och variabler för att lagra simuleringsresultaten. Din app kommer att be om ett antal körningar att slutföra. Under varje körning kommer den att simulera spelet och registrera resultatet i varje fall: om spelaren bestämmer sig för att byta eller behålla samma val.

Använd StringVar(), ställ in de initiala värdena för samma val och ändrade valet till 0. Definiera en postwidget och ställ in dess teckenstorlek till 5. Deklarera två etiketter för att visa samma och det växlade valet och placera det. Deklarera ytterligare två etiketter som visar värdet på de variabler du definierar tidigare. Placera slutligen widgeten Entry under dessa fyra etiketter.

same_choice = StringVar()
switched_choice = StringVar()
same_choice.set(0)
switched_choice.set(0)
no_sample = Entry (font=5)
Etikett (text="Samma val").place (x=230, y=58)
Etikett (text="Bytt val").place (x=230, y=90)
Etikett (textvariabel=samma_val, typsnitt=(50)).place (x=350, y=58)
Etikett (textvariabel=switched_choice, font=(50)).place (x=350, y=90)
no_sample.place (x=200, y=120)

Definiera en funktion, simulera. Initiera resultatvariablerna och få provvärdet som anges av användaren. Deklarera en lista som innehåller de föremål som dörrarna kommer att avslöja.

Inom varje körning, gör en dubblettlista av de ursprungliga dörrarna och blanda den i slumpmässig ordning. Välj en slumpmässig dörr och ta bort den – detta simulerar spelarens val. Simulera sedan Montys avslöjande: om den första dörren inte innehåller priset, öppna den, annars öppna den andra dörren. Ta bort det valet och lämna den återstående dörren som alternativet att byta till.

defsimulera(händelse):
 same_choice_result = 0
 switched_choice_result = 0
 samples = int (no_sample.get())
 dörrar = ["guld", "get", "get"]
för _ i intervall (prover):
 simulated_doors = doors.copy()
 random.shuffle (simulated_doors)
 första_val = random.choice (simulerade_dörrar)
 simulated_doors.remove (första_val)
 öppnad_dörr = simulerade_dörrar[0] om simulerade_dörrar[0] != "guld"annan simulerade_dörrar[1]
 simulated_doors.remove (öppnad_dörr)
 switched_second_choice = simulerade_dörrar[0]

Om det första valet innehåller det önskade priset, öka samma valresultat med ett och reflektera det på skärmen. Utför annars samma operation för det omkopplade valet.

om första_val == "guld":
 same_choice_result += 1
 same_choice.set (same_choice_result)
elif switched_second_choice == "guld":
 switched_choice_result += 1
 switched_choice.set (switched_choice_result)

Ett viktigt steg är att binda Enter-tangenten med en händelse i Tkinter-fönstret. Att göra det säkerställer att när spelaren trycker Stiga på, kommer en viss funktion att köras. För att uppnå detta, passera sträng och simuleringsfunktionen som parametrar till binda() fungera.

De mainloop() funktionen säger åt Python att köra Tkinter-händelsslingan och lyssna efter händelser (som knapptryckningar) tills du stänger fönstret.

no_sample.bind("", simulera)
window.mainloop()

Sätt ihop allt och kör ditt program för att simulera pusslet i aktion.

Utdata från Monty Hall Simulator med Python

När du kör programmet ser du ett enkelt fönster med etiketterna Samma och Switched. Ange ett provnummer i fältet längst ner för att se simulerade resultat. I detta prov på 3 körningar visar programmet att det vinner en gång med samma val och två gånger med en switch.

Dessa resultat är slumpmässiga, men du kan köra simuleringen med en större urvalsstorlek för mer exakthet. I följande urvalsstorlek på 100 vinner det ändrade valet 65 gånger.

Lösa problem med programmering

Monty Hall-simulatorn är en utmärkt demonstration av hur du kan använda programmering för att lösa verkliga problem. Du kan utveckla olika algoritmer och träna modeller för att utföra särskilda uppgifter som att sortera en array eller förbättra ett systems effektivitet för optimal produktion.

Olika programmeringsspråk erbjuder olika möjligheter och funktioner för att göra programmeringen enklare. Med Python kan du skapa modeller som kan förutsäga framtida värden för en datauppsättning med högre noggrannhet. Dessutom kan du automatisera repetitiva operationer, minska tråkigt arbete och förbättra hastigheten och noggrannheten.