Assignment Chef icon Assignment Chef
All German tutorials

Programming lesson

Python-Funktionen und Turtle-Grafik: Eigene Formen mit `def` erstellen – Ein Leitfaden für CSCI 141 (Frühjahr 2019, Lab 5)

Lerne, wie du in Python eigene Funktionen definierst und mit Turtle-Grafik geometrische Formen zeichnest. Ideal für das Lab 5 der CSCI 141 im Frühjahr 2019. Inklusive Docstrings, Parameter und lokaler Variablen.

Python Funktionen definieren Turtle Shape Functions CSCI 141 Lab 5 Lösung Python def Befehl Turtle Grafik Python Docstrings Python Funktionen mit Parametern Python lokale Variablen Python Turtle Formen zeichnen Python Funktionen Tutorial Programmieren lernen mit Turtle Code wiederverwendbar machen Python für Anfänger Turtle Geometrie Lab 5 CSCI 141 Frühjahr 2019 Python Übungen mit Lösungen

Einführung: Warum Funktionen in Python wichtig sind

Stell dir vor, du entwickelst ein Spiel wie Minecraft oder eine App wie TikTok – ohne Funktionen wäre der Code ein einziges Chaos. Genau wie du in einem Spiel immer wieder dieselbe Aktion ausführst (z. B. Springen), helfen Funktionen dabei, wiederkehrende Aufgaben in Python zu bündeln. In diesem Tutorial lernst du, wie du mit def eigene Funktionen schreibst und sie mit der Turtle-Grafik kombinierst, um coole Formen zu zeichnen. Dieses Wissen ist perfekt für das CSCI 141 Lab 5 (Frühjahr 2019) zum Thema „Turtle Shape Functions“.

Grundlagen: Funktionen definieren und aufrufen

Eine Funktion ist wie ein Rezept: Du gibst ihr einen Namen und eine Liste von Anweisungen. In Python sieht das so aus:

def quadrat(seitenlaenge):
    """Zeichnet ein Quadrat mit der angegebenen Seitenlänge."""
    for _ in range(4):
        t.forward(seitenlaenge)
        t.right(90)

Hier ist quadrat der Funktionsname, seitenlaenge ein Parameter. Der Docstring (die drei Anführungszeichen) erklärt, was die Funktion tut – das ist besonders wichtig, wenn du später deinen Code mit anderen teilst. Ohne Docstring weiß niemand, was deine Funktion bewirkt, ähnlich wie bei einer App ohne Bedienungsanleitung.

Parameter und lokale Variablen

Parameter sind wie die Zutaten eines Rezepts. In der Funktion quadrat(seitenlaenge) ist seitenlaenge ein Parameter. Innerhalb der Funktion kannst du auch lokale Variablen anlegen, die nur dort existieren – wie eine temporäre Notiz, die nach dem Kochen weggeworfen wird. Beispiel:

def rechteck(breite, hoehe):
    """Zeichnet ein Rechteck mit Breite und Höhe."""
    umfang = 2 * (breite + hoehe)  # lokale Variable
    for _ in range(2):
        t.forward(breite)
        t.right(90)
        t.forward(hoehe)
        t.right(90)
    return umfang

Hier ist umfang eine lokale Variable – außerhalb der Funktion kannst du nicht darauf zugreifen. Das ist praktisch, weil du dir keine Gedanken über Namenskonflikte machen musst. Stell dir vor, du spielst Fortnite und jeder Spieler hat sein eigenes Inventar – so ähnlich funktionieren lokale Variablen.

Rückgabewerte: Mehr als nur Zeichnen

Funktionen können auch Werte zurückgeben, die du später verwenden kannst. Im Rechteck-Beispiel gibt die Funktion den Umfang zurück. Du könntest dann schreiben:

umfang_rechteck = rechteck(100, 50)
print("Umfang:", umfang_rechteck)

Das ist nützlich, wenn du zum Beispiel die Fläche einer Form berechnen und dann anzeigen möchtest. In der echten Welt wird das ständig gemacht: Wenn du eine KI-App wie ChatGPT verwendest, berechnen Funktionen im Hintergrund Wahrscheinlichkeiten und geben Texte zurück.

Turtle-Grafik: Deine erste Form

Die Turtle ist eine kleine Schildkröte, die du auf dem Bildschirm bewegen kannst. Für das Lab 5 sollst du mit Funktionen eigene Formen zeichnen. Hier ein einfaches Beispiel:

import turtle
t = turtle.Turtle()

def dreieck(seite):
    """Zeichnet ein gleichseitiges Dreieck."""
    for _ in range(3):
        t.forward(seite)
        t.left(120)

dreieck(100)
turtle.done()

Mit dieser Funktion kannst du jedes beliebige Dreieck zeichnen, indem du einfach die Seitenlänge änderst. Genauso wie du in Roblox mit Bausteinen immer wieder neue Strukturen erstellst, baust du hier mit Funktionen komplexe Grafiken.

Docstrings: Deine Code-Dokumentation

Ein guter Docstring sagt, was die Funktion tut, welche Parameter sie erwartet und was sie zurückgibt. Bei Turtle-Funktionen solltest du auch erwähnen, ob die Turtle ihre Ausrichtung oder Position ändert. Beispiel:

def stern(groesse):
    """
    Zeichnet einen fünfzackigen Stern.
    Parameter: groesse (int) – Länge der Zacken.
    Effekt: Turtle endet in der Mitte des Sterns.
    Rückgabe: Keine.
    """
    for _ in range(5):
        t.forward(groesse)
        t.right(144)

Ohne Docstring müsste jeder deinen Code lesen, um zu verstehen, was passiert – das kostet Zeit und führt zu Fehlern. In der Softwareentwicklung ist das wie eine App ohne Tutorial: Niemand weiß, wie man sie bedient.

Trend-Beispiel: Formen für ein Spiel zeichnen

Stell dir vor, du entwickelst ein einfaches Spiel im Stil von Geometry Dash. Du könntest Funktionen schreiben, um Hindernisse wie Quadrate, Dreiecke oder Kreise zu zeichnen. Mit Parametern passt du Größe und Farbe an. So könntest du zum Beispiel einen ganzen Parcours aus verschiedenen Formen zusammensetzen:

def hindernis_quadrat(groesse, farbe):
    t.fillcolor(farbe)
    t.begin_fill()
    for _ in range(4):
        t.forward(groesse)
        t.right(90)
    t.end_fill()

hindernis_quadrat(50, "rot")
t.penup()
t.forward(100)
t.pendown()
hindernis_quadrat(30, "blau")

Das ist nicht nur für Spiele nützlich – auch in der Datenvisualisierung werden oft geometrische Formen gezeichnet, um Diagramme zu erstellen. Mit Funktionen sparst du dir jede Menge Tipparbeit.

Praktische Übung: Eigene Formen für Lab 5

Für das Lab 5 sollst du wahrscheinlich mehrere Funktionen schreiben, die verschiedene Formen zeichnen. Hier ein Vorschlag, wie du vorgehen könntest:

  1. Definiere eine Funktion sechseck(seite), die ein regelmäßiges Sechseck zeichnet.
  2. Definiere eine Funktion kreis_naeherung(radius), die mit vielen kleinen Schritten einen Kreis annähert (z. B. 360 Schritte).
  3. Nutze diese Funktionen, um ein Muster zu zeichnen, zum Beispiel eine Blume aus Sechsecken.

Vergiss nicht, zu jeder Funktion einen aussagekräftigen Docstring zu schreiben. Das ist Teil der Aufgabenstellung und hilft dir, sauberen Code zu produzieren.

Fehler vermeiden: Häufige Stolperfallen

Ein typischer Fehler ist, die Turtle nach dem Zeichnen nicht zurückzusetzen. Wenn du eine Funktion schreibst, die die Turtle an einer bestimmten Position startet, sollte sie auch dort enden – sonst wird die nächste Form an der falschen Stelle gezeichnet. Ein weiterer Fehler: Parameter vergessen. Wenn deine Funktion quadrat() ohne Parameter definiert ist, kannst du die Größe nicht ändern. Das ist, als ob du in Minecraft nur eine feste Blockgröße hättest – ziemlich unpraktisch.

Zusammenfassung

Funktionen sind das Herzstück der Programmierung. Mit def erstellst du wiederverwendbare Bausteine, die du beliebig kombinieren kannst. In Kombination mit der Turtle-Grafik kannst du beeindruckende Formen zeichnen – von einfachen Quadraten bis zu komplexen Mustern. Denk immer an Docstrings, Parameter und lokale Variablen. Dann steht deinem Erfolg im CSCI 141 Lab 5 nichts mehr im Weg.

Probier es selbst aus: Öffne deine Python-Umgebung, importiere Turtle und schreibe deine erste Funktion. Mit jedem Durchgang wirst du sicherer. Viel Erfolg!