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/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/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/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!"<", type(inhalt)) + +inhalt = 42 +print(inhalt, "->", type(inhalt)) + +inhalt = 3.5 +print(inhalt, "->", type(inhalt)) diff --git a/Lektionen/helloworld.typ b/Lektionen/helloworld.typ new file mode 100644 index 0000000..4862b14 --- /dev/null +++ b/Lektionen/helloworld.typ @@ -0,0 +1,116 @@ +#import "../lib/helpers.typ": * + +== Lektion 1: Hello World + +#Theorie[ + === Was ist eine Programmiersprache? + + Ein Computer versteht eigentlich nur Maschinencode – eine Abfolge von 0en und 1en. Eine Programmiersprache ist eine formale Sprache, die es Menschen ermöglicht, Anweisungen so zu schreiben, dass ein Computer sie verstehen _kann_. Sie ist ein Übersetzungssystem: Du schreibst in einer für Menschen lesbaren Syntax auf, was der Computer tun soll, und ein Programm (der Interpreter oder Compiler) übersetzt deine Anweisungen in Maschinencode. + + === Warum Python? + + Es gibt Hunderte von Programmiersprachen. Python hat sich für Anfänger als ideal erwiesen, weil: + + 1. *Lesbarkeit:* Python-Code sieht dem Englischen ähnlich. `print(“Hallo”)` ist selbsterklärend, anders als etwa #Code("helloworld.cpp") oder #Code("helloworld.java") . + + 2. *Minimalistische Syntax:* Python erzwingt saubere Formatierung durch Einrückungen. Das führt zu besseren Gewohnheiten. + + 3. *Unmittelbare Feedback-Schleife:* Du kannst Code schreiben und ihn sofort ausführen. Keine langen Kompilierungsschritte. + + 4. *Breite Anwendung:* Datenanalyse, KI, Web-Backend, Automatisierung – Python ist überall. + + === Ausführung: Quellcode → Interpretation + + Wenn du eine Python-Datei ausführst, passiert folgendes: + + 1. *Quellcode:* Du schreibst lesbare Befehle in `helloworld.py`. Das ist _Text_ – noch keine Anweisung für die CPU. + + 2. *Interpreter:* Python liest deine Datei zeilenweise. Für jede Zeile: + - Prüft Python die Syntax (ist die Syntax korrekt?) + - Übersetzt Python den Befehl in interne Anweisungen + - Führt Python den Befehl aus + + 3. *Ausführung:* Wenn Python `print(“Hallo Welt!”)` liest, sagt es der Konsole: “Gib diesen Text aus.” Die Konsole druckt es. + + 4. *Output:* Du siehst das Ergebnis. + + _Wichtig:_ Python ist eine *interpretierte* Sprache. Das bedeutet: Jedes Mal, wenn du das Programm startest, wird es neu interpretiert. (Das unterscheidet sich von *kompilierten* Sprachen wie C++, die einmal übersetzt werden und dann direkt laufen.) + + === Das “Hello World”-Ritual + + “Hello World” ist die Tradition in der Informatik. Es ist nicht wegen der Aufgabe wichtig, sondern weil es das Fundamental-Konzept demonstriert: *Du kannst dem Computer befehlen, etwas zu tun, und er tut es.* + + Das ist der Kern des Programmierens. +] + +#Praxis[ + Erstelle eine neue Datei namens `helloworld.py` und schreibe folgende Zeile: + + ```python + print(“Hello World!”) + ``` + + Speichere und führe das Programm aus. Die Ausgabe sollte sein: `Hello World!` +] + +#Code("helloworld.py") + +=== Anatomie des Befehls + +#Theorie[ + Der `print()`-Befehl zerlegt sich in drei Teile: + + 1. *Funktionsname:* `print` – der Name der Funktion, die wir aufrufen. Funktionen sind wiederverwendbare Bausteine, die eine spezifische Aufgabe erfüllen. Hier: Text in die Konsole schreiben. + + 2. *Klammern:* `()` – sie umschließen die _Argumente_ (die Eingaben für die Funktion). `print()` ohne Argumente würde eine leere Zeile drucken. + + 3. *Argument:* `”Hello World!”` – der String (Zeichenkette), den wir ausgeben möchten. Die Anführungszeichen sind syntaktisch erforderlich; sie teilen Python mit, dass es sich um Text handelt, nicht um Code. + + _Grundregel:_ Python unterscheidet Groß- und Kleinschreibung. `print` ist korrekt, `Print` führt zu einem Fehler. +] + + +#Spiel[ + Ihr könnt nun versuchen, den Quellcode selbst zu verändern und damit ein wenig herumzuspielen. Öffnet dazu einen Editor und öffnet die Datei. Denkt daran, nach jeder Änderung die Datei zu speichern und im Terminal neu auszuführen. + + Dinge, die ihr ausprobieren könntet sind zum Beispiel: + + - Was passiert, wenn ihr „Hello world!" in etwas anderes ändert? + - Was passiert, wenn ihr die Anführungszeichen löscht? + - Was passiert, wenn ihr zwei `print()`-Befehle hintereinander schreibt? + - Wie könnte man mehrere Sätze in einer Zeile ausgeben? + + Experimentiert! Das Schöne an Python ist, dass ihr sofort Feedback bekommt, wenn etwas schiefläuf +] +#Quiz(answer: "Das andere wird ausgegeben" )[Was passiert, wenn ihr Hello world durch etwas anderes ersetzt? ++ Das andere wird ausgegeben ++ Es gibt einen Fehler ++ Das Programm tut garnichts mehr ++ Das Programm gibt trotzdem Hello world aus +] + +=== Häufige Fehler und ihre Ursachen + +#Theorie[ + Wenn dein Programm nicht läuft, liegt es an einer dieser Syntaxfehler: + + *Fehler 1: Fehlende oder falsche Anführungszeichen* + ```python + print(Hallo Welt!) # SyntaxError – kein String definiert + print(“Hallo Welt!”) # Korrekt + ``` + + *Fehler 2: Falsche Großschreibung* + ```python + Print(“Hallo Welt!”) # NameError – Python kennt Print nicht + print(“Hallo Welt!”) # Korrekt + ``` + + *Fehler 3: Falsche Klammer-Typen* + ```python + print[“Hallo Welt!”] # SyntaxError – eckige Klammern sind für Listen + print(“Hallo Welt!”) # Korrekt – runde Klammern für Funktionen + ``` + + Diese Fehler sind typisch – sie passieren jedem. Der Schlüssel ist, die Fehlermeldung zu lesen. Python teilt dir präzise mit, was schiefgelaufen ist. +] \ No newline at end of file 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 9614250..388fe6b 100644 --- a/lib/helpers.typ +++ b/lib/helpers.typ @@ -52,26 +52,52 @@ let content = { // Remove trailing newline if (raw_c.last() == "\n") { str.slice(raw_c, 0, -1) - - + + } else {raw_c} } +let ext-to-lang(ext) = { + let mapping = ( + "py": "Python", + "cpp": "C++", + "java": "Java", + "js": "JavaScript", + "ts": "TypeScript", + "rs": "Rust", + "go": "Go", + "rb": "Ruby", + "php": "PHP", + "c": "C", + "h": "C", + "hpp": "C++", + ) + mapping.at(ext, default: "") +} -zebraw(raw(lang: "Python", content, block: true)) +let ext = path.split(".").last() +let lang = ext-to-lang(ext) + +stack( + if lang != "" {text(size: 0.85em, weight: "bold", fill: gray)[#lang]} else [], + zebraw(raw(lang: lang, content, block: true)), + spacing: 0.3em +) } #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