eifache Experimente simulieren, die simulierten Daten mit Python rechnerisch auswerten und mit Hilfe der Koordinatengrafik visualisieren.
MUSTERBEISPIELE
Beispiel 1: Würfelsimulation
Mit Hilfe von Zufallszahlen simulierst du das Werfen eines Würfels. Die Funktion randint(1, 6) aus dem Modul random liefert zufällige Würfelzahlen (1, 2, ...6). In deinem Programm werden 1000 solche Würfelzahlen erzeugt und die Häufigkeiten, mit welchen die einzelnen Zahlen vorkommen, in einer Liste p erfasst und mit einem Häufigkeitsdiagramm dargestellt. p = [0] * 7 erzeugt eine Liste mit 7 Nullen.
Experimentere mit verschiedenen n. Je grösser n, umso gleichmässiger sollte die Häufigkeits-Verteilung ausfallen.
Programm:
#Gp14.pyfrom gpanel import *
from random import randint
n = 1000
print("Anzahl Wuerfe = " + str(n))
makeGPanel(-1, 8, -2*n/100, n/4 + n/100)
drawGrid(0, 7, 0, n/4, 7, 10)p = [0] * 7repeat n:
a = randint(1, 6)if a == 1:
p[1] += 1
elif a == 2:
p[2] += 1
elif a == 3:
p[3] += 1
elif a == 4:
p[4] += 1
elif a == 5:
p[5] += 1
elif a == 6:
p[6] += 1
setColor("blue")
for i in range(1, 7):
fillRectangle(i-0.3 , 0, i + 0.3, p[i])
Du wirfst einen Würfel und stellst dir die Frage, wie oft musst du im Mittel würfeln, bis eine bestimmte Zahl, z.B. eine 6 vorkommt. Stellt man sich vor, dass jeder Wurf gleich viel Zeit benötigt, so handelt es sich um die Frage nach der mittleren Wartezeit.
Statt mathematisch vorzugehen, simulierst du das Würfeln mit Zufallszahlen 1, 2, 3, ...6 und wiederholst dieses Experiment, bis die Zahl 6 vorkommt. Die Zahl der benötigen Versuche wird in der Variablen k gespeichert. Du wiederholst das Experiment 10000 mal und stellst die Häufigkeiten in einem Häufigkeitsdiagramm dar. Gleichzeitig bildest du die Summe von k, damit du am Schluss die mittlere Wartezeit berechnen kannst. Diese wird im Titel angezeigt. Um Die Simulation zu verstehen, experimentierst du zuerst mit kleinen n-Werten (z. Bsp. n = 5, n = 10, n = 100).
Programm:
# Gp14a.pyfrom gpanel import *
from random import randint
n = 10000
def sim():
k = 1
r = randint(1, 6)
while r != 6:
r = randint(1, 6)
k += 1
return k
makeGPanel(-5, 55, -200, 2200)
drawGrid(0, 50, 0, 2000)
print("Waiting on a 6")
setColor("blue")
h = [0] * 51
lineWidth(5)
count = 0
repeat n:
k = sim()
print k
count += k
if k <= 50:
h[k] += 1
line(k, 0, k, h[k])
mean = count / n
print("Mean waiting time = " + str(mean))
Beispiel 3: Berechnung des Zahl PI mit der Monte-Carlo-Methode
Es handelt sich um ein klassisches Beispiel einer Computersimulation. Auf ein Quadrat mit der Seitenlänge 1 wird eine grosse Zahl n Zufallspunkte geworfen. Der Anteil der Punkte innerhalb des Viertelkreises entspricht offensichtlich ungefähr seinem Flächenanteil.
Wirft man also n Punkte und befinden sich die Zahl hits innerhalb des Viertelkreises, so gilt
hits / n = Viertelkreisfläche / Quadratfläche
Mit einem GPanel kannst du die Aufgabe grafisch und rechnerisch lösen. Um die Zufallspunkte zu erzeugen, verwendest du die Funktion random(), die Zufallszahlen zwischen 0 und 1 (mit 12 Dezimalstellen) liefert.
Programm:
# Gp14b.pyfrom gpanel import *
from random import random
makeGPanel(-0.3, 1.3, -0.3, 1.3)
rectangle(0, 0, 1, 1)
arc(1, 0, 90)
hits = 0
n = input("Number of rain drops")
i = 0
while i < n:
x = random()
y = random()
if x*x + y*y < 1:
hits = hits + 1
setColor("red")
else:
setColor("green")
i = i + 1
point(x, y)
pi = 4 * hits / nprint("Result: pi = " + str(pi))
Beispiel 4: Simulation eines senkrechten Wurfs
Mit der Beschleunigung a ist in einem kleinen Zeitintervall dt die neue Geschwindigkeit vneu = v + a * dt und der neue Ort xneu = x + v * dt. Hier ist die Beschleunigung a = -g. Der neue Zustand wird alle 0.05 Sekunden berechnet.
Programm:
# Gp14c.pyfrom gpanel import *
import time
makeGPanel(-130, 130, -170, 70)
setColor("red")
enableRepaint(False)
g = 9.81
dt= 0.05
t = 0; y = 0
v = 25
while t < 10:
v = v - g * dt
y = y + v * dt
t = t + dt
drawGrid(-100, 100, -150, 50, "gray")
pos(0, y)
fillCircle(5)
repaint()
time.sleep(dt)
clear()
Für die Simulation verwendest du Zufallszahlen. Die Funktion random() aus dem Modul random liefert Zufallszahlen mit 12 Dezimalstellen, die grösser als 0 und kleiner als 1 sind. Die Funktion randint(a, b) liefert ganzahlige Zufallszahlen zwischen a und b (Grenzen inbegriffen).
ZUM SELBST LÖSEN
1)
Bei einem Spiel werden 3 Würfel gleichzeitig geworfen. Der Spieler A gewinnt, wenn mindestens ein Sechser geworfen wird. Der Spieler B gewinnt, wenn kein Sechser vorkommt. Wer hat die bessere Gewinnchance, wenn das Spiel beliebig oft wiederholt wird?
2)
Man stellt sich die Frage, wie oft man im Mittel würfeln muss, um alle Würfelzahlen 1, 2, 3, 4, 5, 6 mindestens einmal zu erhalten.
Löse die Frage mit einer Simulation.
3)
Simuliere das Werfen zweier Münzen und stelle die Häufigkeiten, mit welchen die Ereignisse "zweimal Zahl", "einmal Zahl und einmal Kopf", und "zweimal Kopf" eintreten, mit einem Häufigkeitsdiagramm dar.
4)
Im Beispiel 4 wird ein senkrechter Wurt simuliert. Analog kann man auch den Schiefen Wurf simulieren. Ein Körper wird unter dem Winkel von 45° mit der Anfangsgeschwindigkeit 32 geworfen. Stelle seine Laufbahn während 10 Sekunden grafisch dar. Um die Funktionen sin und cos zu verwenden, musst du folgende Importzeile hinzufügen: from math import sin, cos, pi
Als Vorlage kannst du das Beispiel 4 verwenden und die physikalischen Formel mit denjenigen für den schiefen Wurf ersetzen:
g = 9.81
dt = 0.05
v = 32
alpha = pi/4
t = 0; x = 0; y = 0
vx = v * math.cos(alpha)
vy = v * math.sin(alpha)
while t < 10:
vy = vy - g * dt
x = x + vx * dt
y = y + vy * dt
Bemerkung: Der Winkel in den Funktionen sin() und cos() muss in Radian angegeben werden. pi/4 entspricht dem Winkel 45°. Für die Umrechnung kann die Funktion radians(alpha), die Winkel in Grad in Winkel in Radian umrechnet, verwendet werden. Diese muss zusätzlich importiert werden.
