From ef65a6e0e06e55dd34a08f897c9f3d04a99591ce Mon Sep 17 00:00:00 2001 From: fedx21dragon Date: Wed, 2 Sep 2026 14:22:32 +0200 Subject: [PATCH 1/2] Lektion Hello wor Signed-off-by: fedx21dragon --- Code/HelloWorld.java | 5 ++ Code/helloworld.cpp | 6 ++ Code/test_installation.py | 20 +++++++ Lektionen/helloworld.typ | 116 ++++++++++++++++++++++++++++++++++++++ lib/helpers.typ | 30 +++++++++- 5 files changed, 174 insertions(+), 3 deletions(-) create mode 100644 Code/HelloWorld.java create mode 100644 Code/helloworld.cpp create mode 100644 Code/test_installation.py create mode 100644 Lektionen/helloworld.typ diff --git a/Code/HelloWorld.java b/Code/HelloWorld.java new file mode 100644 index 0000000..9bc1603 --- /dev/null +++ b/Code/HelloWorld.java @@ -0,0 +1,5 @@ +public class HelloWorld { + public static void main(String[] args) { + System.out.println("Hello World!"); + } +} diff --git a/Code/helloworld.cpp b/Code/helloworld.cpp new file mode 100644 index 0000000..7dd560a --- /dev/null +++ b/Code/helloworld.cpp @@ -0,0 +1,6 @@ +#include + +int main() { + std::cout<<"Hello world!"< Date: Thu, 3 Sep 2026 15:35:44 +0200 Subject: [PATCH 2/2] Lektion Variablen und Arithmetik (Python) Signed-off-by: fedx21dragon --- .gitignore | 8 ++ Code/eingabe_zahlen.py | 17 +++ Code/rechnen.py | 18 +++ Code/rechner_eingabe.py | 13 ++ Code/variablen.py | 5 + Code/variablen_aendern.py | 23 ++++ Lektionen/variablen_aritmetik.typ | 206 ++++++++++++++++++++++++++++++ lib/helpers.typ | 10 +- main.typ | 19 +-- 9 files changed, 299 insertions(+), 20 deletions(-) create mode 100644 .gitignore create mode 100644 Code/eingabe_zahlen.py create mode 100644 Code/rechnen.py create mode 100644 Code/rechner_eingabe.py create mode 100644 Code/variablen.py create mode 100644 Code/variablen_aendern.py create mode 100644 Lektionen/variablen_aritmetik.typ diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9e05a5d --- /dev/null +++ b/.gitignore @@ -0,0 +1,8 @@ +graphify-out/ +graphity-out +.json +main.pdf +CLAUDE.md +.idea/ +__pycache__/ +*.pyc diff --git a/Code/eingabe_zahlen.py b/Code/eingabe_zahlen.py new file mode 100644 index 0000000..269dfce --- /dev/null +++ b/Code/eingabe_zahlen.py @@ -0,0 +1,17 @@ +# input() hält das Programm an und wartet auf eine Eingabe der Nutzerin. +# WICHTIG: input() liefert das Eingegebene IMMER als Text (str) zurück - +# auch dann, wenn die Nutzerin eine Zahl eingetippt hat. + +erste_eingabe = input("Gib eine Zahl ein: ") +zweite_eingabe = input("Gib noch eine Zahl ein: ") + +# "+" verbindet zwei Texte einfach hintereinander (Konkatenation). +# Bei den Eingaben "12" und "3" käme hier "123" heraus - nicht 15! +print("Als Text aneinandergehängt:", erste_eingabe + zweite_eingabe) + +# Damit wir rechnen können, müssen wir den Text erst in eine ganze Zahl +# umwandeln. Das erledigt die Funktion int(). +erste_zahl = int(erste_eingabe) +zweite_zahl = int(zweite_eingabe) + +print("Als Zahlen addiert:", erste_zahl + zweite_zahl) diff --git a/Code/rechnen.py b/Code/rechnen.py new file mode 100644 index 0000000..c6e011d --- /dev/null +++ b/Code/rechnen.py @@ -0,0 +1,18 @@ +# Rechnen mit ganzen Zahlen. Python nutzt die Rechenausdrücke, die wir aus +# der Schule kennen, plus die bereits bekannte Zuweisung mit "=". + +a = 18 +b = 5 + +print("Summe: ", a + b) # 23 +print("Differenz: ", a - b) # 13 +print("Produkt: ", a * b) # 90 +print("Quotient: ", a / b) # 3.6 <- / liefert IMMER eine Kommazahl (float) +print("Ganzzahl-Div: ", a // b) # 3 <- // schneidet den Rest ab +print("Rest (modulo):", a % b) # 3 <- was bei 18 : 5 übrig bleibt +print("Potenz: ", a ** b) # 1889568 <- a hoch b + +# Rechenreihenfolge ("Punkt vor Strich") gilt wie in der Mathematik. +# Mit Klammern kann man sie steuern: +print(2 + 3 * 4) # 14 +print((2 + 3) * 4) # 20 diff --git a/Code/rechner_eingabe.py b/Code/rechner_eingabe.py new file mode 100644 index 0000000..5bfdf6d --- /dev/null +++ b/Code/rechner_eingabe.py @@ -0,0 +1,13 @@ +# Ein kleines Rechenprogramm: Es nimmt zwei ganze Zahlen entgegen und gibt +# Summe, Differenz, Produkt und Quotient aus. + +erste_zahl = int(input("Gib eine ganze Zahl ein: ")) +zweite_zahl = int(input("Gib noch eine ganze Zahl ein: ")) + +print("Summe: ", erste_zahl + zweite_zahl) +print("Differenz: ", erste_zahl - zweite_zahl) +print("Produkt: ", erste_zahl * zweite_zahl) +print("Quotient: ", erste_zahl / zweite_zahl) + +# f-strings sind bequem, um Text und Werte zu mischen: +print(f"{erste_zahl} geteilt durch {zweite_zahl} ist {erste_zahl / zweite_zahl}") diff --git a/Code/variablen.py b/Code/variablen.py new file mode 100644 index 0000000..2fd9e51 --- /dev/null +++ b/Code/variablen.py @@ -0,0 +1,5 @@ +beschreibung = "wundervoll" + +print(f"Hallo, mein Tag war {beschreibung}!") +print(f"ich habe {beschreibung} aus einem skript gelernt.") +print(f"Ich hoffe dir geht es genauso {beschreibung}") diff --git a/Code/variablen_aendern.py b/Code/variablen_aendern.py new file mode 100644 index 0000000..3ae0c77 --- /dev/null +++ b/Code/variablen_aendern.py @@ -0,0 +1,23 @@ +# Ein Programm ist eine Folge von Anweisungen, die von oben nach unten +# abgearbeitet werden - keine Sammlung mathematischer Aussagen. + +zaehler = 0 # Lasse zaehler zuerst den Wert 0 haben. +zaehler = zaehler + 1 # Nimm den aktuellen Wert (0), addiere 1, speichere zurueck. +zaehler = zaehler + 1 # Und noch einmal: aus 1 wird 2. + +print("zaehler ist jetzt:", zaehler) + +# Mathematisch ergibt "zaehler = zaehler + 1" keinen Sinn. +# Als Anweisung gelesen heisst es: "Der Name links soll ab jetzt den +# Wert der rechten Seite tragen." + +# Eine Variable kann im Laufe des Programms ihren Wert - und sogar ihre +# Art von Wert - wechseln: +inhalt = "ein Text" +print(inhalt, "->", type(inhalt)) + +inhalt = 42 +print(inhalt, "->", type(inhalt)) + +inhalt = 3.5 +print(inhalt, "->", type(inhalt)) diff --git a/Lektionen/variablen_aritmetik.typ b/Lektionen/variablen_aritmetik.typ new file mode 100644 index 0000000..1019c4c --- /dev/null +++ b/Lektionen/variablen_aritmetik.typ @@ -0,0 +1,206 @@ +#import "../lib/helpers.typ": * + +== Variablen und Arithmetik + +Bisher haben unsere Programme immer exakt das Gleiche getan. Wir haben Text ausgegeben, und dieser Text stand fest im Quellcode. In dieser Lektion geben wir unseren Programmen ein Gedächtnis: Wir lernen, Werte unter einem Namen zu speichern, sie später wieder abzurufen und mit ihnen zu rechnen. Damit ist der Schritt von einer starren Ausgabe zu einem Programm getan, das auf Eingaben reagiert und etwas ausrechnet. + +#Theorie[ + === Was ist eine Variable? + + Stell dir ein beschriftetes Schließfach vor. Auf dem Schild steht ein Name, im Fach liegt ein Inhalt. Wenn du den Namen nennst, meinst du eigentlich den Inhalt. Genau das ist eine *Variable*: ein Name, unter dem ein Wert abgelegt ist. + + Die Ablage geschieht durch ein Gleichheitszeichen. Der Name steht links, der Wert rechts: + + ```python + beschreibung = "wundervoll" + ``` + + Ab dieser Zeile ist es im Programm so, als stünde überall dort, wo `beschreibung` geschrieben wird, das Wort `"wundervoll"`. Das ist praktisch, wenn derselbe Wert an mehreren Stellen gebraucht wird – ändern wir ihn an einer Stelle, ändert er sich überall. + + Das folgende Programm erzählt von seinem Tag. Führe es aus und schau dir die Ausgabe an. +] + +#Code("variablen.py") + +#Theorie[ + === Das Gleichheitszeichen ist keine Gleichung + + In der Mathematik bedeutet `=` „beide Seiten sind gleich“. In Python bedeutet `=` etwas anderes: *„Der Name auf der linken Seite soll ab jetzt den Wert der rechten Seite tragen.“* Es ist eine *Zuweisung*, kein Vergleich. + + Der Unterschied wird bei einer Zeile wie dieser deutlich: + + ```python + zaehler = zaehler + 1 + ``` + + Als Gleichung gelesen ist das Unsinn. Als Anweisung gelesen ist es klar: Nimm den aktuellen Wert von `zaehler`, addiere 1 dazu, und speichere das Ergebnis wieder unter dem Namen `zaehler`. + + Das liegt daran, dass ein Programm eine *Folge von Anweisungen* ist, die von oben nach unten abgearbeitet wird – keine Sammlung von Aussagen, die alle gleichzeitig gelten. Der Wert einer Variable kann sich im Laufe des Programms also ändern. + + === Datentypen + + Jeder Wert hat einen *Datentyp* – eine Art von Wert. `"wundervoll"` ist ein Text (in Python `str`, von _string_, „Zeichenkette“). `42` ist eine ganze Zahl (`int`, von _integer_). `3.5` ist eine Kommazahl (`float`). Der Typ ist wichtig, weil Python mit verschiedenen Typen unterschiedlich umgeht: Zwei Zahlen kann man multiplizieren, zwei Texte nicht sinnvoll. + + Anders als in vielen anderen Sprachen musst du den Typ in Python *nicht* vorab hinschreiben. Python erkennt ihn automatisch am Wert. Mit der Funktion `type()` kannst du nachfragen, welchen Typ ein Wert gerade hat. +] + +#Code("variablen_aendern.py") + +#Praxis[ + + Weise `beschreibung` in `variablen.py` ein anderes Wort zu und führe das Programm erneut aus. Was ändert sich in der Ausgabe? + + + Definiere in `variablen.py` eine zweite Variable (zum Beispiel `wetter = "sonnig"`) und schreibe mit ihr einen weiteren `print()`-Satz. + + + Schreibe ein Programm, das eine Variable `alter` auf einen Wert setzt, sie dann in mehreren Schritten verändert (`alter = alter + 1`) und nach jedem Schritt ausgibt. +] + +=== Eingaben von der Nutzerin + +#Theorie[ + Ein Programm wird erst dann wirklich nützlich, wenn es mit einer Nutzerin interagiert. Ausgaben kennen wir schon: `print()`. Für Eingaben gibt es die Funktion `input()`. + + ```python + name = input("Wie heißt du? ") + ``` + + `input()` hält das Programm an, zeigt den Text in den Klammern an und wartet, bis die Nutzerin etwas eintippt und Enter drückt. Das Eingetippte wird dann unter dem Namen links vom `=` gespeichert. + + *Der wichtigste Stolperstein dieser Lektion:* `input()` liefert das Eingegebene *immer als Text* (`str`) zurück – auch dann, wenn die Nutzerin eine Zahl eingetippt hat. Der Text `"12"` und die Zahl `12` sind für Python zwei verschiedene Dinge. + + Warum ist das ein Problem? Das `+`-Zeichen bedeutet für zwei Texte „hänge sie aneinander“. Die Eingaben `"12"` und `"3"` ergeben mit `+` also `"123"`, nicht `15`. + + Um mit einer Eingabe zu rechnen, musst du sie erst umwandeln: + + - `int("12")` macht aus dem Text die ganze Zahl `12` + - `float("3.5")` macht aus dem Text die Kommazahl `3.5` +] + +#Code("eingabe_zahlen.py") + +#Praxis[ + + Schreibe ein Programm, das nach dem Namen fragt und anschließend `Hallo, !` ausgibt. + + + Erweitere es: Frage zusätzlich nach dem Geburtsjahr, wandle die Eingabe mit `int()` um und gib aus, wie alt die Person dieses Jahr wird. + + + Was passiert, wenn du bei der Umwandlung mit `int()` keinen Zahlentext, sondern `"hallo"` eingibst? Lies die Fehlermeldung. +] + +=== Rechnen: Arithmetik + +#Theorie[ + Mit Zahlen können wir rechnen. Python versteht die Rechenausdrücke, die du aus der Schule kennst: + + - `+` — Addition + - `-` — Subtraktion + - `*` — Multiplikation + - `/` — Division + - `//` — Ganzzahl-Division (schneidet den Rest ab) + - `%` — Rest der Division („modulo“) + - `**` — Potenz (`a ** b` ist „a hoch b“) + + „Punkt vor Strich“ gilt wie gewohnt, und mit Klammern kannst du die Reihenfolge steuern: `(2 + 3) * 4` ergibt `20`. + + *Zwei Besonderheiten, an denen viele ins Straucheln geraten:* + + 1. `/` liefert in Python *immer* eine Kommazahl. `10 / 2` ergibt nicht `5`, sondern `5.0` (Typ `float`). Wenn du ein ganzzahliges Ergebnis willst, nutze `//`: `10 // 3` ergibt `3`. + + 2. `%` gibt den Rest an. `18 % 5` ist `3`, weil $18 = 3 dot 5 + 3$. Das ist überraschend nützlich, etwa um zu prüfen, ob eine Zahl gerade ist (`zahl % 2 == 0`). + + Eine angenehme Eigenschaft: Ganze Zahlen (`int`) haben in Python *keine Obergrenze*. `2 ** 200` rechnet Python ohne zu murren exakt aus. In vielen anderen Sprachen würde eine so große Zahl „überlaufen“. +] + +#Code("rechnen.py") + +#Theorie[ + Genauso können wir mit Zahlen rechnen, die die Nutzerin eingibt – vorausgesetzt, wir wandeln die Eingabe vorher mit `int()` um. +] + +#Code("rechner_eingabe.py") + +#Praxis[ + + Schreibe ein Programm, das zwei ganze Zahlen entgegennimmt und Summe, Differenz, Produkt *und* Quotient ausgibt. + + + Was fällt auf, wenn du `19` und `7` eingibst? Schau dir den Quotienten genau an. + + + Erweitere das Programm um Ganzzahl-Division (`//`) und Rest (`%`). + + + Was passiert, wenn du als zweite Zahl eine `0` eingibst? Lies die Fehlermeldung – wie heißt der Fehler? +] + +#Spiel[ + + Wie groß ist die größte Zahl, die du in Python speichern kannst? Probier `2 ** 1000` aus. Vergleiche das mit dem, was du vielleicht über andere Programmiersprachen gehört hast. + + + Gib `0.1 + 0.2` aus. Kommt `0.3` heraus? Kommazahlen werden im Computer nur *näherungsweise* gespeichert – das ist normal und begegnet dir in jeder Programmiersprache. + + + Was passiert, wenn du dich im Namen einer Variable vertippst, etwa `print(beschreibnug)` statt `print(beschreibung)`? + + + Texte kann man „addieren“ und sogar „multiplizieren“: Probier `"ha" * 3` und `"Hallo " + "Welt"` aus. Was passiert bei `"Hallo" + 3`? + + + Statt `zaehler = zaehler + 1` gibt es die Kurzschreibweise `zaehler += 1`. Es gibt auch `-=`, `*=` und `/=`. Probier sie aus. +] + +=== Häufige Fehler und ihre Ursachen + +#Theorie[ + *`NameError: name 'x' is not defined`* + + Python kennt den Namen nicht. Meist ein Tippfehler im Variablennamen, oder die Variable wurde erst *nach* ihrer Verwendung zugewiesen. Groß- und Kleinschreibung zählt: `Alter` und `alter` sind zwei verschiedene Namen. + + *`TypeError: can only concatenate str (not "int") to str`* + + Du versuchst, einen Text und eine Zahl mit `+` zu verbinden. Häufig, weil eine `input()`-Eingabe noch Text ist. Lösung: die Zahl mit `int()` umwandeln, oder im `print()` ein Komma statt `+` verwenden, oder einen f-string nutzen: `print(f"Alter: {alter}")`. + + *`ZeroDivisionError: division by zero`* + + Du hast durch `0` geteilt. Durch null zu teilen ist mathematisch nicht definiert, deshalb bricht das Programm ab. In der nächsten Lektion lernst du, solche Fälle vorher abzufangen. + + *`ValueError: invalid literal for int() with base 10: 'hallo'`* + + Du hast `int()` einen Text gegeben, der keine Zahl ist. + + *Verwechslung von `=` und `==`* + + `=` weist zu, `==` vergleicht („sind diese beiden gleich?“). Diese Unterscheidung wird in der nächsten Lektion wichtig. +] + +#Quiz(answer: "a ist 8")[ + Was steht am Ende in `a`? + ```python + a = 5 + a = a + 3 + ``` + + a ist 8 + + a ist 5 + + Es gibt einen Fehler, weil `a = a + 3` keine gültige Gleichung ist + + a ist 53 +] + +#Quiz(answer: "5.0 (eine Kommazahl)")[ + Was gibt `print(10 / 2)` in Python aus? + + 5.0 (eine Kommazahl) + + 5 (eine ganze Zahl) + + 2.5 + + Einen Fehler +] + +#Quiz(answer: "Immer einen Text (str)")[ + Welchen Datentyp liefert `input()` zurück? + + Immer einen Text (str) + + Eine ganze Zahl, wenn eine Zahl eingegeben wurde + + Den Typ, der zum Eingegebenen passt + + Eine Kommazahl (float) +] + +#Quiz(answer: "b), c)")[ + Welche Aussagen über `%` (modulo) sind korrekt? + + `10 % 3` ergibt `3.33` + + `10 % 2 == 0` prüft, ob `10` gerade ist + + `18 % 5` ergibt `3` + + `%` funktioniert nur mit Kommazahlen +] + +#Theorie[ + === Ausblick + + Du kannst jetzt Werte speichern, Eingaben entgegennehmen und rechnen. Aufgefallen ist dir vielleicht, dass ein Programm bei einer Eingabe wie `0` als Divisor einfach abstürzt. In der nächsten Lektion, *Kontrollfluss*, lernst du, wie ein Programm abhängig von seinen Eingaben unterschiedliche Wege einschlägt – und solche Abstürze höflich abfängt. +] diff --git a/lib/helpers.typ b/lib/helpers.typ index 2931db3..388fe6b 100644 --- a/lib/helpers.typ +++ b/lib/helpers.typ @@ -89,13 +89,15 @@ stack( #let Quiz_answers = state("Quiz_answers", ()) +#let Quiz_counter = counter("quiz") -// Quiz is abit more complicated than the other environments +// Quiz is abit more complicated than the other environments #let Quiz(answer: "", body) = { - context { - let number = counter(heading).get().at(0) + Quiz_counter.step() + context { + let number = Quiz_counter.get().at(0) Quiz_answers.update(s => s + ((number, answer),)) - + [=== Quiz #number ] set enum(numbering: "a)") body diff --git a/main.typ b/main.typ index 3d7377f..bc20522 100644 --- a/main.typ +++ b/main.typ @@ -56,24 +56,11 @@ = Python -== Numpy - - - -#let codesnippet(path, name) = { - [#set align(center) - #text(gray, style: "italic")[ - #name]] - - rect(stroke: gray, width: 100%)[ - #raw(lang: "Python", read(path), block: true)] -} - +#include "Lektionen/helloworld.typ" -//#zebraw(raw(lang: "Python", code, block: true)) +#include "Lektionen/variablen_aritmetik.typ" - -#Code("helloworld.py") +== Numpy