# data[].attributes.body
Du musst die Module

import turtle und
import random

importieren, auch um unterschiedliche Farben zu erzeugen. Dann erzeugst du aus Turtle eine Kopie für den Abdruck

stamp = turtle.Turtle()

Du musst den Stift abheben, so dass nur die Abdrücke erscheinen.

stamp.penup()

# data[].attributes.body
Python ist eine sehr bekannte textbasierte Programmiersprache, die in vielen Bereichen (Industrie, Wissenschaft, Spieleentwicklung u.s.w.)  zur Erstellung von Programmen  eingesetzt wird. Die Sprache ist objektorientiert, d.h. es gibt dort 'Module", die bestimmte Aufgaben erledigen. Python ist in diesem Punkt ähnlich aufgebaut, wie C/C++, Java. Python ist eine OpenSource Software.
Der Name Python bezieht sich nicht auf die bekannte Schlange, sondern wurde vom Entwickler Guido von Rossum in Anlehnung an die britische Komikergruppe Monty Python ("Das Leben des Brian") gewählt.

# data[].attributes.body
Python kann von der offiziellen Python Website heruntergeladen werden.

# data[].attributes.attachment_link.readable_text
Python is a programming language that lets you work quickly and integrate systems more effectively. Learn More

Fundraiser deal on now: Get a discount on PyCharm + all proceeds go to the Python Software Foundation. Ending soon! GET THE DEAL

# data[].attributes.attachment_link.keywords[]
python programming language object oriented web free open source software license documentation download community

# data[].attributes.attachment_link.description
The official home of the Python Programming Language

# data[].attributes.body
So startest du Python 3.10:

1. Gehe zum Windows Zeichen ganz links unten.

2. Klicke auf <Alle Programme>.

3. Scrolle herunter bis du Python 3.10 findest.

4. Starte dann das Programm IDLE. Das ist der Python Editor. Gleichzeit geht eine Windows Konsole auf, die du minimieren kannst (nicht schließen).

Im IDLE kannst du jetzt Befehle eingeben, z.B. 3 + 5, die dann sofort ausgeführt werden.

Um ein neues Programm zu schreiben, klicke links oben File --> New File an. Es geht ein neues Fenster auf. Hier kannst du dein Programm schreiben. Vor der Ausführung muss es gespeichert werden, am besten speicherst du sofort mit einem Namen, danach musst du nur noch <strg>+s drücken.

Zum Ausführen gehst du auf Run --> Run Module.

# data[].attributes.body
Mit Visual Studio Code können Programme in unterschiedlichen Programmiersprachen (JavaScript, Python, HTML etc.) geschrieben werden.

# data[].attributes.attachment_link.title
Visual Studio Code - Code Editing. Redefined

# data[].attributes.attachment_link.description
Visual Studio Code is a code editor redefined and optimized for building and debugging modern web and cloud applications. Visual Studio Code is free and available on your favorite platform - Linux, macOS, and Windows.

# data[].attributes.body
Ein Modul ist in Python ein Bereich, in dem viele vorgefertigte Funktionen vorhanden sind. Es gibt dort Funktionen für die Bewegung, für das Aussehen und für die Steuerung von Programmen.
Um dieses Modul und alle Funktionen zu laden, musst du am Anfang des Programms den Befehl

import turtle

eingeben. es passiert nach <enter> nichts weiter. Das Modul ist geladen und die Befehle können jetzt benutzt werden.

# data[].attributes.body
Du kannst die Turtle mit dem Befehl

turtle.shape('turtle')

anzeigen.

# data[].attributes.body
Die Größe des Output Fensters kannst du über den Befehl

turtle.setup(500, 500)

definieren. Probiere verschiedene Größen aus.

# data[].attributes.body
Die Farbe des Output Fensters wird über das Objekt Screen() eingestellt.

turtle.Screen().bgcolor("blue")

bgcolor() ist die Funktion für die Hintergrundfarbe, die im Objekt Screen aufgerufen wird.

# data[].attributes.body
Du sollst jetzt alle Befehle in einem kleinen Programm zusammenfassen:

import turtle
turtle.setup(500, 500)
turtle.Screen().bgcolor("lightblue")
turtle.shape('turtle')

Für die Farbe wählst du ein helleres Blau. Das Programmierfenster öffnen, speichern, Befehle eingeben.

# data[].attributes.body
Du kannst die Farben der Turtle auch über die RGB (Red-Green-Blue) Farben einstellen. Der Zahlenbereich geht jeweils von 0 bis 255. Der Zahlenwert gibt den Anteil der jeweiligen Farbe wieder. Um das zu aktivieren musst du

turtle.Screen().colormode(255)

eingeben. Hellblau wäre

turtle.Screen().bgcolor(29, 162, 216)

Damit die Turtle grün wird kannst du

turtle.color(9, 185, 13)

eingeben. Die Farbe des Umrisses veränderst du mit

turtle.pencolor(0, 120, 0)

Die Größe der Turtle wird mit dem Befehl

turtle.turtlesize(10, 10, 2)

eingestellt. Du kannst auch andere Zahlen einsetzen, probiere es aus. Mit dem Befehl

turtle.resizemode('auto')

wird die Turtle wieder auf die Originalgröße zurückgesetzt.

Füge diese Befehle deinem ersten Programm hinzu.

# data[].attributes.body
Du kannst die Turtle auf dem Bildschirm (Screen) mit vier Befehlen bewegen:

turtle.forward()   -> vorwärts gehen

turtle.back()        -> rückwärts gehen

turtle.left()           -> nach links drehen

turtle.right()        -> nach rechts drehen

In den Klammern ist bei Vor-und Rückwärts die Anzahl der Pixel (z.B. 200), bei der Drehung der jeweilige Winkel. Alle Zahlen können positiv oder negativ sein.

# data[].attributes.body
Zu Beginn legst du die Größe und die Umrandung der Turtle fest:

turtle.turtlesize(3, 3, 2)

turtle.turtlesize(outline=3)

Die Farbe des Screens kannst du wählen.

# data[].attributes.body
Wir starten mit unserem ersten Programm:

import turtle
turtle.setup(500, 500)
turtle.Screen().bgcolor("lightblue")
turtle.Screen().colormode(255)
turtle.color(9, 185, 13)
turtle.pencolor(0, 120, 0)
turtle.turtlesize(3, 3, 2)
turtle.turtlesize(outline=3)
turtle.shape('turtle')

Jetzt fügen wir die Bewegung hinzu. Du kannst dir z.B. einen Weg aufzeichnen als Plan.

hier ist ein Beispiel:

turtle.forward(100)
turtle.right(90)
turtle.forward(100)
turtle.left(45)
turtle.forward(50)
turtle.right(135)
turtle.forward(200)
turtle.right(135)
turtle.forward(50)
turtle.left(45)
turtle.forward(200)
turtle.right(360)

# data[].attributes.body
Du kannst auch eine Wiederholungsschleife einfügen:

for i in range(1, 5):

Den Doppelpunkt nicht vergessen, die folgenden Befehle werden eingerückt.

for i in range(1, 5):
turtle.forward(100)
turtle.right(90)
turtle.forward(100)
turtle.left(45)
turtle.forward(50)
turtle.right(135)
turtle.forward(200)
turtle.right(135)
turtle.forward(50)
turtle.left(45)
turtle.forward(200)
turtle.right(360)

# data[].attributes.body
Du hast gesehen, dass das Turtle Modul über viele grafische Funktionen verfügt, Deshalb erstellen wir jetzt eine Kopie des Moduls Turtle und nennen diese Kopie pen. Das Modul pen verfügt über die gleichen Eigenschaften wie turtle. In Python nennt man dieses eine Instanz des Moduls turtle. Du schreibst:

pen = turtle.Turtle()

Jetzt funktionieren alle Funktionen, die du für turtle kennst auch für pen:

pen.color("blue")
pen.pensize(5)
pen.forward(100)

Probiere es aus!

# data[].attributes.body
Du kannst mit dem pen ein Quadrat zeichnen, in dem du immer gerade aus gehst, nach links drehst, gerade aus gehst, nach links drehst und so weiter. Die Befehle kannst du kopieren und untereinander einfügen (strg+c und strg+v).

pen.forward(100)
pen.left(90)
pen.forward(100)
pen.left(90)
pen.forward(100)
pen.left(90)
pen.forward(100)
pen.left(90)

Jetzt ist das Quadrat fertig. Der Pfeil stört noch etwas. Du kannst ihn mit

pen.hideturtle()

verschwinden lassen.

# data[].attributes.body
Um Tipparbeit zu sparen, kannst du eine Wiederholungsschleife benutzen (das ist immer sinnvoll, wenn du in deinem Programm Befehle siehst, die sich wiederholen).

for i in range (1, 5):
pen.forward(100)
pen.left(90)

Den Doppelpunkt nicht vergessen! Die Befehle werden automatisch eingerückt,

# data[].attributes.body
Zuerst musst das Modul turtle importieren:

import turtle

Dann definierst du die Anzeigeeigenschaften:

turtle.setup(500, 500)
turtle.Screen().bgcolor("lightblue")
turtle.Screen().colormode(255)

Jetzt erstellst du den pen:

pen = turtle.Turtle()

Dann werden die Eigenschaften des pens definiert:

pen.color("red")
pen.pensize(5)

Jetzt kannst du das Quadrat zeichnen und den pen verstecken:

for i in range(1, 5):
pen.forward(100)
pen.left(90)
pen.hideturtle()

# data[].attributes.body
Mit dem Befehl fillcolor() kannst du Formen mit einer Farbe ausfüllen. Dieser Befehl gehört zum Turtle Modul bzw. zu pen, wenn diese Kopie erzeugt worden ist.

turtle.fillcolor("orange")
pen.fillcolor(*orange")

Du kannst eine Form füllen, wenn du am Beginn der Zeichnung den Befehl:

pen.begin_fill()

eingibst. Das Füllen wird mit dem Befehl:

pen.end_fill()

beendet.

# data[].attributes.body
Um einen Kreis auszufüllen kannst du folgendes eingeben:

pen.fillcolor("orange")
pen.begin_fill()
pen.circle(50)
pen.end_fill()

# data[].attributes.body
Die Funktion circle hat drei Parameter. Wird nur ein Parameter übergeben, wir der Radius genommen.

circle(50)

zeichnet also einen Kreis mit einem Radius von 50.

circle(50, 270)

zeichnet einen Kreis mit dem Radius 50 bis zu einem Winkel von 270°.

# data[].attributes.body
Wenn du die circle Funktion in einer Wiederholungsschleife aufrufst und dabei den Radius immer vergrößerst erhält du eine Spirale (# bedeutet Kommentar):

import turtle
#radius festlegen
r = 1
#kreis mit schleife
for i in range (1, 100):
turtle.circle(r+i, 45)

Das ist ein einfaches Programm ohne Einstellungen für den Screen und die Farben. Das kannst du jetzt hinzufügen.

# data[].attributes.body
Du kannst einen Trichter zeichnen, wenn du bei jeder Wiederholung in einer Schleife den Radius vergrößerst und die Kreise vollständig sind (360°):

import turtle
#kleinster Radius
r = 10
#Anzahl der Radien
n = 50
#Schrittweite
step = 4
#Trichter zeichnen
for i in range (1,n,step):
turtle.circle(r+i)

# data[].attributes.body
Mit dem Befehl

stamp() kannst du einen Abdruck erstellen. Du kennst diesen Befehl vielleicht auch von Scratch. Zuerst wird eine Kopie des Turtle Objekts erstellt:

turtle_stamp = turtle.Turtle()

Dann erstellt du die Farben und die Form des Abdrucks:

turtle_stamp.shape('turtle')
turtle_stamp.color('green')

Vor der Bewegung der Turtle solltest du die Turtle immer anheben und am Ort des Abdrucks wieder absetzen:

turtle_stamp.penup()
turtle_stamp.pendown()

Die Bewegung erfolgt mit forward().

# data[].attributes.headline
Einen Abdruck an mehreren Positionen erstellen

# data[].attributes.subject
Einen Abdruck an mehreren Positionen erstellen

# data[].attributes.body
Du sollst einen Abdruck der Turtle an mehreren Positionen erstellen. Dazu muss du immer die Abfolge:

Stift anheben
Richtungsänderung
Vorwärtsgehen
Abdruck

wiederholen. Probiere es aus!

# data[].attributes.body
Mit einem Zufallsgenerator kannst du den Abdruck in unterschiedlichen Farben erzeugen. Dazu legst du ein Array mit den Farben an:

colours=["blue","yellow","green","cyan","lightblue","red","orange"]

Achte auf die eckigen Klammern! Dann erzeugst du die Farbe der Turtle mit:

turtle_stamp.color(random.choice(colours))

Die Anweisung random.choice(colours) wählt aus dem Array eine Farbe aus.

Du kannst die vier Abdrücke in einer Wiederholungsschleife organisieren.

for i in range(1,5):

Doppelpunkt nicht vergessen!

# data[].attributes.body
Erweitere das Programm für das Zeichnen des Quadrats mit den Befehlen für das ausfüllen.

import turtle
#erzeugen der Instanz pen
pen = turtle.Turtle()
#Screen
turtle.setup(500, 500)
turtle.Screen().bgcolor("lightblue")
turtle.Screen().colormode(255)
#Farbe und Größe
pen.color("green")
pen.pensize(5)
#Quadrat zeichnen mit Wiederholungsschleife und ausfüllen
pen.fillcolor("green")
pen.begin_fill()
for i in range(1, 5):
pen.forward(100)
pen.left(90)
pen.end_fill()
pen.hideturtle()

# data[].attributes.body
Erweitere das Programm so, dass du mehrere farbige Quadrate auf dem Screen an unterschiedlichen Positionen zeichnest. Du wählst die Positionen mit dem Befehl

pen.goto(x,y)

an. x und y sind die Koordinaten in deinem Screen. Wenn du den pen bewegst musst du vor dem goto den pen mit

pen.up()

hochnehmen und nach goto mit

pen.down()

absetzen.

Du kannst die Positionen in einer Schleife durch addieren verändern:

for i in range(1,5):
goto(100 +i * 50)

Du musst die Zahlen für deinen Screen ausprobieren.

# data[].attributes.body
import turtle

import random

#erzeugen der Instanz pen

pen = turtle.Turtle()

#Screen

turtle.setup(500, 500)

turtle.Screen().bgcolor("lightblue")

turtle.Screen().colormode(255)

#Farbe und Größe

colours=["blue","orange","red","green","pink","grey"]

#pen.color(random.choice(colours))

pen.pensize(5)

#Quadrat zeichnen mit Wiederholungsschleife und ausfüllen

#pen.fillcolor(random.choice(colours))

#unterschiedliche positinen

for j in range(1,6):

pen.up()

pen.goto(-200+j*50, -200+j*50)

pen.down()

pen.color(random.choice(colours))

pen.fillcolor(random.choice(colours))

pen.begin_fill()

for i in range(1, 5):

pen.forward(100)

pen.left(90)

pen.end_fill()

pen.hideturtle()

turtle.done()

# data[].attributes.body
Um die Abdrücke der Turtle in Form einer Spirale anzuordnen benutzen wir eine Technik, die wir schon von Scratch kennen:

1. bei jedem Schritt vergrößern wir die Länge. Hierzu definiert
ihr eine Variable für die Änderung der Länge, z.B. delta.
Delta wird bei jedem Schritt erhöht, delta +=3. Du musst
ausprobieren, welche Erhöhung sinnvoll ist. Der Befehl für
den Vorwärtsschritt lautet: stamp.forward(delta)
2. Bei jedem Schritt wird der Stamp ein wenig gedreht, z.B.
25°.

# data[].attributes.body
In diesem Projekt programmieren wir einen Nachthimmel, an dem Sterne durch einen Zufallsgenerator erscheinen. Wir programmieren eine Horizontlinie.

# data[].attributes.body
Wir benötigen die Module turtle und random:

import turtle
import random

Wir definieren den 1 byte Farbmodus:

turtle.colormode(255)

Das Ausgabefenster mit der Hintergrundfarbe:

turtle.Screen().setup(1000, 1000)
turtle.Screen().bgcolor(35, 58, 119)

# data[].attributes.body
Für den Horizont definierst du die Variable divider_pen. Es soll eine Linie gezeichnet werden, die den Horizont darstellt. divider_pen wird als Kopie von Turtle erstellt und hat alle Turtle Eigenschaften.

divider_pen = turtle.Turtle()

Die Dicke und die Farbe wird gesetzt:

divider_pen.color(255, 212, 31)
divider_pen.pensize(10)

Zeichnen des Horitontes:

divider_pen.back(500)
divider_pen.forward(1000)

Verstecken des pens:

divider_pen.ht()

# data[].attributes.body
Definition des pen:

pen = turtle.Turtle()

Startpunkt des pen:

pen.penup()
pen.ht()
pen.goto(-200, 300)
pen.color(255, 215, 0)
pen.pensize(5)

# data[].attributes.body
Die Schildkröte wird definiert durch:

tooga = turtle.Turtle()

Die Form und die Farbe werden durch:

tooga.shape('turtle')
tooga.color(9, 185, 13)
tooga.pencolor(0, 120, 0)
tooga.turtlesize(3, 3, 3)

# data[].attributes.body
Nachdem alle Definitionen gemacht worden sind wird jetzt das Programm geschrieben, mit dem zufällig gewählt wird, ob der Himmel klar oder bewölkt ist und je nach Bewölkung Sterne sichtbar werden. Dieser Vorgang wird in einer Schleife programmiert.

tooga_penup()
tooga.goto(0, -100)

Daran schließt sich der Stern und die Auswahl der Bewölkung an.

# data[].attributes.body
Erstelle ein Programm, mit dem du Wörteraus einer Liste raten kannst (z.B. Hangmann). Die Wörter, die geraten werden sollen, werden in einer Liste notiert :

word = ["Geheimnis", "Himmel" ...]

Die Liste soll mindestens 10 Einträge umfassen.

Die Auswahl aus der Liste soll über

random.choice(word)

erfolgen. Zu Beginn des Programms musst du

import random
import time

für den Zufallsgenerator und die Zeit laden. Wir benötigen:

time.sleep()

Zwischen den Klammern wird die Wartezeit eingetragen.

# data[].attributes.body
Wenn die maximale Anzahl von Versuchen erreicht ist, kannst du das gesuchte Wort über den Befehl:

print("Das Wort war:", word)

ausgeben.

# data[].attributes.body
Dieses ist die Initialisierung des Programms im oberen Drittel.

# data[].attributes.body
Dieses ist die Wörterliste. Erweitere diese, so dass du ca. 10 Wörter zu raten hast.

# data[].attributes.body
Dieses ist der eigentliche Abschnitt, der das Wörterraten organisiert.

# data[].attributes.body
Mit Python soll ein Satzbot erstellt werden, der im ersten Schritt einfache Sätze automatisch erstellt. Die einfachen Sätze sollen aus den Elementen:

Substantiv

Verb

Objekt

bestehen. Zusätzlich kommt in der ersten Stufe noch ein Adjektiv vor dem Objekt hinzu.

Zum Programmieren definieren wir Namen, aus denen wir entnehmen können, um, welches Element es sich handelt:

part1 = Substantiv

part2 = Verb

part3 = Adjektiv

part4 = Objekt

part1, part2, part3, part4 sind Listen, die die Wörter enthalten.

Alle Wörter sind eine Liste, die aus den Listen der einzelnen Satzelemente besteht. Die Auswahl der Wörter wird über einen Zufallsgenerator erstellt.

Lange Rede kurzer Sinn. Ausprobieren!!!

Kommentare nicht vergessen !!!!

# data[].attributes.body
Du importierst das Modul random:

import random

# data[].attributes.body
Die Wörter in den einzelnen Satzelementen werden als Listen definiert:

part1 = ["Das Haus", "Die Sonne, "Der Mantel"]     (Subjekt)
part2 = ["ist", "hat", "geht"]                                      (Verb)
part3 = ["gelbes", "hohes", "heißes"]                      (Adjektiv)
part4 = ["Dach", "Stadt", "Blume"]                           (Objekt)

Die Wörter sind Beispiele. Je mehr Wörter in den Listen enthalten sind, desto interessanter werden die Sätze. Das Gute daran ist, dass du die Listen nur einmal definieren musst und dann jede Menge Sätze produzieren kannst.

Je mehr Wörter, desto mehr Kombinationen.

# data[].attributes.headline
Satzgenerator - Listen und Zufallsgenerator

# data[].attributes.subject
Satzgenerator - Listen und Zufallsgenerator

# data[].attributes.body
Du erstellst eine Liste mit den Wörtern aller Listen:

best_words = [part1, part2, part3, part4]

Dann erstellst du den Satz:

sentence = []

Der Satz ist zunächst eine leere Liste, die in einer for-Schleife ausgefüllt wird. Die for-Schleife läuft über alle Einzellisten:

for part in best_words:
r = random.randint(0, len(part)-1)
sentence.append(part[r])

Nach der for-Schleife wird der gesamte Satz ausgegeben:
print("    ".join(sentence))

Nachdem du die Grundstruktur erstellt und getestet hast, kannst du die einzelnen Elemente verändern, Wörter hinzufügen und das Programm ausprobieren.

# data[].attributes.body
Mit dem Modul Turtle wird eine Turtle Race programmiert. Die einzelnen Turtles werden über einen Zufallsgenerator bewegt, so dass das Ergebnis des "Rennens" vom Zufall abhängt. In der Grundversion habe 6 Turtles an der Startlinie platz. Die Startlinie und die Anzahl der Turtles soll erweitert werden, so dass dort 15 Turtles das Rennen aufnehmen können, alle Turtles sollen unterschiedliche Farben haben. Die Größe der Turtles ist die von Python vorgegebene Größe (Default Wert).

# data[].attributes.body
Es gibt mehrere Möglichkeiten ein Modul in Python zu importieren. Wir haben bislang das Modul mit dem Befehl:

import modul

importiert. Um einen Befehl auszuführen, muss immer das Modul mit dem Namen des Befehls im Modul angesprochen werden, z.B.

modul.modulname()
turtle.forward()

Das hat den Vorteil, dass man immer weiß, auf welches Modul sich der jeweilige Befehl bezieht.

Bei der zweiten Möglichkeit

from modul import *

werden alle Befehle importiert und können direkt angesprochen werden ohne den Namen des Moduls zu nennen, z.B.

forward()

Ohne turtle vorangestellt. Das hat den Vorteil, dass weiniger Code geschrieben werden muss und den Nachteil, dass nicht klar ist, aus welchem Modul der Befehl stammt.

Die dritte Möglichkeit ist, nur bestimmte Befehle zu importieren, die dann direkt angesprochen werden können:

from modul import modulname

Wir importieren alle Befehle aus dem Modul turtle mit:

from turtle import *

und aus dem Modul random nur die Funktion randint mit:

from random import randint

# data[].attributes.body
Im zweiten Schritt werden jetzt der Bildschirm und einige Variablen definiert.

setup(1000, 1000)
Screen().bgcolor("lightblue")

Der Name des Moduls turtle entfällt, da wir '*' alle Befehle importiert haben.

Die Variablen werden initialisiert und der Startpunkt wird mit goto festgelegt:

speed()               # Initialisierung von speed
penup()               # Initialisierung von penup

goto(-240, 140)  #Startpunkt

# data[].attributes.body
Im nächsten Schritt wird die Darstellung der Rennstrecke programmiert. Die Rennstrecke wird dargestellt durch gestrichelte Linien im Abstand von 20. Wir zeichnen zunächst 10 Striche senkrecht. Die senkrechten Striche sind in der Schleife mit dem Zähler num. Die gestrichelte Darstellung wird durch penup und pendown erreicht.
Wir zeichnen in der Rennstrecke zunächst 35 senkrechte Linien. Jede Linie wird mit der entsprechenden Zahl markiert.
Die senkrechten Linien sind ausreichend für sechs Turtles, die am Rennen teilnehmen. Sie muss bei einer größeren Anzahl entsprechend verlängert werden.

# data[].attributes.body
Die einzelnen Turtles, die am Rennen teilnehmen werden mit Namen als Variable definiert. Hier wird die Form, die Farbe und der Startpunkt an der Startlinie festgelegt. Dieser Startpunkt wird bei jedem weiteren Teilnehmer um 30 nach unten verschoben.

# data[].attributes.body
Die Bewegung wird mit dem Zähler turn in einer for-Schleife mit 220 Schritten programmiert. Die Bewegung jeder Turtle wird mit einer zufälligen Zahl zwischen 1 und 5 gesteuert. Dadurch ergeben sich die unterschiedlichen Geschwindigkeiten.

# data[].attributes.body
Für die Definition einer Turtle muss ein Name gewählt werden, z.B. herbert = Turtle(). Dann erhält herbert die Eigenschaften, z.B.
herbert.shape('turtle') u.s.w..
Die Grundfarben können jeweils mit einem light... oder dark... versehen werden, z.B. lightgreen oder darkred.

# data[].attributes.body
Kontrollstrukturen sind eine Art Schalter, die das Programm zu Anweisungen weiterleiten, wenn bestimmten Bedingungen erfüllt sind.

Wir werden diese Kontrollstrukturen anhand von Zahlenoperationen kennenlernen.

# data[].attributes.body
Der Turtle-Coder (https://www.code-your-life.org/Praxis/Logo_Turtle/1349_Der_TurtleCoder.htm) wurde vom MIT (Massachusetts Institute of Technology, mit.edu) entwickelt. Kinder sollen mit dieser Programmierumgebung an des Programmieren mit der professionellen Programmierumgebung Python herangeführt werden. Der TurtleCoder wird unter anderem von Microsoft auf der Seite www.code-your-life.org als online-tool und zum Download angeboten.