# 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
Scratch ist eine grafische Programmiersprache, die vom Massachusetts Institute of Technology entwickelt wurde. Die Version 3 kann online oder per Download benutzt werden.

# data[].attributes.attachment_link.description
Scratch is a free programming language and online community where you can create your own interactive stories, games, and animations.

# data[].attributes.body
In der Aufgabe a) wird ein einfaches Quadrat gezeichnet.

# data[].attributes.headline
Erklärvideo zum Zeichnen von Figuren mit Scratch

# data[].attributes.subject
Erklärvideo zum Zeichnen von Figuren mit Scratch

# data[].attributes.body
Öffne den Python 10 Editor (alle Programme -> Python 10 -> idle) und wähle unter File -Y New File.

# data[].attributes.body
Zum Zeichnen der Figuren benutzen wir in Python das Modul turtle. Der erste Befehl lautet:

import turtle

Nun ist das Modul geladen. Um einen geraden Strich zu zeichnen, gibst du den Befehl

turtle.forward(100)

ein. Jetzt unbedingt speichern und dann auf Run-> Run Module gehen. Für eine Drehung nach rechts gibst du

turtle.right(90)

ein, gefolgt von:

turtle.forward(100)

Das Ergebnis sollte so aussehen wie das Bild oben.

# data[].attributes.body
Hintergrundfarbe: turtle.bgcolor("black")
Stiftfarbe:               turtle.color("yellow")
Stftbreite:               turtle.width(5)
Geschwindigkeit:   turtle.speed(3)
Anfangspunkt:        turtle.goto(100, 100)
Stift anheben:         turtle.up()
Stift absenken: turtle.down()

# data[].attributes.body
Für 5 Wiederholungen lautet der Befehl:

for i in range(1,6):
turtle.forward(100)

Wichtig: Den Doppelpunkt nicht vergessen! Dann werden die nachfolgenden Befehle eingerückt.

# data[].attributes.body
Erstelle ein Programm für ein Spiel, in dem eine geheime zufällige Zahl geraten werden soll. In dem Programm soll die Anzahl der Versuche begrenzt sein (z.B. 7). Der Zahlenbereich soll größer als 100 sein. Das Programm soll Hinweise für die Spielerin oder den Spieler geben, ob die Benutzereingabe größer oder kleiner als die Ratezahl ist.

# data[].attributes.body
Schreibe ein Programm für das Zahlen raten in Python. Schreibe das Programm mit dem Idle Editor von Python 10 bzw. in Visual Code Studio.

# data[].attributes.body
durchgang
aktiv
ratezahl
bentzereingabe

# data[].attributes.body
import random

ratezahl = random.randint(0, 128)

(Der Zahlenbereich kann verändert werden)

# data[].attributes.body
while aktiv == True   (führt die Schleife aus bis aktiv=False wird)

if benutzereingabe == ratezahl :
(vergleicht die benutzereingabe mit der ratezahl)

elif  benutzereingabe > ratezahl :
(ist eine Verzweigung unter der if-Anweisung)

else :
(ist die Verzweigung, wenn die vorherige Bedingung nicht erfüllt ist

Das Programm soll auch stoppen, wenn die maximale Anzahl der Versuche erreicht worden ist..

# data[].attributes.attachment_link.readable_text
Dieses Python Tutorial entsteht im Rahmen von Uni-Kursen und kann hier kostenlos genutzt werden. Python ist eine für Anfänger und Einsteiger sehr gut geeignete Programmiersprache, die später auch den Fortgeschrittenen und Profis alles bietet, was man sich beim Programmieren wünscht. Der Kurs ist eine Einführung und bietet einen guten Einstieg. Es wird aktuelles Wissen vermittelt - daher schreiben wir unseren Python-Code mit der aktuellen Python-Version 3.

einfach Python lernen über das Programmieren von Spielen

Damit programmieren lernen mit Python noch mehr Spaß macht, werden wir im Kurs anhand verschiedener Spiele die Anwendung von Python kennen lernen und unser Wissen als Programmierer aufbauen. Die Grundlagen werden direkt in bekannte Spiele umgesetzt wie:

Galgenmännchen

Lotto-Simulator

einen Chatbot

Tic-Tac-Toe Spiel

Pong (damit noch mehr Bewegung ins Spiel kommt)

Breakout

Bee Invaders (cooler Space Invaders Clone mit Honig)

und vieles mehr

Dazu werden im Kurs Schritt für Schritt die Vorgehensweise beim Lernen von Programmieren gezeigt. Es wird anhand von Beispiel-Code alle Befehle erklärt, wie man mit diesem Wissen Programme schreibt. Beispielsweise wie aus einem Sprite-Sheet mit den einzelnen Bewegungsstadien eine animierte Spielerfigur wird - in diesem Fall eine Honigbiene.

Und das fertige Ergebnis (sieht dann umgesetzt in Python + Pygame noch besser aus):

Biene mit animierter Bewegung im Flug

Python ist Zukunftsorientiert

Python hat sich zu einer sehr beliebten Programmiersprache entwickelt. In immer weiteren Softwareprogrammen und Hardware kann man Python einsetzen - was Python noch interessanter macht. Im Kurs gibt es auch einen Abstecher zum Einplatinencomputer Raspberry Pi (Pi steht für Python-Interpreter).

Das Programmieren in Python kann in folgenden Formen gemacht werden:

Funktionale Programmierung

Objektorientierte Programmierung (OOP)

wie auch Aspektorientierte Programmierung (AOP)

Python ist eine gute Programmiersprache auch für Einsteiger, die bisher noch nicht mit Programmieren und Programmiersprachen in Berührung gekommen sind.

Bei Python spricht man von einer Skriptsprache - ein erstelltes Programm wird interpretiert, wenn es gestartet wird. Daher bekommt man erst dann Fehlermeldungen, wenn Fehler im Python-Programm sind. Dazu aber später mehr. Die Sprache ist sehr einfach zu lernen und durch die (erzwungene) saubere Erstellung von Code punktet die Sprache: Sie ist gut lesbar und hat einen übersichtlichen kurzen Code. Daher ist Python sehr einfach zu lernen und ideal als Einführung in eine Programmiersprache.

Viel Spaß in diesem Python Kurs.

# data[].attributes.attachment_link.title
Python lernen - Python Kurs für Anfänger und Fortgeschrittene

# data[].attributes.attachment_link.description
Dieses Python Tutorial entsteht im Rahmen von Uni-Kursen und kann hier kostenlos genutzt werden. Python ist eine für Anfänger und Einsteiger sehr gut geeignete Programmiersprache, die später auch den Fortgeschrittenen und Profis alles bietet, was man sich beim Programmieren wünscht. Der Kurs ist eine Einführung und bietet einen guten Einstieg.

# data[].attributes.body
Mit dem Programm Scratch soll ein Umrechner für Celsius in Kelvin erstellt werden. Die Formel lautet:
Kelvin = 273,15 + Celsius
Der Benutzer soll die Zahl in Grad Celsius eingeben und dann das Ergebnis in Grad Kelvin erhalten.

# data[].attributes.body
Schreibe ein Programm für die Umrechnung von Celsius in Python. Benutze für die Eingabemaske das Modul tkinter.

# data[].attributes.body
Das Modul tkinter stellt eine grafische Benutzeroberfläche für die Ein- und Ausgabe zur Verfügung. Der Fachbegriff lautet "graphical user interface" oder GUI. Das Modul wird durch:
import tkinter as tk
(hier wird gleich das Kurzwort "tk" für tkinter aktiviert.

# data[].attributes.body
tkinter bietet Steuererlemente für:

Textlabels

Textboxen

Inputboxen

Schaltflächen (Buttons)

Radiobuttons

Checkbottons

Menüs

# data[].attributes.body
Nach dem Import müssen wir unser Fenster initialisieren. Dazu wird ein Konstruktor aufgerufen, der in die Variable root den Bildschirm setzt:

import tkinter as tk
root = tk.Tk()
root.mainloop()

root.mainloop() wird an das Ende des Programms gesetzt.

# data[].attributes.body
Eine einfache Ausgabe kannst du mit dem Label-Widget realisieren:

import tkinter as tk
root = tk.Tk()
# Textausgabe erzeugen
label1 = tk.Label(root, text="Hallo Welt")
# in GUI Elemente einbetten
label1.pack()
root.mainloop()

# data[].attributes.body
Im Label-Widget können die Farben über die Befehle "bg" für den Hintergrund (bg("orange")) und für den Vordergrund fg eingegeben werden.

# data[].attributes.body
Zum Ausführen einer Aktion führen wir eine Schaltfläche (Button Widget) ein, die Aktion wird über das def Kommando definiert.

# data[].attributes.body
Unter Fühlen findest du den Befehl "frage". In der "antwort" wird der Eingabewert gespeichert.
Die Rechenoperationen findest du unter "Operationen".
Die Ausgabe erfolgt über das Modul "sage" unter Aussehen.

# data[].attributes.body
Die GUI wird mit tkinter erstellt.

import tkinter as tk
root = tk.Tk()

# data[].attributes.body
Mit den Methoden grid() und pack() können Elemente in der GUI platziert werden. Die Methode grid() bietet über die Zeile und die Spalte zusätzliche Möglichkeiten.

# data[].attributes.body
Es sollen unterschiedliche Textelemente in der GUI positioniert werden. Dafür soll die Methode grid() verwendet werden.

# data[].attributes.body
Die Methode grid() kannst du durch:

label.grid(row="zeilennummer",column="spaltennummer")

aufrufen.

# data[].attributes.body
Die Zuweisung des Textes erfolgt über:

label1 = tk.Label(root, text="deintext", bg="deinetextfarbe")

Du kannst den Namen für die Variable frei wählen.

# data[].attributes.body
Über das Attribut sticky= kann der Inhalt ausgerichtet werden. Mögliche Attribute sind die Himmelsrichtungen n, s, w, e, sw, se ... (e: east).

label.grid(row="deinezeile", column="deinespalte", sticky="e")

Der Text wird am Ostrand ausgerichtet. Die unterschiedlichen Postionen können einfach ausprobiert werden.

# data[].attributes.body
Versuche diesen einfachen Stern mit Scratch zu zeichnen.

Die Richtungsänderung ist jeweils 144 Grad.

# data[].attributes.body
Versuche einen Stern mit Python zu zeichnen.

Die Richtungsänderung ist 144 Grad.

# data[].attributes.body
Mit dem Turtle Modul soll ein Glücksratgeber programmiert werden. Per Zufall wird eine Antwort auf deine Frage ermittelt. Vier Antworten stehen zur Verfügung (z.B. "Ja, Vielleicht, Auf gar keinen Fall, Ja, aber in 50 Jahren).

# data[].attributes.body
import turtle

import random

Wir erzeugen einen Pointer durch Vererben der Eigenschaften des Turtle Moduls. Dadurch verwendet der Pointer die gleichen Befehle wie das Turtle Modul.

pointer = turtle.Turtle()

pointer.turtlesize(3, 3, 2)

Mit dem Befehl turtlesize bestimmen wir die Größe des Pointers.

# data[].attributes.headline
Vererben der Turtle Eigenschaften auf das Modul pen.

# data[].attributes.subject
Vererben der Turtle Eigenschaften auf das Modul pen.

# data[].attributes.body
Wir generieren nun ein pen und vererben ebenfalls die Turtle Eigenschaften.

pen = turtle.Turtle()

Jetzt können wir alle Turtle Befehle auch für den pen benutzen:

pen.up()
pen.down()
pen.goto(x,y)
pen.write("dein text", font=('dein font', Schriftgröße)

# data[].attributes.body
Die Richtung des Pointers wird über eine Zufallszahl eingestellt:

spin_amount = random.randint(1 ,360)

Der Pointer wird durch:

pointer.left(spin_amount)

ausgerichtet.

# data[].attributes.body
Mit Scratch lässt sich der Glückratgeber sehr einfach programmieren. Du benötigst dich den Zufallsgenerator aus dem Bereich Operatoren. Die Drehung der Figur (Pfeil) wird über den Befehl "drehe dich 🤬 Grad" erreicht. Der Text wird auf dem Bühnenbild dargestellt. So können einfach unterschiedliche Generatoren hergestellt werden.

# data[].attributes.body
Die Drehung des Pfeils wird etwas interessanter, wenn sich dieser in einer Wiederholungsschleife dreht, z.B. "wiederhole 10 mal".

# 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
In dem Spiel Master-Mind oder Superhirn geht es darum eine Kombination aus Farben und Positionen zu raten.
Sechs Farben werden an vier Positionen versteckt angeordnet. Es gibt 1296 unterschiedliche Kombinationen. Dabei können Farben mehrfach vorkommen.
Der Spieler erhält nach jedem Zug eine Rückmeldung, aus der er ersehen kann, ob die Farbe (o) oder Farbe und Position (+) richtig sind. Die Rückmeldung (o+) bedeutet, dass  eine Position die richtige Farbe und eine Position die richtige Farbe und die richtige Position aufweist. Der Spieler weiß allerdings nicht, um welche  Farben  und Positionen es sich handelt.

# data[].attributes.body
Wir programmieren das Spiel mit Python. Anstelle von Farben benutzen wir im ersten Schritt die Zahlen von 1 bis 6 und wählen 4 Positionen, so dass wir 1296 Kombinationen haben.

Mit dem Modul itertools können wir alle Kombinationen aus Zahl und Position ermitteln. Dazu verwenden wir die enthaltene Funktion product:

from itertools import product

Weiterhin benötigen wir den random Generator:

import random as rnd

# data[].attributes.body
Alle vierer Kombination aus Zahl und Position werden mit dem Befehl:

geheim = list(product(range(1,7), repeat=4)

erzeugt. Wir wählen dann eine Kombination mit dem Befehl:

geheim = rnd.choice(geheim)

aus dieser Liste aus und können diese mit

print(geheim)

ausgeben. Wenn du das Programm jetzt wiederholt startest, kannst du sehen, dass sich die Kombination verändert.

Während des Spiels sollte dieser Befehl mit # auskommentiert werden.

# data[].attributes.body
Du gibst jetzt deine Kombination ein und speicherst diese in der Variablen Versuch:

versuch = input('dein Versuch: ')

Mit diesem Befehl erhälts du jetzt als Ergebnis einen String mit Zahlen und keine Liste. Du musst diesen String mit dem Befehl .split() aufspalten. Dann erhältst du eine Liste mit String Elementen. Diese Elemente musst du jetzt in Integer umwandeln, mit dem Befehl map kannst dieses für alle Elemente erledigen und hinterher die Liste ausgeben:

versuch = list(map(int, input('dein Versuch: ').split()))

Jetzt kannst du deinen Versuch als Liste ausgeben:

print(versuch)

# data[].attributes.body
Zur Auswertung müssen wir die beiden Listen versuch und geheim miteinander vergleichen. Dabei müssen wir ermitteln, ob Elemente in beiden Listen vorhanden sind und, ob es Übereinstimmungen bei den Positionen gibt. Dazu definieren wir eine Funktion:

def treffer(v,g):

In diese Funktion werden unsere beiden Listen versuch und geheim übergeben.

Um herauszufinden, ob Position und Farbe identisch sind werden beide Listen über den Befehl zip(v,g) wie ein Reißverschluss zusammengefügt und geprüft, ob an den Stellen der Liste beide übereinstimmen. Der Befehl lautet:

farbe_position = sum(a == b for a,b in zip(v,g)

Bei Übereinstimmung ist der Rückgabewert True also 1. Diese Rückgabewerte werden dann summiert.

Die Überprüfung der Farbübereinstimmung ist etwas komplizierter. Mit dem Befehl:

farbe = sum(min(v.count(a), g.count(a)) for a in set(g)

wird die Anzahl der übereinstimmenden Farben zwischen beiden Listen ermittelt. Davon wird jetzt noch die Anzahl der richtigen Positionen abgezogen:

farbe = farbe - farbe_position

Der Befehl set(g) entfernt aus der Liste g alle doppelten Farben. Der Rückgabewert ist die Menge der gleichen Farben(geschweifte Klammern). Mit dem ersten Teil wird die Häufigkeit des Vorkommens einer Farbe in den Listen v und g über count ermittelt.

Der Rückgabewert der Funktion ist dann:

return '+'*farbe_position + 'o'*farbe

Die richtige Farbe und Position wird mit '+' multipliziert, die richtige Farbe mit 'o'. Wir erhalten dann einen String.

# data[].attributes.body
Im letzten Schritt wird die Auswertung abgeschlossen und das Ergebnis angezeigt. Die Anzahl der Versuche wird definiert durch:

anz = 0

Die Anzahl wird bei jedem Versuch hochgezählt. Sie könnte durch eine weitere while Schleife begrenzt werden.

Die erste while Schleife wird so lange durchlaufen bis das Ergebnis '++++' (alle Farben an der richtigen Position) erreicht wird:

while erg != '++++' :

Die Anzahl der Versuche wird um 1 erhöht und der Versuch wird über das Terminal eingegeben:

anz +=1
versuch = list(map(int, input('Dein Versuch :').split()))

Erläuterung:

1. der Input Befehl gibt einen String zurück.

2. mit dem Befehl .split() wird dieser String in eine Liste von Strings umgewandelt.

3. diese wird mit int in Zahlen umgewandelt. map hat die Aufgabe die Umwandlung auf alle Elemente anzuwenden.

4. mit list() wird dann die Liste der Zahlen erzeugt, die dann mit der geheim Liste verglichen werden kann.

Das Ergebnis erhältst du durch den Aufruf der Funktion treffer:

erg = treffer(versuch, geheim)

Die Übergabewerte sind die beiden Listen. Dann wird das Ergebnis ausgegeben:

print(anz, "Versuch: ", erg)

Die while Schleife wird so lange durchlaufen bis alle Farben und Positionen gefunden wurden. Wenn diese beendet ist, wird die Anzahl der benötigten Versuche ausgegeben:

print(f'Lösung in {anz} Versuchen gefunden!')

Das "f" steht hier für die format Funktion.

# data[].attributes.body
Wir erstellen mit Python einen Chat Roboter, der dann auch in Internetseiten integriert werden kann. Dazu muss dieser jedoch in JavaScript konvertiert werden, weil die meisten Hoster Python nicht anbieten.
Zur Programmierung benutzen wir das Modul "dictionary", das eine assoziative Liste zur Verfügung stellt, d.h. wir können Antworten vorgeben, die sich auf bestimmte Wörter in der Frage beziehen. Dadurch wird der Chatbot etwas "intelligenter" und es macht mehr Spaß.

# data[].attributes.body
der Benutzer wird vom Chatbot begrüßt

es wird überprüft, ob die einzelnen Wörter in der Datenbasis vorkommen

wenn eine passende Antwort vorliegt, wird diese ausgegeben

ansonsten wird eine Zufallsantwort ausgegeben

# data[].attributes.body
Die Begrüßung erfolgt über eine Reihe von print("") Anweisungen, z.B.

print("Willkommen beim Chatbot")
print("Worüber möchtest du sprechen?")

Hier können beliebige Texte eingefügt werden.

# data[].attributes.body
Die Zufallsantworten werden in Form einer Liste erstellt und dann über den Befehl random.choice ausgewählt:

zufallsantworten = ["wer weiß" ... ]

random.choice(zufallsantworten)

Je länger die Liste der Zufallsantworten ist, desto interessanter wird die Unterhaltung.

# data[].attributes.body
Die Reaktionsantworten werden in Form eines "Dictionaries", ein spezieller Python Datentyp, eingegeben. Hier wird jedem Wort (key) eine Bedeutung zugeordnet. Menge wird mit geschweiften Klammern geschrieben. Die einzelnen Paare werden mit "," getrennt.

reaktionsantworten = {"hallo": "aber Hallo", ...}

Je mehr Antwortpaare hier notiert werden, desto interessanter wird die Unterhaltung mit dem Bot.

# data[].attributes.body
Die Nutzereingabe erfolgt über die input Anweisung:

nutzereingabe = input("Welche Frage hast du?")

Die nutzereingabe ist eine Liste, die mit dem Befehl split() in die einzelnen Wörter aufgeteilt wird und mit dem Befehl lower() komplett in Kleinbuchstaben umgewandelt wird:

nutzereingabe.split()
nutzereingabe.lower()

Dann muss verglichen werden, ob im Dictionary der Reaktionsantworten ein Wort aus der Nutzereingabe enthalten ist.

# data[].attributes.body
Die Abfrageschleife wird so lange durchlaufen, bis der Benutzer "bye" eingibt. Es wird überprüft, ob in der nutzereingabe ein Wort aus den reaktionsantworten enthalten ist. Wenn dieses nicht der Fall ist, wird eine Antwort aus den zufallsantworten ausgewählt.