Willkommen zu diesem spannenden Projekt, in dem wir die Welt des Programmierens mit der Alltäglichkeit einer Verkehrsampel verbinden! Mit Python und seiner benutzerfreundlichen Grafikbibliothek Turtle werden wir Schritt für Schritt eine animierte Verkehrsampel erstellen. Keine Sorge, wenn Sie neu im Programmieren sind – diese Anleitung ist so konzipiert, dass sie auch für Anfänger leicht verständlich ist. Los geht’s!
Was wir benötigen
Bevor wir eintauchen, stellen Sie sicher, dass Sie Folgendes eingerichtet haben:
- Einen Computer (logisch!)
- Python installiert: Sie können die neueste Version von der offiziellen Python-Website (python.org) herunterladen.
- Eine IDE (Integrierte Entwicklungsumgebung) oder einen Texteditor: Beliebte Optionen sind VS Code, PyCharm, Thonny oder einfach der eingebaute Texteditor Ihres Betriebssystems.
Grundlagen: Die Turtle-Bibliothek
Die Turtle-Bibliothek in Python ist ein großartiges Werkzeug für Anfänger, um die Grundlagen der Programmierung kennenzulernen. Sie ermöglicht es Ihnen, eine „Schildkröte” (einen Cursor) auf dem Bildschirm zu steuern, um Formen und Grafiken zu zeichnen. Wir werden diese Schildkröte benutzen, um unsere Verkehrsampel zu erstellen.
Schritt 1: Importieren der Turtle-Bibliothek und Einrichten des Bildschirms
Öffnen Sie Ihre IDE und erstellen Sie eine neue Python-Datei (z.B. verkehrsampel.py). Fügen Sie dann die folgenden Zeilen hinzu:
import turtle
import time
# Bildschirm erstellen
screen = turtle.Screen()
screen.bgcolor("lightgray") # Hintergrundfarbe
screen.setup(width=600, height=700) # Fenstergröße
screen.title("Verkehrsampel mit Python")
Hier importieren wir die turtle-Bibliothek und die time-Bibliothek (für die Pausen zwischen den Ampelphasen). Wir erstellen dann ein screen-Objekt, das unser Zeichenfenster darstellt. Wir legen auch die Hintergrundfarbe, die Fenstergröße und den Titel fest.
Schritt 2: Die Schildkröte erstellen und konfigurieren
Als Nächstes erstellen wir unsere „Schildkröte”, die die eigentliche Zeichenarbeit erledigt:
# Schildkröte erstellen
pen = turtle.Turtle()
pen.speed(0) # Schnellste Geschwindigkeit
pen.shape("square") # Form der Schildkröte
pen.penup() # Stift hochheben, damit beim Bewegen nicht gezeichnet wird
Wir erstellen ein pen-Objekt vom Typ Turtle. Die speed(0)-Funktion setzt die Zeichengeschwindigkeit auf die schnellstmögliche. Die shape("square")-Funktion ändert die Form des Cursors in ein Quadrat. Schließlich hebt penup() den Stift hoch, sodass wir die Schildkröte bewegen können, ohne eine Linie zu zeichnen.
Schritt 3: Das Gehäuse der Verkehrsampel zeichnen
Jetzt zeichnen wir das Gehäuse der Verkehrsampel:
# Gehäuse zeichnen
def draw_rectangle(x, y, width, height, color):
pen.goto(x, y)
pen.pendown()
pen.color(color)
pen.begin_fill()
for _ in range(2):
pen.forward(width)
pen.left(90)
pen.forward(height)
pen.left(90)
pen.end_fill()
pen.penup()
draw_rectangle(-40, 80, 80, 200, "black") # Position und Größe anpassen
Wir definieren eine Funktion draw_rectangle, die ein Rechteck an einer bestimmten Position mit einer bestimmten Größe und Farbe zeichnet. Wir verwenden diese Funktion, um das schwarze Gehäuse der Verkehrsampel zu zeichnen. Die Koordinaten (-40, 80) bestimmen die obere linke Ecke des Rechtecks. Die Werte 80 und 200 bestimmen die Breite und Höhe.
Schritt 4: Die Lichter (Kreise) zeichnen
Nun kommen wir zu den eigentlichen Lichtern. Wir erstellen drei Kreise in Rot, Gelb und Grün:
# Lichter zeichnen
def draw_circle(x, y, radius, color):
pen.goto(x, y - radius) # Startposition für den Kreis
pen.pendown()
pen.color(color)
pen.begin_fill()
pen.circle(radius)
pen.end_fill()
pen.penup()
red_light_y = 60
yellow_light_y = -20
green_light_y = -100
red_light = draw_circle(0, red_light_y, 30, "red")
yellow_light = draw_circle(0, yellow_light_y, 30, "gray")
green_light = draw_circle(0, green_light_y, 30, "gray")
Wir definieren eine draw_circle-Funktion, die einen Kreis an einer bestimmten Position mit einem bestimmten Radius und einer bestimmten Farbe zeichnet. Wir verwenden diese Funktion, um drei Kreise zu zeichnen: einen roten (oben), einen gelben (in der Mitte) und einen grünen (unten). Beachten Sie, dass wir die gelben und grünen Lichter zunächst in „gray” zeichnen, um anzudeuten, dass sie aus sind. Die Y-Koordinaten red_light_y, yellow_light_y und green_light_y positionieren die Kreise vertikal innerhalb des Gehäuses.
Schritt 5: Die Ampelanimation
Jetzt kommt der aufregende Teil: Wir lassen die Ampel animieren!
# Ampel-Logik
while True:
# Rot
draw_circle(0, red_light_y, 30, "red")
draw_circle(0, yellow_light_y, 30, "gray")
draw_circle(0, green_light_y, 30, "gray")
time.sleep(2) # 2 Sekunden Rot
# Rot und Gelb
draw_circle(0, red_light_y, 30, "red")
draw_circle(0, yellow_light_y, 30, "yellow")
draw_circle(0, green_light_y, 30, "gray")
time.sleep(1) # 1 Sekunde Rot und Gelb
# Grün
draw_circle(0, red_light_y, 30, "gray")
draw_circle(0, yellow_light_y, 30, "gray")
draw_circle(0, green_light_y, 30, "green")
time.sleep(2) # 2 Sekunden Grün
# Gelb
draw_circle(0, red_light_y, 30, "gray")
draw_circle(0, yellow_light_y, 30, "yellow")
draw_circle(0, green_light_y, 30, "gray")
time.sleep(1) # 1 Sekunde Gelb
Wir verwenden eine while True-Schleife, um die Ampelphasen kontinuierlich zu wiederholen. Innerhalb der Schleife zeichnen wir die Kreise in den entsprechenden Farben für jede Phase (Rot, Rot und Gelb, Grün, Gelb). time.sleep() pausiert das Programm für eine bestimmte Anzahl von Sekunden, wodurch die Verzögerungen zwischen den Phasen simuliert werden. Beachten Sie, dass wir bei jedem Phasenwechsel die Lichter in „gray” zurücksetzen, bevor wir die aktuelle Farbe zeichnen.
Schritt 6: Beenden
Um zu verhindern, dass das Fenster sofort geschlossen wird, fügen Sie die folgende Zeile am Ende Ihres Codes hinzu:
turtle.done()
Dies hält das Turtle-Fenster offen, bis Sie es manuell schließen.
Der vollständige Code
Hier ist der vollständige Code für Ihre Bequemlichkeit:
import turtle
import time
# Bildschirm erstellen
screen = turtle.Screen()
screen.bgcolor("lightgray")
screen.setup(width=600, height=700)
screen.title("Verkehrsampel mit Python")
# Schildkröte erstellen
pen = turtle.Turtle()
pen.speed(0)
pen.shape("square")
pen.penup()
# Gehäuse zeichnen
def draw_rectangle(x, y, width, height, color):
pen.goto(x, y)
pen.pendown()
pen.color(color)
pen.begin_fill()
for _ in range(2):
pen.forward(width)
pen.left(90)
pen.forward(height)
pen.left(90)
pen.end_fill()
pen.penup()
draw_rectangle(-40, 80, 80, 200, "black")
# Lichter zeichnen
def draw_circle(x, y, radius, color):
pen.goto(x, y - radius)
pen.pendown()
pen.color(color)
pen.begin_fill()
pen.circle(radius)
pen.end_fill()
pen.penup()
red_light_y = 60
yellow_light_y = -20
green_light_y = -100
red_light = draw_circle(0, red_light_y, 30, "red")
yellow_light = draw_circle(0, yellow_light_y, 30, "gray")
green_light = draw_circle(0, green_light_y, 30, "gray")
# Ampel-Logik
while True:
# Rot
draw_circle(0, red_light_y, 30, "red")
draw_circle(0, yellow_light_y, 30, "gray")
draw_circle(0, green_light_y, 30, "gray")
time.sleep(2)
# Rot und Gelb
draw_circle(0, red_light_y, 30, "red")
draw_circle(0, yellow_light_y, 30, "yellow")
draw_circle(0, green_light_y, 30, "gray")
time.sleep(1)
# Grün
draw_circle(0, red_light_y, 30, "gray")
draw_circle(0, yellow_light_y, 30, "gray")
draw_circle(0, green_light_y, 30, "green")
time.sleep(2)
# Gelb
draw_circle(0, red_light_y, 30, "gray")
draw_circle(0, yellow_light_y, 30, "yellow")
draw_circle(0, green_light_y, 30, "gray")
time.sleep(1)
turtle.done()
Fazit
Herzlichen Glückwunsch! Sie haben erfolgreich eine animierte Verkehrsampel mit Python und der Turtle-Bibliothek erstellt. Dieses Projekt ist ein großartiger Ausgangspunkt, um mehr über grafische Programmierung und die Grundlagen der Python-Syntax zu erfahren. Experimentieren Sie mit verschiedenen Farben, Formen und Timings, um Ihre eigene, einzigartige Verkehrsampel zu erstellen. Viel Spaß beim Programmieren!