Lezers zoals jij steunen MUO. Wanneer u een aankoop doet via links op onze site, kunnen we een aangesloten commissie verdienen. Lees verder.

Als je een kind uit de jaren 70 bent, ben je misschien opgegroeid met het kijken naar de populaire spelshow Let's Make a Deal. Sindsdien bespreken mensen levendig de Monty Hall-puzzel en hebben ze plezier met het repliceren ervan. De verbijsterende spanning en het drama dat wordt gecreëerd wanneer de deelnemer een van de drie deuren kiest, is elke keer weer leuk om naar te kijken.

Met behulp van wiskunde en een beetje programmeren ga je een Monty Hall Simulator bouwen met behulp van Python. Hiermee kun je voor eens en voor altijd beslissen dat het verwisselen van de deuren je kansen om te winnen vergroot.

Wat is het Monty Hall-probleem?

Het Monty Hall-probleem is een hersenkraker vernoemd naar de presentator van de spelshow, Monty Hall. Er zijn drie deuren, waarvan er slechts één een gewenste prijs bevat. Zodra je een deur hebt gekozen, opent Monty - die weet wat er achter hen is - een andere deur en onthult een geit. Je hebt nu de mogelijkheid om bij je oorspronkelijke beslissing te blijven of over te stappen naar de andere deur.

instagram viewer

Vanwege zijn verrassende en onvoorspelbare karakter is de Monty Hall-puzzel erg populair. Hoewel het over waarschijnlijkheden gaat, tart de oplossing de intuïtie. Het dient als een uitstekende demonstratie van hoe verwarrend kansberekeningen kunnen zijn. De puzzel leert ons hoe we indrukken van ogenschijnlijk willekeurige gebeurtenissen kunnen negeren en ons in plaats daarvan kunnen concentreren op redeneringen en feiten.

De Random- en Tkinter-modules

Om een ​​Monty Hall-simulatie in Python te bouwen, begin je met de Random- en Tkinter-modules.

Er zijn verschillende functies voor het produceren van willekeurige getallen in de module Willekeurig. U kunt deze algoritmen gebruiken om geschudde reeksen, spelbewegingen en pseudo-willekeurige gehele getallen te genereren. Het wordt vaak gebruikt in spellen zoals handcricket, of een eenvoudige typetest, evenals om dobbelstenen te simuleren en lijsten te schudden.

Tkinter is de standaard GUI-bibliotheek voor Python. Hiermee kun je fantastische GUI-applicaties bouwen. U kunt een takenlijst-app, een teksteditor of een eenvoudige rekenmachine maken. Je kunt je kennis in de praktijk brengen en je programmeervaardigheden aanscherpen met behulp van Python en Tkinter om eenvoudige desktop-apps te bouwen.

Open een terminal en voer de volgende opdracht uit om Tkinter aan uw systeem toe te voegen:

pip installeer tkinter

Hoe een Monty Hall-simulator te bouwen met behulp van Python

Hierin vind je de broncode van de Monty Hall Simulator GitHub-opslagplaats.

Importeer de willekeurige en Tkinter-modules. De StringVar-functie maakt het eenvoudiger om de waarde van een widget zoals een Label of Item te regelen. U kunt een label gebruiken om wat tekst op het scherm weer te geven en een invoer om gebruikersinvoer op te halen.

Initialiseer de Tkinter-instantie en geef het hoofdvenster weer. Stel de afmetingen van het venster in op 600 pixels breed en 200 pixels hoog met behulp van de geometrie() methode. Stel een geschikte venstertitel in en verbied het wijzigen van de grootte.

importeren willekeurig
van tkinter importeren StringVar, Label, Tk, Ingang
venster = Tk()
venster.geometrie("600x200")
venster.titel("Monty Hall-simulatie")
venster.aanpasbaar(0, 0)

Stel vervolgens twee paar widgets en variabelen in om de simulatieresultaten op te slaan. Uw app vraagt ​​om een ​​aantal runs om te voltooien. Tijdens elke run simuleert het het spel en registreert het in elk geval het resultaat: of de speler besluit om te wisselen of dezelfde keuze te behouden.

Stel met behulp van StringVar() de beginwaarden van dezelfde keuze en schakelde keuze in op 0. Definieer een invoerwidget en stel de lettergrootte in op 5. Declareer twee labels om dezelfde en de geschakelde keuze weer te geven en positioneer deze. Declareer nog twee labels die de waarde weergeven van de variabelen die u eerder hebt gedefinieerd. Plaats ten slotte de invoerwidget onder deze vier labels.

zelfde_keuze = StringVar()
geschakelde_keuze = StringVar()
dezelfde_keuze.set(0)
geschakelde_keuze.set(0)
no_sample = Invoer (lettertype=5)
Label (tekst="Dezelfde keuze").plaats (x=230, j=58)
Label (tekst="Geschakelde keuze").plaats (x=230, j=90)
Label (tekstvariabele=zelfde_keuze, font=(50)).plaats (x=350, j=58)
Label (textvariable=switched_choice, font=(50)).plaats (x=350, j=90)
geen_voorbeeld.plaats (x=200, j=120)

Definieer een functie, simuleren. Initialiseer de resultaatvariabelen en verkrijg de door de gebruiker ingevoerde voorbeeldwaarde. Declareer een lijst met de items die de deuren zullen onthullen.

Maak binnen elke run een dubbele lijst van de originele deuren en schud deze in willekeurige volgorde. Kies een willekeurige deur en verwijder deze - dit simuleert de keuze van de speler. Simuleer vervolgens Monty's onthulling: als de eerste deur de prijs niet bevat, open deze dan, open anders de tweede deur. Verwijder die keuze en laat de resterende deur staan ​​als optie om naar over te schakelen.

defsimuleren(evenement):
 zelfde_keuze_resultaat = 0
 geschakeld_keuze_resultaat = 0
 samples = int (no_sample.get())
 deuren = ["goud", "geit", "geit"]
voor _ in bereik (voorbeelden):
 gesimuleerde_deuren = deuren.kopie()
 random.shuffle (gesimuleerde_deuren)
 eerste_keuze = willekeurige.keuze (gesimuleerde_deuren)
 gesimuleerde_deuren.verwijderen (eerste_keuze)
 geopende_deur = gesimuleerde_deuren[0] als gesimuleerde_deuren[0] != "goud"anders gesimuleerde_deuren[1]
 gesimuleerde_doors.remove (geopende_deur)
 geschakelde_tweede_keuze = gesimuleerde_deuren[0]

Als de eerste keuze de gewenste prijs bevat, verhoog dan hetzelfde keuzeresultaat met één en reflecteer dit op het scherm. Voer anders dezelfde bewerking uit voor de geschakelde keuze.

als eerste_keuze == "goud":
 zelfde_keuze_resultaat += 1
 zelfde_keuze.set (zelfde_keuze_resultaat)
elif geschakelde_tweede_keuze == "goud":
 geschakeld_keuze_resultaat += 1
 geschakelde_keuze.set (geschakelde_keuze_resultaat)

Een belangrijke stap is om de Enter-toets te binden aan een gebeurtenis in het Tkinter-venster. Dit zorgt ervoor dat wanneer de speler drukt Binnenkomen, wordt een bepaalde functie uitgevoerd. Om dit te bereiken, passeert u de string en de simulatiefunctie als parameters voor het binden() functie.

De Hoofdlus() functie vertelt Python om de Tkinter-gebeurtenislus uit te voeren en te luisteren naar gebeurtenissen (zoals het indrukken van knoppen) totdat u het venster sluit.

geen_sample.bind("", simuleren)
venster.mainloop()

Zet alles bij elkaar en voer je programma uit om de puzzel in actie te simuleren.

Uitvoer van Monty Hall Simulator met behulp van Python

Bij het uitvoeren van het programma ziet u een eenvoudig venster met de labels Same en Switched. Voer een monsternummer in het veld onderaan in om gesimuleerde resultaten te bekijken. In dit voorbeeld van 3 runs laat het programma zien dat het één keer wint met dezelfde keuze en twee keer met een wissel.

Deze resultaten zijn willekeurig, maar u kunt de simulatie uitvoeren met een grotere steekproefomvang voor meer nauwkeurigheid. In de volgende steekproef van 100 wint de geschakelde keuze 65 keer.

Problemen oplossen met behulp van programmeren

De Monty Hall Simulator is een uitstekende demonstratie van hoe je programmeren kunt gebruiken om echte problemen op te lossen. U kunt verschillende algoritmen ontwikkelen en modellen trainen om bepaalde taken uit te voeren, zoals het sorteren van een array of het verbeteren van de effectiviteit van een systeem voor optimale productie.

Verschillende programmeertalen bieden verschillende mogelijkheden en functies om het programmeren te vergemakkelijken. Met behulp van Python kunt u modellen maken die de toekomstige waarden van een dataset nauwkeuriger kunnen voorspellen. Bovendien kunt u repetitieve bewerkingen automatiseren, saai werk verminderen en de snelheid en nauwkeurigheid verbeteren.