🐍 Thema 5: Grundlagen der Programmierung

Überblick

In diesem Themenbereich geht es darum, wie Programme aufgebaut sind, wie Anweisungen formuliert werden und wie man mit Python einfache Probleme Schritt für Schritt lösen kann.

Programmieren bedeutet nicht nur, Code zu schreiben. Es bedeutet auch:

ein Problem genau zu verstehen,
eine Lösung logisch zu planen,
Anweisungen eindeutig zu formulieren,
Fehler systematisch zu suchen,
Programme verständlich zu strukturieren,
Code so zu schreiben, dass auch andere ihn nachvollziehen können.

Python eignet sich besonders gut zum Einstieg, weil die Sprache vergleichsweise gut lesbar ist und viele grundlegende Konzepte deutlich sichtbar macht.

Leitfrage

Wie lassen sich Probleme so in eindeutige Programmanweisungen übersetzen, dass ein Computer sie zuverlässig ausführen kann?

Was ist ein Programm?

Ein Programm ist eine Folge von Anweisungen, die ein Computer ausführt. Diese Anweisungen müssen eindeutig, vollständig und in einer bestimmten Syntax geschrieben sein.

Ein Mensch versteht oft auch ungenaue Anweisungen:

Zeichne ungefähr ein Muster mit mehreren Linien.

Ein Computer braucht dagegen präzisere Anweisungen:

python

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

Merke

Computer führen Anweisungen nicht „ungefähr“ aus. Sie arbeiten streng nach dem Programmcode.

Programmiersprachen

Eine Programmiersprache ist eine formale Sprache, mit der Menschen Anweisungen für Computer formulieren können.

Python wird häufig eingesetzt für:

kleine Programme und Skripte,
Datenverarbeitung,
Automatisierung,
Webentwicklung,
künstliche Intelligenz,
Unterricht und Einstieg ins Programmieren.

Wichtig

Python-Code muss syntaktisch korrekt sein. Schon kleine Fehler bei Doppelpunkten, Einrückungen oder Klammern können verhindern, dass ein Programm ausgeführt wird.

Zentrale Sprachkonstrukte in Python

Programme bestehen aus wiederkehrenden Grundbausteinen. Dazu gehören:

Variablen,
Datentypen,
Operatoren,
Bedingungen,
Schleifen,
Funktionen,
Bibliotheken.

Diese Bausteine lassen sich kombinieren, um komplexere Programme zu erstellen.

Variablen

Eine Variable ist ein benannter Speicherplatz für einen Wert.

python

name = "Mina"
alter = 17
punkte = 42

Die Variable name enthält den Text "Mina".
Die Variable alter enthält die Zahl 17.

Merke

Variablen speichern Werte, damit ein Programm später wieder darauf zugreifen kann.

Gute Variablennamen

Gute Variablennamen sagen aus, wofür ein Wert steht.

Weniger gut:

python

x = 17
y = 42

Besser:

python

alter = 17
punkte = 42

Merksatz

Code wird nicht nur für den Computer geschrieben, sondern auch für Menschen, die ihn lesen, verstehen oder später verändern müssen.

Datentypen

Python unterscheidet verschiedene Arten von Daten.

Datentyp	Bedeutung	Beispiel
`int`	ganze Zahl	`17`
`float`	Kommazahl	`3.14`
`str`	Zeichenkette / Text	`"Hallo"`
`bool`	Wahrheitswert	`True`, `False`

Beispiele:

python

alter = 17
preis = 4.50
name = "Mina"
bestanden = True

Wichtig

Der Datentyp beeinflusst, was man mit einem Wert machen kann. Mit Zahlen kann man rechnen. Texte werden anders verarbeitet.

Eingaben und Casting

Mit input() kann ein Programm eine Eingabe von Nutzer·innen einlesen.

python

alter = input("Wie alt bist du? ")

Wichtig: input() liefert immer einen Text zurück, also einen Wert vom Typ str.

Wenn man damit rechnen möchte, muss man den Wert umwandeln.

python

alter = int(input("Wie alt bist du? "))

Oder bei Kommazahlen:

python

preis = float(input("Preis eingeben: "))

Diese Umwandlung nennt man Casting.

Merke

Nutzereingaben sind in Python zunächst Text. Für Berechnungen müssen sie oft mit int() oder float() umgewandelt werden.

Konsolenausgabe mit fehlgeschlagenem Test ohne Casting und erfolgreichem Test nach Casting. — Abb.: Konsolentest zu `input()` und Casting. Im ersten Durchlauf scheitert der Vergleich, weil eine Texteingabe mit einer Zahl verglichen wird. Nach der Umwandlung mit `int()` läuft derselbe Test korrekt durch. Eigene Darstellung.

📝 Übung: Eingaben sinnvoll weiterverarbeiten

Du möchtest ein kleines Programm schreiben, das eine Bestellung im Schulbuffet berechnet. Die Nutzer·in gibt ein:

den Preis eines Getränks,
den Preis eines Snacks,
die Anzahl der Snacks.

Das Programm soll den Gesamtpreis berechnen und ausgeben. Achte darauf, dass die Eingaben mit passenden Datentypen weiterverarbeitet werden.

Lösungshinweis

python

getraenk = float(input("Preis des Getränks: "))
snack = float(input("Preis eines Snacks: "))
anzahl = int(input("Anzahl der Snacks: "))

gesamt = getraenk + snack * anzahl
print("Gesamtpreis:", gesamt, "Euro")

Wichtig ist hier die Unterscheidung zwischen float für Preise und int für die Anzahl. Ohne Casting wären die Eingaben Texte und könnten nicht sinnvoll als Rechnung verwendet werden.

Operatoren

Operatoren führen Operationen mit Werten aus.

Arithmetische Operatoren

Operator	Bedeutung	Beispiel
`+`	Addition	`3 + 2`
`-`	Subtraktion	`7 - 4`
`*`	Multiplikation	`5 * 3`
`/`	Division	`10 / 2`
`//`	Ganzzahldivision	`7 // 2` ergibt `3`
`%`	Rest einer Division	`7 % 2` ergibt `1`
`**`	Potenz	`2 ** 3` ergibt `8`

Merksatz

Der Modulo-Operator % ist besonders nützlich, wenn man prüfen möchte, ob eine Zahl gerade oder ungerade ist.

Beispiel:

python

zahl = 8

if zahl % 2 == 0:
    print("gerade")
else:
    print("ungerade")

Vergleichsoperatoren

Vergleichsoperatoren prüfen Bedingungen. Das Ergebnis ist immer True oder False.

Operator	Bedeutung
`==`	ist gleich
`!=`	ist ungleich
`<`	kleiner als
`>`	größer als
`<=`	kleiner oder gleich
`>=`	größer oder gleich

Beispiel:

python

alter = 17
print(alter >= 18)

Ausgabe:

txt

False

Boolesche Operatoren

Mit booleschen Operatoren können Bedingungen verbunden werden.

Operator	Bedeutung
`and`	beide Bedingungen müssen wahr sein
`or`	mindestens eine Bedingung muss wahr sein
`not`	kehrt den Wahrheitswert um

Beispiel:

python

alter = 17
hat_erlaubnis = True

if alter >= 18 or hat_erlaubnis:
    print("Zugang erlaubt")
else:
    print("Zugang nicht erlaubt")

Bedingte Anweisungen

Mit if, elif und else kann ein Programm Entscheidungen treffen.

python

zahl = int(input("Zahl eingeben: "))

if zahl > 0:
    print("positiv")
elif zahl < 0:
    print("negativ")
else:
    print("null")

Merke

Bedingungen ermöglichen Verzweigungen im Programmablauf. Das Programm reagiert abhängig von Daten oder Eingaben unterschiedlich.

Einrückung in Python

Python verwendet Einrückungen, um zusammengehörige Codeblöcke zu kennzeichnen.

Richtig:

python

if zahl > 0:
    print("Die Zahl ist positiv.")

Falsch:

python

if zahl > 0:
print("Die Zahl ist positiv.")

Wichtig

Einrückungen sind in Python nicht nur optisch wichtig, sondern Teil der Sprache.

Schleifen

Schleifen wiederholen Anweisungen.

for-Schleife

Eine for-Schleife wird verwendet, wenn man weiß oder gut festlegen kann, wie oft etwas wiederholt werden soll.

python

for i in range(5):
    print("Hallo")

Das gibt fünfmal Hallo aus.

Beispiel mit Zahlen:

python

for i in range(1, 6):
    print(i)

Ausgabe:

txt

Merke

range(5) erzeugt die Werte 0, 1, 2, 3, 4. Der Endwert ist nicht enthalten.

while-Schleife

Eine while-Schleife läuft, solange eine Bedingung wahr ist.

python

zahl = int(input("Zahl eingeben, -1 beendet: "))

while zahl != -1:
    print("Du hast eingegeben:", zahl)
    zahl = int(input("Zahl eingeben, -1 beendet: "))

Wichtig

Bei while-Schleifen muss sich die Bedingung irgendwann ändern können. Sonst entsteht eine Endlosschleife.

Funktionen

Eine Funktion ist ein benannter Programmteil, der eine bestimmte Aufgabe übernimmt.

python

def begruessung():
    print("Hallo!")

Die Funktion wird erst ausgeführt, wenn sie aufgerufen wird:

python

begruessung()

Funktionen mit Parametern

Funktionen können Werte übergeben bekommen. Diese Werte heißen Parameter.

python

def begruessung(name):
    print("Hallo", name)

Aufruf:

python

begruessung("Mina")

Funktionen mit Rückgabewert

Mit return kann eine Funktion ein Ergebnis zurückgeben.

python

def quadrat(zahl):
    return zahl * zahl

ergebnis = quadrat(5)
print(ergebnis)

Ausgabe:

txt

Merke

Funktionen helfen dabei, Programme zu strukturieren, Wiederholungen zu vermeiden und einzelne Aufgaben klar voneinander zu trennen.

Methoden

Eine Methode ist eine Funktion, die zu einem Objekt gehört.

Beispiel:

python

text = "hallo"
print(text.upper())

upper() ist eine Methode des Strings text.

Auch bei Turtle-Grafiken werden Methoden bzw. Funktionsaufrufe verwendet:

python

turtle.forward(100)
turtle.left(90)

Bibliotheken

Eine Bibliothek stellt zusätzliche Funktionen, Objekte oder Werkzeuge bereit.

Beispiel:

python

import turtle

Damit kann man die Turtle-Bibliothek verwenden.

python

import random

Damit kann man Zufallszahlen erzeugen.

Merke

Bibliotheken erweitern Python um Funktionen, die nicht jedes Mal selbst programmiert werden müssen.

Turtle-Grafik

Die Turtle-Bibliothek eignet sich gut, um Programmabläufe sichtbar zu machen. Eine Turtle bewegt sich über den Bildschirm und zeichnet dabei Linien.

Beispiel:

python

import turtle

turtle.forward(100)
turtle.left(90)
turtle.forward(100)

turtle.done()

Wichtige Befehle:

Befehl	Bedeutung
`turtle.forward(100)`	bewegt die Turtle 100 Schritte vorwärts
`turtle.backward(100)`	bewegt die Turtle 100 Schritte rückwärts
`turtle.left(90)`	dreht die Turtle 90 Grad nach links
`turtle.right(90)`	dreht die Turtle 90 Grad nach rechts
`turtle.penup()`	hebt den Stift
`turtle.pendown()`	senkt den Stift
`turtle.done()`	hält das Fenster offen

Wichtig

In manchen Umgebungen muss turtle.done() am Ende stehen, damit das Ausgabefenster sichtbar bleibt.

Vier regelmäßige Vielecke mit Beschriftung der jeweiligen Drehwinkel. — Abb.: Regelmäßige Vielecke als Turtle-nahe Visualisierung. Die Grafik zeigt, wie sich die Anzahl der Wiederholungen und der Drehwinkel gegenseitig bestimmen. Eigene Darstellung.

Regelmäßige Vielecke zeichnen

Viele Turtle-Figuren entstehen durch eine einfache Grundidee: Eine Bewegung wird mehrmals wiederholt, und nach jeder Seite dreht sich die Turtle um denselben Winkel.

Für ein regelmäßiges Vieleck gilt:

txt

Drehwinkel = 360 / Anzahl der Ecken

Ein mögliches Programm könnte so aussehen:

python

import turtle


def zeichne_vieleck(anzahl_ecken, seitenlaenge):
    winkel = 360 / anzahl_ecken

    for i in range(anzahl_ecken):
        turtle.forward(seitenlaenge)
        turtle.left(winkel)


zeichne_vieleck(5, 80)
turtle.done()

Merksatz

Bei einem regelmäßigen Vieleck verteilt sich eine volle Drehung von 360° gleichmäßig auf alle Seiten.

📝 Übung: Vieleck-Generator verbessern

Du bekommst einen ersten Entwurf für ein Zeichenprogramm. Es soll ein regelmäßiges Vieleck zeichnen, ist aber noch sehr starr:

python

import turtle

for i in range(5):
    turtle.forward(80)
    turtle.left(72)

turtle.done()

Überarbeite den Entwurf so, dass daraus ein flexibler Vieleck-Generator wird.

Erkläre zuerst, warum 72 bei fünf Ecken der richtige Drehwinkel ist.
Schreibe den Code so um, dass die Eckenzahl in einer Variable gespeichert wird.
Berechne den Drehwinkel aus dieser Variable.
Ergänze eine sinnvolle Seitenlänge, die bei vielen Ecken nicht zu groß wird.
Teste gedanklich, was bei 3, 6 und 12 Ecken passiert.

Lösungshinweis

python

import turtle

ecken = int(input("Eckenzahl eingeben: "))

if ecken >= 3:
    winkel = 360 / ecken
    seitenlaenge = 240 / ecken + 25

    for i in range(ecken):
        turtle.forward(seitenlaenge)
        turtle.left(winkel)
else:
    print("Ein Vieleck braucht mindestens drei Ecken.")

turtle.done()

Hier wird nicht nur eine fertige Funktion abgeschrieben, sondern ein starrer Code schrittweise verallgemeinert. Das ist ein wichtiger Schritt beim Programmieren: Aus einem Einzelfall entsteht ein flexibler Algorithmus.

Funktionen bei Turtle-Grafiken

Turtle-Programme werden übersichtlicher, wenn man häufig verwendete Zeichenschritte in Funktionen auslagert.

Beispiel:

python

import turtle


def zeichne_quadrat(seitenlaenge):
    for i in range(4):
        turtle.forward(seitenlaenge)
        turtle.left(90)


zeichne_quadrat(80)
turtle.done()

Diese Funktion zeichnet ein Quadrat mit frei wählbarer Seitenlänge.

Man kann Funktionen auch kombinieren. Das folgende Beispiel zeichnet eine Rosette aus Quadraten, die alle um denselben Mittelpunkt angeordnet sind:

python

import turtle
import math


def zeichne_zentriertes_quadrat(seitenlaenge, winkel):
    turtle.penup()
    turtle.goto(0, 0)
    turtle.setheading(winkel + 225)
    turtle.forward(seitenlaenge / math.sqrt(2))

    turtle.setheading(winkel)
    turtle.pendown()

    for i in range(4):
        turtle.forward(seitenlaenge)
        turtle.left(90)


def zeichne_quadrat_rosette(anzahl, seitenlaenge):
    for i in range(anzahl):
        winkel = i * 360 / anzahl
        zeichne_zentriertes_quadrat(seitenlaenge, winkel)


zeichne_quadrat_rosette(12, 160)
turtle.done()

Der Zusatz mit penup(), goto() und setheading() sorgt dafür, dass jedes Quadrat wieder passend um den Mittelpunkt ausgerichtet wird. Ohne diesen Schritt würde die Turtle immer vom aktuellen Standpunkt weiterzeichnen.

Merke

Funktionen machen Turtle-Programme modular: Ein einzelner Programmteil übernimmt eine klar erkennbare Aufgabe.

Mehrere gedrehte Quadrate bilden ein symmetrisches Muster. — Abb.: Rosette aus mehrfach gedrehten Quadraten. Das Muster zeigt, wie Funktionen und Schleifen zusammenarbeiten: Eine Form wird als Funktion definiert und anschließend wiederholt aufgerufen. Eigene Darstellung.

📝 Übung: Ein anderes Muster modular planen

Plane ein Turtle-Programm für ein Sonnenrad aus Dreiecken. Du musst nicht exakt dieselbe Rosette wie im Beispiel nachbauen. Ziel ist, die Idee der Modularität auf eine neue Figur zu übertragen.

Schreibe eine Funktion zeichne_dreieck(seitenlaenge).
Schreibe eine zweite Funktion zeichne_sonnenrad(anzahl, seitenlaenge).
Nach jedem Dreieck soll sich die Turtle weiterdrehen.
Erkläre, welche Aufgabe jede der beiden Funktionen übernimmt.
Überlege, welcher Parameter das Aussehen stärker verändert: anzahl oder seitenlaenge.

Lösungshinweis

python

import turtle


def zeichne_dreieck(seitenlaenge):
    for i in range(3):
        turtle.forward(seitenlaenge)
        turtle.left(120)


def zeichne_sonnenrad(anzahl, seitenlaenge):
    for i in range(anzahl):
        zeichne_dreieck(seitenlaenge)
        turtle.left(360 / anzahl)


zeichne_sonnenrad(10, 90)
turtle.done()

Die Lösung übernimmt nicht das Quadrat-Beispiel, sondern überträgt die Grundidee auf eine andere Form. Genau dieser Transfer ist beim Programmieren wichtig.

Parameter gezielt verändern

Programme werden besonders interessant, wenn sich Werte gezielt verändern lassen. Bei Turtle-Grafiken kann etwa die Anzahl der Wiederholungen als Parameter eingesetzt werden. Das Programm bleibt fast gleich, aber die Ausgabe verändert sich deutlich.

python

import turtle


def zeichne_quadrat(seitenlaenge):
    for i in range(4):
        turtle.forward(seitenlaenge)
        turtle.left(90)


def zeichne_rosette(anzahl, seitenlaenge):
    for i in range(anzahl):
        zeichne_quadrat(seitenlaenge)
        turtle.left(360 / anzahl)


zeichne_rosette(10, 80)
turtle.done()

Merke

Parameter wie Seitenlänge, Winkel oder Wiederholungszahl steuern das Verhalten eines Programms. Kleine Änderungen am Parameter können die Ausgabe deutlich verändern, ohne dass das ganze Programm neu geschrieben werden muss.

Drei Turtle-Muster mit unterschiedlicher Wiederholungszahl als Parametervergleich. — Abb.: Parametervergleich bei Turtle-Grafiken. Dasselbe Grundprinzip erzeugt je nach Wiederholungszahl ein anderes Muster. So wird sichtbar, warum Funktionen mit Parametern Programme flexibler machen. Eigene Darstellung.

Programme lesen und Fehler finden

Programmieren besteht nicht nur aus Schreiben, sondern auch aus Lesen, Testen und Verbessern von Code.

Code-Tracing

Beim Code-Tracing geht man ein Programm Schritt für Schritt durch und notiert, wie sich Variablen verändern.

Beispiel:

python

werte = [6, 14, 3, 8]
summe = 0
anzahl = 0
gerade = 0
ungerade = 0

for zahl in werte:
    summe += zahl
    anzahl += 1

    if zahl % 2 == 0:
        gerade += 1
    else:
        ungerade += 1

durchschnitt = summe / anzahl

Bei diesem Programm ändern sich nicht nur eine, sondern mehrere Variablen gleichzeitig. Beim Tracing wird daher nach jedem Schleifendurchlauf festgehalten, welche Zahl gerade verarbeitet wurde und wie sich summe, anzahl, gerade und ungerade verändern. Erst am Ende kann der Durchschnitt sinnvoll berechnet werden.

Merke

Code-Tracing hilft, Programmabläufe sichtbar zu machen und Fehler zu finden. Besonders nützlich ist es, wenn Schleifen, Zähler, Bedingungen und Berechnungen zusammenwirken.

Code-Tracing-Tabelle mit mehreren Variablen: zahl, summe, anzahl, gerade, ungerade und durchschnitt. — Abb.: Code-Tracing mit mehreren Variablen. Die Tabelle zeigt nach jedem Schleifendurchlauf, welche Zahl verarbeitet wurde und wie sich Summe, Anzahl sowie die Zähler für gerade und ungerade Zahlen verändern. Eigene Darstellung.

Beispiel: Zahlen auswerten

Ein Programm soll mehrere ganze Zahlen einlesen und auswerten.

Grundidee:

summe speichert die Summe aller eingegebenen Zahlen.
anzahl zählt, wie viele Zahlen eingegeben wurden.
gerade und ungerade zählen die Zahlen je nach Teilbarkeit durch 2.
Die Eingabe endet mit einem vereinbarten Abbruchwert.

Beispiel:

python

summe = 0
anzahl = 0
gerade = 0
ungerade = 0

zahl = int(input("Ganze Zahl eingeben (-1 beendet): "))

while zahl != -1:
    summe += zahl
    anzahl += 1

    if zahl % 2 == 0:
        gerade += 1
    else:
        ungerade += 1

    zahl = int(input("Ganze Zahl eingeben (-1 beendet): "))

if anzahl > 0:
    print("Summe:", summe)
    print("Anzahl:", anzahl)
    print("Durchschnitt:", summe / anzahl)
    print("Gerade Zahlen:", gerade)
    print("Ungerade Zahlen:", ungerade)
else:
    print("Es wurden keine Werte eingegeben.")

Achtung

Wenn kein Wert eingegeben wurde, ist anzahl gleich 0. Dann darf nicht durch 0 dividiert werden.

Ausführliche Konsolenausgabe eines Python-Programms zur Auswertung mehrerer Zahlen. — Abb.: Ausführliche Programmausgabe nach der Auswertung mehrerer Zahlen. Die Konsole zeigt Eingaben, Abbruchwert und Ergebniswerte. Dadurch wird nachvollziehbar, wie Variablen wie Summe, Anzahl, Durchschnitt sowie gerade und ungerade Zahlen zusammenhängen. Eigene Darstellung.

📝 Übung: Auswertung als Funktion umbauen

Das vorige Beispiel arbeitet mit Eingaben in einer while-Schleife. Übertrage die Idee nun auf eine andere Struktur: Eine Liste von Messwerten ist bereits vorhanden.

Gegeben ist:

python

messwerte = [12, 7, 0, 15, 8, 3]

Schreibe eine Funktion wertebericht(messwerte), die Folgendes ausgibt:

die Anzahl der Werte,
die Summe,
den Durchschnitt,
den kleinsten Wert,
den größten Wert,
wie viele Werte mindestens 10 betragen.

Lösungshinweis

python

def wertebericht(messwerte):
    anzahl = len(messwerte)
    summe = sum(messwerte)
    durchschnitt = summe / anzahl
    minimum = min(messwerte)
    maximum = max(messwerte)

    mindestens_zehn = 0
    for wert in messwerte:
        if wert >= 10:
            mindestens_zehn += 1

    print("Anzahl:", anzahl)
    print("Summe:", summe)
    print("Durchschnitt:", durchschnitt)
    print("Minimum:", minimum)
    print("Maximum:", maximum)
    print("Werte ab 10:", mindestens_zehn)


wertebericht([12, 7, 0, 15, 8, 3])

Die Übung verwendet dieselben Grundideen wie das Eingabeprogramm, aber in einer anderen Situation: Statt einer Abbruchschleife wird eine vorhandene Liste verarbeitet.

Syntax und Semantik

Syntax

Die Syntax beschreibt die formalen Regeln einer Programmiersprache.

Beispiele für Syntaxregeln in Python:

Nach if, elif, else, for, while und def steht ein Doppelpunkt.
Codeblöcke werden eingerückt.
Klammern und Anführungszeichen müssen korrekt gesetzt werden.
Variablennamen dürfen bestimmten Regeln nicht widersprechen.

Syntaxfehler:

python

if alter >= 18
    print("volljährig")

Hier fehlt der Doppelpunkt.

Korrekt:

python

if alter >= 18:
    print("volljährig")

Merke

Ein Syntaxfehler verhindert meist, dass das Programm überhaupt ausgeführt wird.

Semantik

Die Semantik beschreibt die Bedeutung eines Programms.

Ein Programm kann syntaktisch korrekt sein und trotzdem etwas Falsches tun.

Beispiel:

python

summe = 30
anzahl = 3

durchschnitt = anzahl / summe
print(durchschnitt)

Der Code ist syntaktisch korrekt, aber semantisch falsch, wenn der Durchschnitt berechnet werden soll. Richtig wäre:

python

durchschnitt = summe / anzahl

Wichtig

Syntaxfehler erkennt Python oft sofort. Semantikfehler sind manchmal schwieriger zu finden, weil das Programm läuft, aber falsche Ergebnisse liefert.

Interpreterausgaben zu Syntaxfehler, semantischem Fehler und korrigiertem Programm. — Abb.: Interpreter- und Testergebnisse zu Syntax und Semantik. Ein Syntaxfehler stoppt die Ausführung sofort. Ein semantischer Fehler lässt das Programm laufen, führt aber zu einem falschen Ergebnis; erst der korrigierte Test ist erfolgreich. Eigene Darstellung.

Natürliche Sprache und Programmiersprache

Natürliche Sprache kann mehrdeutig sein.

Beispiel:

Ich sehe den Mann mit dem Fernglas.

Das kann bedeuten:

Ich verwende ein Fernglas.
Der Mann hat ein Fernglas.

Programmiersprachen müssen solche Mehrdeutigkeit vermeiden. Ein Computer soll genau wissen, welche Anweisung gemeint ist.

Merksatz

Natürliche Sprache lebt oft von Kontext und Mehrdeutigkeit. Programmiersprachen brauchen Eindeutigkeit und klare Regeln.

Strukturierter Code

Guter Code soll nicht nur funktionieren, sondern auch verständlich sein.

Dazu helfen:

klare Variablennamen,
klare Funktionsnamen,
sinnvolle Kommentare,
einheitliche Formatierung,
Modularität,
übersichtliche Programmstruktur.

Kommentare

Kommentare erklären den Code für Menschen. Python ignoriert sie bei der Ausführung.

python

# Berechnet den Durchschnitt aller eingegebenen Werte
durchschnitt = summe / anzahl

Gute Kommentare erklären nicht jeden offensichtlichen Schritt, sondern helfen beim Verständnis.

Weniger hilfreich:

python

# erhöhe anzahl um 1
anzahl += 1

Hilfreicher:

python

# Ein gültiger Wert wurde eingelesen
anzahl += 1

Modularität

Modularität bedeutet, ein Programm in kleinere, möglichst unabhängige Teile zu zerlegen.

Beispiel:

python

def eingabe_lesen():
    return int(input("Zahl eingeben: "))


def ist_gerade(zahl):
    return zahl % 2 == 0


def ausgabe(text):
    print(text)

Vorteile:

Code wird übersichtlicher.
Einzelne Teile können leichter getestet werden.
Aufgaben können in Teams aufgeteilt werden.
Funktionen können wiederverwendet werden.
Fehler sind leichter einzugrenzen.

Merke

Modularer Code ist besonders wichtig bei größeren Projekten, Teamarbeit und späteren Erweiterungen.

Bibliotheken sinnvoll nutzen

Bibliotheken wie turtle, random oder math stellen fertige Werkzeuge bereit.

Beispiel:

python

import random

zahl = random.randint(1, 6)
print("Gewürfelt:", zahl)

Wichtig

Bibliotheken sparen Arbeit, aber man sollte trotzdem verstehen, was die verwendeten Funktionen grundsätzlich tun.

Fehleranalyse und Testen

Beim Programmieren treten Fehler ganz normal auf. Wichtig ist, sie systematisch zu finden.

Hilfreiche Strategien:

Fehlermeldungen genau lesen,
Programm schrittweise testen,
Zwischenergebnisse ausgeben,
kleine Testfälle verwenden,
Variablenwerte notieren,
Codeabschnitte einzeln prüfen,
Kommentare oder Pseudocode zur Planung nutzen.

Strategie

Wenn ein Programm nicht funktioniert, erkläre nicht nur „es geht nicht“, sondern beschreibe möglichst genau:

Was sollte passieren?
Was passiert tatsächlich?
An welcher Stelle könnte der Fehler liegen?
Welche Werte haben die Variablen an dieser Stelle?

Pseudocode

Pseudocode beschreibt einen Algorithmus in einer Mischung aus Alltagssprache und Programmstruktur.

Beispiel:

txt

Setze Summe auf 0
Setze Anzahl auf 0
Lies einen Wert ein

Solange der Wert nicht der Abbruchwert ist:
    Addiere den Wert zur Summe
    Erhöhe die Anzahl um 1
    Prüfe, ob der Wert gerade oder ungerade ist
    Lies den nächsten Wert ein

Wenn Anzahl größer als 0:
    Berechne Durchschnitt = Summe / Anzahl
    Gib die Ergebnisse aus
Sonst:
    Gib aus: Keine Werte eingegeben

Merke

Pseudocode hilft, die Logik eines Programms zu planen, bevor man sich mit genauer Syntax beschäftigt.

Prüfungsvorbereitung

Die folgenden Aufgaben trainieren dieselben Kompetenzen, verwenden aber andere Kontexte, Daten und Beispiele. Sie trainieren Transfer: Du sollst Beispiele nicht abschreiben, sondern auf neue Situationen anwenden.

📝 Übung: Code lesen, nicht nur ausführen

Betrachte den Code. Er ist syntaktisch korrekt.

python

rabatt = 0.10
preis = 24.90
anzahl = 3

gesamt = preis * anzahl
endpreis = gesamt - gesamt * rabatt

print(endpreis)

Erkläre die Bedeutung der Variablen.
Berechne das Ergebnis schrittweise.
Ändere den Code gedanklich so, dass der Rabatt erst ab mindestens 50 Euro Gesamtpreis gilt.

Lösungshinweis

Der Gesamtpreis vor Rabatt beträgt 24.90 * 3 = 74.70. Der Rabatt beträgt 10 %, also 7.47. Der Endpreis ist 67.23.

Eine mögliche Erweiterung:

python

if gesamt >= 50:
    endpreis = gesamt - gesamt * rabatt
else:
    endpreis = gesamt

📝 Übung: Eingaben robust machen

Ein Programm fragt nach einer Zahl und soll ausgeben, ob sie durch 3 teilbar ist.

Lies eine Zahl ein.
Wandle die Eingabe in int um.
Prüfe mit dem Modulo-Operator, ob die Zahl durch 3 teilbar ist.
Erweitere das Programm so, dass bei einer negativen Zahl zusätzlich eine Warnung ausgegeben wird.

Lösungshinweis

python

zahl = int(input("Zahl eingeben: "))

if zahl < 0:
    print("Hinweis: Die Zahl ist negativ.")

if zahl % 3 == 0:
    print("Die Zahl ist durch 3 teilbar.")
else:
    print("Die Zahl ist nicht durch 3 teilbar.")

📝 Übung: Turtle-Code übertragen

Du kennst nun Vielecke und einfache Muster. Entwickle daraus ein kleines Logo aus zwei Formen:

Zeichne zuerst ein regelmäßiges Sechseck.
Hebe den Stift, gehe ein Stück nach rechts und senke den Stift wieder.
Zeichne dort ein Dreieck.
Lagere beide Formen in eigene Funktionen aus.
Erkläre, warum penup() und pendown() hier wichtig sind.

Lösungshinweis

python

import turtle


def sechseck(seite):
    for i in range(6):
        turtle.forward(seite)
        turtle.left(60)


def dreieck(seite):
    for i in range(3):
        turtle.forward(seite)
        turtle.left(120)


sechseck(60)

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

dreieck(80)

turtle.done()

penup() verhindert, dass beim Wechsel der Position eine Verbindungslinie gezeichnet wird.

📝 Übung: Fehlerarten unterscheiden

Ordne die folgenden Probleme zu: Syntaxfehler, Laufzeitfehler oder semantischer Fehler. Begründe jeweils kurz.

python

# A
if zahl > 10
    print("groß")

# B
preis = input("Preis: ")
print(preis * 2)

# C
summe = 60
anzahl = 5
durchschnitt = anzahl / summe

Lösungshinweis

A ist ein Syntaxfehler, weil nach der Bedingung der Doppelpunkt fehlt.

B ist kein Syntaxfehler. Python wiederholt bei Textmultiplikation den Text. Das kann ein semantischer Fehler sein, wenn eigentlich gerechnet werden sollte. Sinnvoll wäre float(input(...)).

C ist syntaktisch korrekt, aber semantisch falsch, weil der Durchschnitt als summe / anzahl berechnet werden müsste.

📝 Übung: Modularität beurteilen

Ein Programm besteht aus einem einzigen langen Codeblock. Darin werden Eingaben gelesen, Werte geprüft, Berechnungen durchgeführt und Ergebnisse ausgegeben.

Nenne zwei Nachteile dieser Struktur.
Schlage drei sinnvolle Funktionen vor, in die man das Programm aufteilen könnte.
Erkläre, warum diese Aufteilung die Fehlersuche erleichtert.

Lösungshinweis

Nachteile: Der Code ist schwer zu lesen, schwer zu testen und schwer zu erweitern.

Mögliche Funktionen:

python

def eingabe_lesen():
    ...

def werte_pruefen(wert):
    ...

def ergebnis_ausgeben(ergebnis):
    ...

Wenn jede Funktion eine klare Aufgabe hat, kann man sie einzeln testen. Fehler lassen sich dadurch besser eingrenzen.

Ich kann …

Nach der Wiederholung dieses Themenbereichs solltest du Folgendes können:

Ich kann erklären, was ein Computerprogramm ist.
Ich kann beschreiben, warum Programmiersprachen eindeutig sein müssen.
Ich kann zentrale Sprachkonstrukte von Python nennen und erklären.
Ich kann Variablen und passende Variablennamen verwenden.
Ich kann grundlegende Datentypen wie int, float, str und bool unterscheiden.
Ich kann erklären, warum Eingaben mit input() oft gecastet werden müssen.
Ich kann arithmetische Operatoren, Vergleichsoperatoren und boolesche Operatoren anwenden.
Ich kann bedingte Anweisungen mit if, elif und else formulieren.
Ich kann for- und while-Schleifen unterscheiden und einsetzen.
Ich kann Funktionen mit Parametern und Rückgabewerten erklären.
Ich kann Methoden und Funktionen grundsätzlich voneinander unterscheiden.
Ich kann Bibliotheken wie turtle oder random sinnvoll einordnen.
Ich kann einfache Turtle-Programme lesen, verändern und erklären.
Ich kann Schleifen und Funktionen in Turtle-Grafiken sinnvoll einsetzen.
Ich kann Programme Schritt für Schritt analysieren und Variablenwerte nachverfolgen.
Ich kann Syntaxfehler und Semantikfehler unterscheiden.
Ich kann erklären, wie Python auf Fehler reagiert.
Ich kann beschreiben, warum Kommentare, gute Namen und Modularität wichtig sind.
Ich kann Pseudocode nutzen, um Programmabläufe vor dem Codieren zu planen.
Ich kann beim Programmieren genaues Lesen, logisches Denken und systematisches Testen anwenden.

Mini-Check

Beantworte zum Abschluss kurz:

Was ist eine Variable?
Worin unterscheiden sich int, float, str und bool?
Warum liefert input() zunächst einen Text zurück?
Was bedeutet Casting?
Wofür verwendet man den Modulo-Operator %?
Was ist der Unterschied zwischen = und ==?
Wann eignet sich eine for-Schleife besonders gut?
Wann eignet sich eine while-Schleife besonders gut?
Was ist eine Funktion?
Was bedeutet return?
Warum sind Schleifen bei Turtle-Grafiken hilfreich?
Was ist ein Syntaxfehler?
Was ist ein Semantikfehler?
Warum sind gute Variablen- und Funktionsnamen wichtig?
Warum ist Modularität bei Teamprojekten hilfreich?
Welche überfachlichen Fähigkeiten trainierst du beim Programmieren?

Kurzlösungen

Ein benannter Speicherplatz für einen Wert.
int ist eine ganze Zahl, float eine Kommazahl, str Text, bool ein Wahrheitswert.
Weil Nutzereingaben zunächst als Zeichenkette eingelesen werden.
Die Umwandlung eines Werts in einen anderen Datentyp.
Um den Rest einer Division zu bestimmen, z. B. zur Prüfung auf gerade oder ungerade Zahlen.
= weist einen Wert zu; == vergleicht zwei Werte.
Wenn die Anzahl der Wiederholungen bekannt oder gut festlegbar ist.
Wenn eine Wiederholung von einer Bedingung abhängt.
Ein benannter Programmteil, der eine bestimmte Aufgabe übernimmt.
return gibt ein Ergebnis aus einer Funktion zurück.
Weil wiederholte Bewegungen und Drehungen kompakt formuliert werden können.
Ein Verstoß gegen die formalen Regeln der Programmiersprache.
Ein Bedeutungsfehler: Das Programm läuft, macht aber nicht das Gewünschte.
Sie machen Code verständlicher und leichter wartbar.
Aufgaben können besser aufgeteilt, getestet und erweitert werden.
Genaues Lesen, logisches Denken, systematisches Testen, Fehlersuche, Ausdauer und strukturiertes Problemlösen.

🐍 Thema 5: Grundlagen der Programmierung ​

Überblick ​

Was ist ein Programm? ​

Programmiersprachen ​

Zentrale Sprachkonstrukte in Python ​

Variablen ​

Gute Variablennamen ​

Datentypen ​

Eingaben und Casting ​

📝 Übung: Eingaben sinnvoll weiterverarbeiten ​

Operatoren ​

Arithmetische Operatoren ​

Vergleichsoperatoren ​

Boolesche Operatoren ​

Bedingte Anweisungen ​

Einrückung in Python ​

Schleifen ​

for-Schleife ​

while-Schleife ​

Funktionen ​

Funktionen mit Parametern ​

Funktionen mit Rückgabewert ​

Methoden ​

Bibliotheken ​

Turtle-Grafik ​

Regelmäßige Vielecke zeichnen ​

📝 Übung: Vieleck-Generator verbessern ​

Funktionen bei Turtle-Grafiken ​

📝 Übung: Ein anderes Muster modular planen ​

Parameter gezielt verändern ​

Programme lesen und Fehler finden ​

Code-Tracing ​

Beispiel: Zahlen auswerten ​

📝 Übung: Auswertung als Funktion umbauen ​

Syntax und Semantik ​

Syntax ​

Semantik ​

Natürliche Sprache und Programmiersprache ​

Strukturierter Code ​

Kommentare ​

Modularität ​

Bibliotheken sinnvoll nutzen ​

Fehleranalyse und Testen ​

Pseudocode ​

Prüfungsvorbereitung ​

📝 Übung: Code lesen, nicht nur ausführen ​

📝 Übung: Eingaben robust machen ​

📝 Übung: Turtle-Code übertragen ​

📝 Übung: Fehlerarten unterscheiden ​

📝 Übung: Modularität beurteilen ​

Ich kann … ​

Mini-Check ​

🐍 Thema 5: Grundlagen der Programmierung

Überblick

Was ist ein Programm?

Programmiersprachen

Zentrale Sprachkonstrukte in Python

Variablen

Gute Variablennamen

Datentypen

Eingaben und Casting

📝 Übung: Eingaben sinnvoll weiterverarbeiten

Operatoren

Arithmetische Operatoren

Vergleichsoperatoren

Boolesche Operatoren

Bedingte Anweisungen

Einrückung in Python

Schleifen

for-Schleife

while-Schleife

Funktionen

Funktionen mit Parametern

Funktionen mit Rückgabewert

Methoden

Bibliotheken

Turtle-Grafik

Regelmäßige Vielecke zeichnen

📝 Übung: Vieleck-Generator verbessern

Funktionen bei Turtle-Grafiken

📝 Übung: Ein anderes Muster modular planen

Parameter gezielt verändern

Programme lesen und Fehler finden

Code-Tracing

Beispiel: Zahlen auswerten

📝 Übung: Auswertung als Funktion umbauen

Syntax und Semantik

Syntax

Semantik

Natürliche Sprache und Programmiersprache

Strukturierter Code

Kommentare

Modularität

Bibliotheken sinnvoll nutzen

Fehleranalyse und Testen

Pseudocode

Prüfungsvorbereitung

📝 Übung: Code lesen, nicht nur ausführen

📝 Übung: Eingaben robust machen

📝 Übung: Turtle-Code übertragen

📝 Übung: Fehlerarten unterscheiden

📝 Übung: Modularität beurteilen

Ich kann …

Mini-Check