Erste Schritte mit Python by Jens-Thomas Meyer

Python

jtmeyer — 2022-03-15 09:47:44 UTC

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.

Python

jtmeyer — 2022-03-15 09:48:03 UTC

Python kann von der offiziellen Python Website heruntergeladen werden.

Visual Studio Code

jtmeyer — 2022-03-15 09:52:26 UTC

Mit Visual Studio Code können Programme in unterschiedlichen Programmiersprachen (JavaScript, Python, HTML etc.) geschrieben werden.

Was ist das?

jtmeyer — 2022-03-15 10:22:59 UTC

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 nichts weiter. Das Modul ist geladen und die Befehle können jetzt benutzt werden.

Python 3.10 starten.

jtmeyer — 2022-03-15 10:41:11 UTC

So startest du Python 3.10:

Gehe zum Windows Zeichen ganz links unten.
Klicke auf .
Scrolle herunter bis du Python 3.10 findest.
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 +s drücken.

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

Die Turtle anzeigen

jtmeyer — 2022-03-15 10:54:40 UTC

Du kannst die Turtle mit dem Befehl

turtle.shape('turtle')

anzeigen.

Output Fenstergröße

jtmeyer — 2022-03-15 11:06:57 UTC

Die Größe des Output Fensters kannst du über den Befehl

turtle.setup(500, 500)

definieren. Probiere verschiedene Größen aus.

Farbe des Fensters

jtmeyer — 2022-03-15 11:15:19 UTC

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.

Ein kleines Programm

jtmeyer — 2022-03-15 11:33:54 UTC

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.

Turtle Farbe und Größe

jtmeyer — 2022-03-15 17:39:28 UTC

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.

Zweites Programm

jtmeyer — 2022-03-15 17:54:04 UTC

Befehle zur Bewegung

jtmeyer — 2022-03-16 17:17:24 UTC

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.

Aussehen der Turtle

jtmeyer — 2022-03-16 17:20:59 UTC

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.

Bewegung der Turtle

jtmeyer — 2022-03-16 17:30:53 UTC

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)

Wiederholungsschleife

jtmeyer — 2022-03-16 17:54:57 UTC

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)

Ein neues Modul erstellen

jtmeyer — 2022-03-17 17:00:19 UTC

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!

Quadrat

jtmeyer — 2022-03-17 17:07:58 UTC

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.

Quadrat mit Wiederholungsschleife

jtmeyer — 2022-03-17 17:13:50 UTC

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,

Das Quadrat Programm

jtmeyer — 2022-03-17 17:38:47 UTC

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()

Der Befehl fillcolor

jtmeyer — 2022-03-19 10:31:02 UTC

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.

Einen Kreis ausfüllen

jtmeyer — 2022-03-19 10:47:16 UTC

Um einen Kreis auszufüllen kannst du folgendes eingeben:

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

Das Quadrat ausfüllen

jtmeyer — 2022-03-19 10:56:38 UTC

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()

circle(radius, extent)

jtmeyer — 2022-03-19 11:57:23 UTC

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°.

Spirale

jtmeyer — 2022-03-20 10:35:04 UTC

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.

Trichter

jtmeyer — 2022-03-20 10:54:41 UTC

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)

stamp()

jtmeyer — 2022-03-20 11:24:58 UTC

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().

Einen Abdruck an mehreren Positionen erstellen

jtmeyer — 2022-03-20 11:43:53 UTC

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!

Vier Abdrücke

jtmeyer — 2022-03-20 11:45:22 UTC

Turtle in unterschiedlichen Farben

jtmeyer — 2022-03-20 16:12:49 UTC

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!

Viele Quadrate

jtmeyer — 2022-03-23 17:42:45 UTC

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.

Quadrate

jtmeyer — 2022-03-23 17:43:44 UTC

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()

Spirale mit Abdrücken

jtmeyer — 2022-04-24 15:47:27 UTC

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°.

Vorbereitung für das Programm

jtmeyer — 2022-04-24 15:54:52 UTC

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()

jtmeyer — 2022-04-24 15:55:37 UTC

jtmeyer — 2022-04-24 15:56:01 UTC

Nachthimmel mit Sternen

jtmeyer — 2022-05-01 14:07:58 UTC

In diesem Projekt programmieren wir einen Nachthimmel, an dem Sterne durch einen Zufallsgenerator erscheinen. Wir programmieren eine Horizontlinie.

Vorbereitung des Programms

jtmeyer — 2022-05-01 14:14:50 UTC

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)

Horizont

jtmeyer — 2022-05-01 15:30:02 UTC

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()

Pen

jtmeyer — 2022-05-01 15:35:28 UTC

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)

Form

jtmeyer — 2022-05-01 15:45:24 UTC

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)

Sterne erzeugen

jtmeyer — 2022-05-01 15:52:07 UTC

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.

Ergebnis Toogas Reise

jtmeyer — 2022-05-01 15:58:50 UTC

Toogas Reise Programm

jtmeyer — 2022-05-01 16:02:32 UTC

Wörter raten programmieren

jtmeyer — 2022-05-08 13:10:51 UTC

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.

Code Schnipsel Teil 1

jtmeyer — 2022-05-08 13:25:14 UTC

Dieses ist die Initialisierung des Programms im oberen Drittel.

Code Schnipsel Teil 2

jtmeyer — 2022-05-08 13:30:23 UTC

Dieses ist die Wörterliste. Erweitere diese, so dass du ca. 10 Wörter zu raten hast.

Code Schnipsel Teil 3

jtmeyer — 2022-05-08 13:34:21 UTC

Dieses ist der eigentliche Abschnitt, der das Wörterraten organisiert.

Gesuchtes Wort ausgeben

jtmeyer — 2022-05-09 07:59:14 UTC

Wenn die maximale Anzahl von Versuchen erreicht ist, kannst du das gesuchte Wort über den Befehl:

print("Das Wort war:", word)

ausgeben.

Einen Satzgenerator erstellen

jtmeyer — 2022-05-16 09:51:16 UTC

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 !!!!

Satzgenerator - Teil 1

jtmeyer — 2022-05-16 09:56:39 UTC

Du importierst das Modul random:

import random

Satzteile - Definition der Elemente

jtmeyer — 2022-05-16 10:16:33 UTC

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.

Satzgenerator - Listen und Zufallsgenerator

jtmeyer — 2022-05-16 10:52:06 UTC

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.

jtmeyer — 2022-05-16 11:44:08 UTC

Programmierung der Turtle-Race

jtmeyer — 2022-06-06 09:03:27 UTC

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).

jtmeyer — 2022-06-06 09:04:37 UTC

Schritt 1 : Modul importieren

jtmeyer — 2022-06-06 09:36:49 UTC

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

Schritt 2: Bildschirm und Variablen

jtmeyer — 2022-06-06 11:53:54 UTC

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

Schritt 3 : Rennstrecke

jtmeyer — 2022-06-06 15:25:15 UTC

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.

Schritt 4 : Definition der Turtles

jtmeyer — 2022-06-06 15:33:57 UTC

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.

Schritt 5 :

jtmeyer — 2022-06-06 15:46:07 UTC

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.

Namen und Farben

jtmeyer — 2022-06-06 15:57:36 UTC

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.

Verzweigungen if, else und elif

jtmeyer — 2023-02-05 15:40:48 UTC

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.

Turtle-Coder

jtmeyer — 2023-03-03 07:24:17 UTC

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.