---

🧩 Funktionen mit Turtle 🐢🐢🐢

Code strukturieren und wiederverwenden

Einstieg: Worum geht es in diesem Kapitel?

In den letzten Einheiten hast du mit Turtle gezeichnet, Schleifen verwendet und Muster erzeugt. Dabei hast du vielleicht bemerkt: Manche Code-Teile braucht man immer wieder. Ein Quadrat, ein Dreieck, eine Bewegung zur nächsten Position oder eine zufällige Farbe können mehrfach vorkommen.

Wenn man denselben Code immer wieder kopiert, wird ein Programm schnell unübersichtlich. Außerdem ist es mühsam, später etwas zu ändern.

Genau hier helfen Funktionen. Eine Funktion fasst mehrere Befehle unter einem Namen zusammen. Danach kannst du diese Befehle immer wieder aufrufen.

Merksatz

Eine Funktion bündelt Code, den du später wiederverwenden kannst.

Grundlagen: Funktionen verstehen

Warum Funktionen?

Stell dir vor, du möchtest an mehreren Stellen ein Quadrat zeichnen. Ohne Funktion müsstest du den Code jedes Mal neu schreiben. Mit einer Funktion definierst du einmal, wie ein Quadrat gezeichnet wird, und rufst diese Funktion danach einfach auf.

Das macht deinen Code:

• kürzer
• übersichtlicher
• leichter veränderbar
• besser wiederverwendbar

In dieser Einheit arbeitest du wieder mit Turtle in PyCharm. Denke daran:

turtle.done()

muss am Ende deines Turtle-Programms stehen.

Eine erste Funktion

Eine Funktion beginnt in Python mit def. Das steht für define, also „definieren“.

import turtle

def square():
    for i in range(4):
        turtle.forward(100)
        turtle.left(90)

turtle.done()

Mit def square(): wird die Funktion definiert. Mit square() wird sie aufgerufen. Erst beim Aufruf wird der Code in der Funktion ausgeführt.

Häufiger Fehler

Eine Funktion wird nur ausgeführt, wenn du sie aufrufst. Das Definieren mit def allein zeichnet noch nichts.

Funktionen und Einrückung

Wie bei Schleifen ist die Einrückung entscheidend. Alles, was zur Funktion gehört, muss eingerückt sein.

def square():
    turtle.forward(100)
    turtle.left(90)

Der Doppelpunkt nach def square(): zeigt: Jetzt beginnt ein eingerückter Codeblock.

Merkhilfe

Bei Python zeigen Einrückungen, welche Befehle zusammengehören.

Kurze und klare Funktionsnamen

Funktionsnamen sollen verständlich sein. In dieser Einheit verwenden wir eher kurze Namen, damit der Code gut lesbar bleibt.

Sinnvolle Namen sind zum Beispiel:

square()
triangle()
shape()
next_shape()
next_line()

Weniger sinnvoll wären Namen wie:

abc()
ding()
test123()

Gute Praxis

Ein Funktionsname soll kurz sein, aber trotzdem verraten, was die Funktion macht.

Ein Dreieck als Funktion

Ein Dreieck kann zum Beispiel so als Funktion geschrieben werden:

import turtle

def triangle():
    for i in range(3):
        turtle.forward(70)
        turtle.left(360/3)

triangle()

turtle.done()

Auch hier gilt: Die Funktion wird erst ausgeführt, wenn du triangle() aufrufst.

🐢 Challenge 1: Eine Zeile aus Formen

Erstelle eine Funktion für ein Quadrat und eine Funktion für ein Dreieck.

Verwende beide Funktionen, um das Muster aus der Vorlage zu zeichnen.

Arbeite weiter in einem Python-File. Strukturiere deinen Code mit Kommentaren.

# Challenge 1
# Quadrat- und Dreieckfunktionen

Dein Programm soll mindestens diese Funktionen enthalten:

start()
square()
triangle()
next_shape()

Die Funktion start() soll die Turtle an eine sinnvolle Startposition bringen. Überlege selbst, welche Koordinaten dafür passen. Die Funktion next_shape() soll die Turtle danach jeweils zur nächsten Form bewegen.

Hinweis

Überlege zuerst, welche Teilformen sich wiederholen. Danach überlege, wo dein Muster beginnen soll und wie groß der Abstand zwischen den Formen sein muss.

Wichtig

Die Startposition und die Abstände sollen nicht zufällig gewählt werden. Teste deine Werte so lange, bis das Muster gut sichtbar und sinnvoll platziert ist.

Muster strukturieren: Bewegung, Wiederholung und Zeilen

Bewegungen auslagern

Wenn du mehrere Formen zeichnest, muss die Turtle oft an eine neue Position bewegt werden. Auch diese Bewegung kannst du in eine Funktion auslagern.

Eine Funktion wie next_shape() soll die Turtle zur nächsten Form bewegen, ohne dabei eine störende Linie zu zeichnen.

Dafür können diese Befehle hilfreich sein:

turtle.penup()
turtle.forward(...)
turtle.pendown()

penup() hebt den Stift an. Die Turtle kann sich dann bewegen, ohne zu zeichnen. Mit pendown() setzt du den Stift wieder ab.

Merksatz

Nicht nur Formen können als Funktionen geschrieben werden. Auch wiederkehrende Bewegungen können eigene Funktionen sein.

Muster wiederholen

Wenn eine Zeile deines Musters funktioniert, kannst du überlegen, welche Teile sich wiederholen. Vielleicht musst du nicht jede Form einzeln aufrufen, sondern kannst eine Schleife verwenden.

Eine Schleife kann zum Beispiel mehrmals eine Form zeichnen und danach jeweils zur nächsten Position wechseln.

Hinweis

Prüfe zuerst, ob dein Muster einmal korrekt funktioniert. Danach kannst du überlegen, welche Befehle sich wiederholen und durch eine Schleife ersetzt werden können.

Die nächste Zeile planen

Für ein größeres Muster brauchst du nicht nur eine Bewegung zur nächsten Form, sondern auch eine Bewegung in die nächste Zeile.

Dafür ist eine weitere Funktion sinnvoll:

next_line()

Diese Funktion soll die Turtle so bewegen, dass die nächste Zeile an einer passenden Stelle beginnt. Dabei gibt es zwei naheliegende Möglichkeiten.

Möglichkeit 1: Mit ycor()

Manchmal ist es praktisch, die aktuelle Position der Turtle auszulesen. Dafür gibt es:

turtle.xcor()
turtle.ycor()

turtle.xcor() liefert die aktuelle x-Position der Turtle. turtle.ycor() liefert die aktuelle y-Position der Turtle.

Für next_line() ist vor allem turtle.ycor() hilfreich, weil du die Turtle relativ zur aktuellen Höhe eine Zeile nach unten setzen kannst.

Eine mögliche Idee ist:

def next_line():
    turtle.penup()
    turtle.setposition(-300, turtle.ycor() - 130)
    turtle.pendown()

Dieser Befehl bedeutet:

• Die Turtle wird auf die x-Position -300 gesetzt.
• Die aktuelle y-Position wird mit turtle.ycor() ausgelesen.
• Von dieser y-Position werden 130 abgezogen.
• Dadurch springt die Turtle eine Zeile nach unten.

Die Werte -300 und 130 sind nur Beispiele. Du musst sie an dein Muster anpassen.

Merksatz

Mit ycor() kannst du die aktuelle Höhe der Turtle auslesen und daraus die Position der nächsten Zeile berechnen.

Möglichkeit 2: Manuell mit Bewegung und Drehung

Du kannst eine neue Zeile auch ohne Koordinaten beginnen. Dann bewegst du die Turtle relativ zu ihrer aktuellen Position.

Eine mögliche Idee ist:

def next_line():
    turtle.penup()
    turtle.backward(520)
    turtle.right(90)
    turtle.forward(130)
    turtle.left(90)
    turtle.pendown()

Diese Variante bedeutet ungefähr:

• Die Turtle geht zurück an den Anfang der Zeile.
• Sie dreht sich nach unten.
• Sie geht eine Zeile nach unten.
• Sie dreht sich wieder in die ursprüngliche Richtung.

Wichtig

Bei dieser Variante ist die Blickrichtung der Turtle entscheidend. Wenn die Turtle vorher anders ausgerichtet ist, bewegt sie sich möglicherweise nicht dorthin, wo du es erwartest.

Hinweis

Für strukturierte Muster ist die Variante mit setposition() und ycor() oft leichter zu kontrollieren. Die manuelle Variante hilft aber gut zu verstehen, wie Bewegungen und Richtungen zusammenhängen.

Expert:innenwissen: Richtung bewusst setzen mit setheading()

Wenn du mit relativen Bewegungen arbeitest, kann es hilfreich sein, die Blickrichtung der Turtle bewusst festzulegen. Dafür gibt es setheading().

turtle.setheading(0)

setheading(0) richtet die Turtle nach rechts aus. Danach ist klarer, in welche Richtung forward() läuft.

Weitere wichtige Richtungen:

turtle.setheading(0)    # nach rechts
turtle.setheading(90)   # nach oben
turtle.setheading(180)  # nach links
turtle.setheading(270)  # nach unten

Das kann besonders hilfreich sein, wenn deine Turtle nach dem Zeichnen einer Form in eine unerwartete Richtung schaut.

Verschachtelte Schleifen

Wenn du mehrere Reihen und Spalten zeichnen möchtest, helfen verschachtelte Schleifen. Das bedeutet: Eine Schleife befindet sich innerhalb einer anderen Schleife.

Die innere Schleife kann eine Zeile zeichnen. Die äußere Schleife kann dafür sorgen, dass mehrere Zeilen entstehen.

Merksatz

Eine verschachtelte Schleife eignet sich gut für Muster mit Reihen und Spalten.

🐢 Challenge 2: Muster mit mehreren Zeilen

Erweitere dein Programm aus Challenge 1.

Du sollst nicht neu beginnen, sondern deine bestehenden Funktionen weiterverwenden und sinnvoll ergänzen.

Verwende weiterhin:

start()
square()
triangle()
next_shape()

Ergänze zusätzlich eine Funktion für den Wechsel in die nächste Zeile:

next_line()

Zeichne nun mit verschachtelten Schleifen ein größeres Muster aus mehreren Zeilen.

Dein Programm soll danach mindestens diese Funktionen enthalten:

start()
square()
triangle()
next_shape()
next_line()

Hinweis

Die innere Schleife kann eine Zeile zeichnen. Die äußere Schleife kann dafür sorgen, dass mehrere Zeilen entstehen. Nach jeder Zeile brauchst du eine passende Bewegung zur nächsten Zeile.

Wichtig

Arbeite bewusst auf Basis deiner Lösung aus Challenge 1 weiter. Ziel ist nicht, den Code neu zu schreiben, sondern ihn mit einer weiteren Funktion und einer verschachtelten Schleife zu erweitern.

Zufall und Farben

Zufallszahlen verwenden

Bisher hast du Farben selbst festgelegt. Nun soll Python zufällige Farben erzeugen.

Dafür brauchst du die Funktion randint() aus der Bibliothek random.

from random import randint

Dann kannst du eine zufällige ganze Zahl erzeugen:

zahl = randint(0, 255)

Das Ergebnis ist eine Zahl zwischen 0 und 255.

Wichtig

Für RGB-Farben mit Werten von 0 bis 255 brauchst du wieder turtle.colormode(255).

Zufällige Farben mit Turtle

Eine zufällige Farbe kann direkt mit drei Zufallszahlen gesetzt werden:

from random import randint
import turtle

turtle.colormode(255)

turtle.color(randint(0, 255), randint(0, 255), randint(0, 255))

Die drei Werte stehen für Rot, Grün und Blau.

Merksatz

Eine RGB-Farbe besteht aus drei Zahlen: Rot, Grün und Blau.

Eine Farbfunktion als Zusatzidee

Wenn du zufällige Farben öfter brauchst, kannst du auch dafür eine Funktion erstellen.

def random_color():
    turtle.color(randint(0, 255), randint(0, 255), randint(0, 255))

Diese Funktion setzt direkt eine zufällige Turtle-Farbe. Du kannst sie dann vor dem Zeichnen oder Füllen einer Form aufrufen:

random_color()

Hinweis

Für Challenge 3 ist eine eigene Farbfunktion nicht zwingend notwendig. Du kannst die zufällige Farbe auch direkt mit turtle.color(randint(...), randint(...), randint(...)) setzen.

🐢 Challenge 3: Zufällige Farben

Verwende zufällige Farben für deine Formen.

Nutze dafür:

• randint()
• turtle.colormode(255)
• turtle.color()
• begin_fill()
• end_fill()

Hinweis

Setze die Farbe direkt vor dem Füllen der jeweiligen Form. Du brauchst für jede RGB-Farbe drei Zahlen: Rot, Grün und Blau.

Parameter und flexible Formen

Werte an Funktionen übergeben

Bisher zeichnet eine Funktion immer genau dasselbe. Das ist praktisch, aber manchmal zu unflexibel.

In der letzten Einheit hast du mit einer Variable wie seiten regelmäßige Vielecke gezeichnet. Dieses Prinzip kannst du nun in eine Funktion übertragen.

Eine Funktion kann einen Wert erhalten und diesen Wert im eigenen Code verwenden. Dieser übergebene Wert heißt Parameter.

def shape(sides):
    for i in range(sides):
        turtle.forward(100)
        turtle.left(360 / sides)

Beim Aufruf gibst du an, wie viele Seiten die Form haben soll:

shape(5)
shape(8)
shape(12)

shape(5) zeichnet ein Fünfeck. shape(8) zeichnet ein Achteck. shape(12) zeichnet ein Zwölfeck.

Merksatz

Ein Parameter macht eine Funktion flexibler.

Seitenlänge anpassen

Wenn alle Formen ungefähr gleich groß wirken sollen, reicht es nicht immer, nur die Seitenzahl zu ändern. Ein Dreieck mit Seitenlänge 100 wirkt anders als ein Zwölfeck mit Seitenlänge 100.

Du kannst daher auch die Seitenlänge als zweiten Parameter übergeben:

def shape(sides, length):
    for i in range(sides):
        turtle.forward(length)
        turtle.left(360 / sides)

Dann kannst du die Funktion so aufrufen:

shape(3, 100)
shape(6, 70)
shape(12, 40)

Bei dieser Version bedeutet length: Jede einzelne Seite der Form ist genau so lang. Wenn du also bei vielen Seiten dieselbe Seitenlänge verwendest, wird die gesamte Form größer.

Hinweis

Funktionen können mehrere Parameter haben. Die Reihenfolge beim Aufruf muss zu deiner Definition passen.

Formen über den Umfang maßstabsgetreu annähern

Für Challenge 4 ist es sinnvoll, darüber nachzudenken, wie Formen mit unterschiedlicher Seitenanzahl ungefähr gleich groß wirken können.

Eine Möglichkeit ist, nicht die Länge einer einzelnen Seite zu übergeben, sondern einen ungefähren Umfang. Auf Englisch nennt man Umfang circumference. Der Umfang beschreibt die gesamte Strecke rund um die Form. Wenn dieser Umfang gleich bleibt, müssen die einzelnen Seiten bei mehr Seiten kürzer werden.

Die Funktionsidee könnte dann so beginnen:

def shape(sides, circumference):
    for i in range(sides):
        turtle.forward(...)
        turtle.left(360 / sides)

Jetzt bedeutet circumference nicht mehr „Länge einer einzelnen Seite“, sondern ungefähr „Gesamtstrecke um die Form herum“.

Überlege:

Was muss bei turtle.forward(...) stehen, wenn der Umfang auf alle Seiten verteilt werden soll?

Hinweis

Wenn der Umfang auf mehrere Seiten aufgeteilt wird, hängt die Länge einer einzelnen Seite von sides ab.

Wichtig

Diese Lösung sorgt nicht dafür, dass alle Formen exakt dieselbe Fläche haben. Sie ist aber eine gute Annäherung für Turtle-Muster, weil Formen mit vielen Seiten dadurch nicht automatisch viel größer werden.

🐢 Challenge 4: Zufällige regelmäßige Formen

Erstelle eine Funktion, die regelmäßige Formen mit beliebiger Seitenanzahl zeichnen kann.

Die Formen sollen ungefähr gleich groß wirken.

Verwende anschließend randint(), um zufällige Formen in einem Muster zu zeichnen.

Hinweis

Du kannst die Seitenzahl zufällig wählen, zum Beispiel zwischen 3 und 10. Überlege außerdem, wie du die Seitenlänge sinnvoll anpassen kannst.

Erinnerung

Ein Parameter macht eine Funktion flexibler. Statt für jede Form eine eigene Funktion zu schreiben, kann eine Funktion mit Parametern verschiedene Formen erzeugen.

Komplexere Muster planen

Ein Hexagon-Muster planen

Nun wird es komplexer: Du sollst ein Muster aus mehreren Dreiecken erstellen, das wie ein Hexagon-Muster wirkt.

Dafür ist es sinnvoll, das Problem in kleinere Teile zu zerlegen:

• eine zufällige Farbe erzeugen
• ein Dreieck zeichnen
• ein Hexagon-Muster aus Dreiecken zusammensetzen
• die Turtle an eine zufällige Position bewegen

Genau dafür sind Funktionen gedacht. Du musst nicht alles in einem langen Codeblock lösen, sondern kannst dein Programm in sinnvolle Bausteine aufteilen.

Merksatz

Bei größeren Aufgaben hilft es, zuerst die Teilprobleme zu erkennen. Aus diesen Teilproblemen können Funktionen entstehen.

🐢 Challenge 5: Hexagon-Muster

Erstelle ein Programm, das ein Hexagon-Muster mehrfach an zufälligen Positionen zeichnet.

Dein Programm soll enthalten:

• eine Funktion für eine zufällige Farbe oder eine direkte Zufallsfarbe
• eine Funktion triangle()
• eine Funktion für das Hexagon-Muster
• Code, der die Turtle nach jedem Muster an eine zufällige Position bewegt

Hinweis

Es kann hilfreich sein, das Hexagon-Muster zuerst ohne Funktion und ohne Schleife zu testen. Danach kannst du den Code schrittweise verbessern.

Wichtig

Achte darauf, dass deine Funktionen klar getrennte Aufgaben haben. Eine Funktion sollte nicht „alles auf einmal“ erledigen.

Weitere Muster mit Funktionen

Wenn du Funktionen sinnvoll verwendest, kannst du auch größere Muster deutlich übersichtlicher zeichnen. Du musst nicht jedes Detail neu schreiben, sondern kannst vorhandene Bausteine wiederverwenden.

🐢 Challenge 6: Neues Muster

Erstelle ein neues Programm und zeichne das Muster aus der Vorlage.

Verwende Code aus dieser und den vorherigen Einheiten, wenn er dir hilft.

Hinweis

Überlege zuerst, welche Teilform sich wiederholt. Daraus kann eine Funktion entstehen.

Zusatzidee

Du kannst Code aus früheren Challenges wiederverwenden und anpassen. Das ist kein Schummeln, sondern ein wichtiger Teil des Programmierens.

Allgemeines zum Erlernen einer Programmiersprache

In dieser Einheit geht es nicht nur darum, neue Befehle kennenzulernen. Der wichtige Schritt ist, Code bewusst zu strukturieren.

Funktionen helfen dir, ein größeres Problem in kleinere Teilprobleme zu zerlegen. Wenn ein Muster schwierig wirkt, frage dich zuerst:

• Welche Teile wiederholen sich?
• Welche Aufgabe kann eine eigene Funktion übernehmen?
• Welche Werte sollten flexibel bleiben?
• Welche Funktionen kann ich wiederverwenden?

So arbeitest du nicht einfach Zeile für Zeile weiter, sondern beginnst, dein Programm zu planen.

Wissensspeicher

Wichtige Begriffe

Funktion Ein benannter Codeblock, der eine bestimmte Aufgabe ausführt.

Unterprogramm / Subroutine Anderer Begriff für eine Funktion.

def Schlüsselwort, mit dem eine Funktion definiert wird.

Funktionsaufruf Ausführen einer Funktion, zum Beispiel square().

Parameter Wert, den eine Funktion beim Aufruf erhalten kann.

Argument Konkreter Wert, der an eine Funktion übergeben wird, zum Beispiel 5 in shape(5).

return Gibt einen Wert aus einer Funktion zurück.

verschachtelte Schleife Eine Schleife innerhalb einer anderen Schleife.

randint() Funktion aus der Bibliothek random, die eine zufällige ganze Zahl erzeugt.

RGB-Farbe Farbe aus drei Werten für Rot, Grün und Blau.

turtle.colormode(255) Legt fest, dass RGB-Werte von 0 bis 255 verwendet werden.

xcor() / ycor() Befehle, mit denen du die aktuelle x- oder y-Position der Turtle auslesen kannst.

setheading() Befehl, mit dem du die Blickrichtung der Turtle bewusst setzen kannst.

Abschlussgedanke

Funktionen sind ein wichtiger Schritt vom Ausprobieren zum planvollen Programmieren. Sie helfen dir, Code zu ordnen, wiederzuverwenden und größere Aufgaben in kleinere lösbare Teile zu zerlegen.

Weitere Beispiele zur Vorbereitung auf praktische Übung

https://www.coding4you.at/python/turtle.html