Jython HomeDruckenJava-Online

Zufallszahlen verwenden


Zufallszahlen werden häufig bei Simulationen und verschiedenen Verfahren der Statistik verwendet. Auch in der Turtlegrafik kann man mit Hilfe von Zufallszahlen interessante Applikationen programmieren. Um Zufallszahlen verwenden zu können, muss das Modul- random importiert werden.
random.random() liefert eine Zufallszahl zwischen 0 und kleiner als 1
random.randint(a, b) liefer ganzzahlige Zufallszahlen, wobei a die kleinste und b die grösste Zahl ist. random.randint(1, 6) liefert beispielsweise die Würfelzahlen 1, 2, 3, 4, 5, 6.

Beispiel 1: Sterne an zufällig gewählten Positionen .
Mit random.randint(-270, 270) werden zufällige x- und y-Koordinaten zwischen -270 und 270, die für die Positionierung der Sterne im Turtlefenster benutzt werden können.

 
Ausführen mit Webstart
 # Tu8.py

from gturtle import *
import random

def star(x, y):
    setPos(x, y)
    fillToPoint(x, y)
    for i in range(6):
        forward(10)
        right(140)
        forward(10)
        left(80)

makeTurtle()        
hideTurtle()
clear("blue")
setPenColor("yellow")
for i in range(50):
    x = random.randint (-270, 270)
    y = random.randint (-270, 270)
    star(x, y)
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

Erklärungen zum Programmcode:

Mit clear("blue") wird der Hintergrund gelöscht und mit der blauen Farbe gefärbt
import random importiert das Modul random
x = random.randint(-270, 270) liefert eine Zufallszahl zwischen -270 und 270. Da die Funktion zum Modul random gehört, muss random. vorangestellt werden
fillToPoint(x, y) füllt die Stern-Figur vom Punkt in welchen die Turtle mit dem Zeichnen des Sternes beginnt

 

Beispiel 2: Zufälliges malen
Farbig gefüllte Kreise mit zufälligem Durchmesser werden an Positionen, die durch Zufallszahlen zwischen -300 und 300 bestimmt sind, gezeichnet. Für den Import verwendet man hier from random import randint, damit muss man nicht bei jedem Aufruf von randint() den Modulnamen random voranstellen.

Eine zufällige Farbe wird erzeugt, indem man für den Rot-, Grün- und Blau-Anteil des RGB-Werts eine ganzzahlige Zufallszahl zwischen 0 und 255 wählt.
# Tu8a.py

from gturtle import *
from random import randint

makeTurtle()
hideTurtle()

for i in range(100):
    x = randint(-300, 300)
    y = randint(-300, 300)
    setPos(x, y)
    r = randint(0, 255)
    g = randint(0, 255)
    b = randint(0, 255)
    c = Color(r, g, b)
    setPenColor(c)
    d = randint(50, 300)
    dot(d)
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

 
Ausführen mit Webstart

 

Beispiel 3: Noch ein Kunstwerk
Mit Hilfe von Zufallszahlen werden Stiftfarbe, Länge der gezeichneten Strecke und die Richtung der Turtle festgelegt.

Die Turtle bewegt sich um eine zufällig gewählte Strecke vorwärts und dreht zufällig um 90° nach links oder rechts. Der blaue Farbanteil wird hier auf 255 gesetzt.

# Tu8b.py

from gturtle import *
import random

makeTurtle()        
speed(-1)
wrap()
fillToPoint(0, 0)
for i in range(200):
     r = random.randint(0, 255)
     g = random.randint(0, 255)
     b = 255
     c = Color(r, g, b)
     setPenColor(c)
     if random.random() < 0.5:
         right(90)
     else:
         left(90)
     forward(80 * random.random())
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)
 
Ausführen mit Webstart

Erklärungen zum Programmcode:

Mit wrap() wird Turtle in den wrap-Modus versetzt. Wenn sie am Rand des Fensters ankommt, erscheint sie automatisch auf den gegenüber liegenden Rand des Fensters (Torussymmetrie)

 

Beispiel 4: Berechnung von π mit Zufallsregen
Auf einen Viertelkreis, der in einem Quadrat mit der Seitenlänge 1 eingebettet ist, wirft man ein grosse Zahl von Zufallspunkten. Der prozentualen Anteil der Punkte, die auf den Viertelkreis fallen (k) zu allen Punkten, die auf das Quadrat fallen (n), ist im gleichen Verhältnis, wie die Fläche des Viertelkreises mit dem Radius 1 (π/4) zur Quadratfläche (1). Daraus lässt sich die Zahl pi berechnen:

  daraus folgt

Die Überprüfung, ob ein Zufallspunkt im Viertelkreis liegt, erfolgt nach dem Satt von Pythagoras. Summe der Quadrate der beiden Koordinaten muss kleiner als 1 sein.

# Tu8c.py

from gturtle import *
import random

from gturtle import *

def init():
    setPenColor("black")
    for i in range(4):
        forward(200)
        right(90)
    moveTo(0, 200)
    right(90)
    rightArc(200, 90)

makeTurtle() 
hideTurtle()   
addStatusBar(20)
n = 10000
k = 0
init()

for i in range(n):
    zx = random.random()
    zy = random.random()
    if zx * zx + zy * zy <= 1:
        k = k + 1
        setPenColor("red")
    else:
        setPenColor("green")    
    setPos(zx * 200, zy * 200)
    dot(2)
pi = 4 * k/n
setStatusText("PI  =  " + str(pi))           
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)
 
Ausführen mit Webstart

Erklärungen zum Programmcode:

Für die Berechnung werden mit random.random() Zufallszahlen zwischen 0 und 1 erzeugt. Für die grafische Darstellung werden diese Zahlen mit 200 multipliziert. Auch die Quadratseite ist hier nicht 1 sondern 200.

 

Beispiel 5: Beliebige Fläche mit Monte-Carlo-Methode berechnen
Mit dem Zufallsregen, genannt auch Monte-Carlo-Methode, lassen sich beliebige Fläche schätzungsweise bestimmen. Man bettet die Fläche in ein Quadrat oder Rechteck mit bekanntem Flächeninhalt und bestimmt den prozentualen Anteil der Punkte, die auf die Fläche fallen.

In unserem Beispiel soll die graue Fläche berechnet werden. Die Überprüfung, ob ein Zufallspunkt in dieser Fläche liegt, kann durch Erfassung der Hintergrundfarbe vorgenommen werden. Mit getPixelColorStr(), kann man die Pixelfarbe an der aktuellen Turtleposition bestimmen. Wenn diese "gray" ist, so liegt der Punkt in der grauen Fläche und wird als Treffer erfasst.

 
Ausführen mit Webstart
# Tu8d.py

from gturtle import *
import random

def figure():
    setPenColor("gray")
    setFillColor("gray")
    setPos(0, 100)
    startPath()
    rightArc(100, 90)
    rightArc(50, 180)
    left(180)
    rightArc(50, 180)
    rightArc(100, 90)    
    fillPath()
    
makeTurtle()
hideTurtle()
figure()
n = 20000
hits = 0
addStatusBar(20)

for i in range(n):
    zx = random.randint(0, 200)
    zy = random.randint(0, 200)
    setPos(zx, zy)
    if getPixelColorStr() == "gray" or getPixelColorStr() == "red":
        hits = hits + 1
        setPenColor("red")
    else:
        setPenColor("green")    
    dot(2)
a = hits/n * 100
setStatusText("  Area = " + str(a) + "% of square")  
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

Erklärungen zum Programmcode:

Da nur Pixel mit ganzzahligen Koordinaten für die Farbüberürüfung genommen werden, werden hier ganzzahlige Zufallszahlen verwendet. Der theoretisch berechnete Wert der grauen Fläche beträgt 58.9% der Quadratfläche.
getPixelColorStr() == "gray" or getPixelColorStr() == "red": Die Punkte können mehrmals getroffen werden. Die bereits rot-gefärbte Punkte müssen daher auch als Treffer gezählt werden.

Beispiel 6: Random walk
Die Turtle startet an der Homeposition (0, 0) und bewegt sich wiederholt um 20 Schritte in beliebiger Richtung vorwärts. Es zeigt sich, dass sie sich in den meisten Fällen trotz der Zufallsbewegung vom Startpunkt entfernt, also irgendwann den Rand des Geheges erreicht.

Die Anzahl der Schritte und die Distanz vom Startpunkt werden in der Statuszeile ausgeschrieben.

 
Ausführen mit Webstart
# Tu8e.py

from gturtle import *
import random

makeTurtle()
hideTurtle()
addStatusBar(20) 
dot(10)
openDot(400)
n = 0
r = 0
while r < 200:
    z = random.random()
    angle = z * 360
    heading(angle)
    forward(20)
    r = distance(0, 0)
    setStatusText("Number of steps: " + str(n) + ". Distance: " + str(r))
    n += 1     
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

Erklärungen zum Programmcode:

heading(angle): Legt die Richtung der Turtle fest
distance(0, 0): Gibt die Distanz der zwischen der aktuellen Turtle-Position und dem Punkt(0, 0) zurück

 


Aufgaben Serie 8

1)

Zeichne Konfetti in den Farben rot, magenta, yellow, cyan und green an zufällig gewählten Positionen. Wähle einen schwarzen Hintergrund.

       
2)

Zeichne gefüllte Rechtecke mit zufällig gewählten Breite und Höhe, an zufälligen Positionen und mit zufällig gewählten Farben.

 

 
       
3)

Bestimme mit dem Zufallsregen die Fläche der nebenstehenden Figur. Verwende das unten stehende Programm, um die Figur mit grauer Farbe zu erzeugen und lasse die Zufallspunkte auf ein Quadrat mit der Seitenlänge 300, in welches diese Fläche eingebettet ist, fallen.
Wie viel % der Quadratfläche beträgt die graue Fläche?

from gturtle import *

def figure():
    setPenColor("gray")
    setFillColor("gray")
    startPath()
    for i in range(6):
        rightArc(100, 90)
        right(90)
        rightArc(100, 90)
        right(30)
    fillPath()
    
makeTurtle()
hideTurtle()
figure()
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)
 
       
4)

Schreibe ein Programm, welches das zufällige Wandern einer Turtle (siehe Beispiel 6) 100 mal wiederholt. Wie viele Schritte braucht die Turtle im Durchschnitt, um den Rand des Geheges, der die Entfernung 200 von ihrem Startpunkt hat, zu erreichen?