· handout

Welcome to the Python pre-course. Scan the code in the corner to open the slides on your own device: you can follow along, move at your own pace, and the sync button brings you back to where we are.

Kurz vorstellen, bevor die Runde dran ist: Name, Studiengang, und wie das mit dem Programmieren angefangen hat. Der Weg auf der rechten Seite ist der eigentliche Punkt – angefangen mit Minecraft-Mods im Lockdown, ohne Vorwissen, und der Rest kam Stück für Stück. Das nimmt die Angst vor der Frage, ob man dafür ein Genie sein muss. Kurz halten: eine Minute, höchstens zwei, dann sind die anderen dran.

Reihum: Name sagen, kurz vorstellen – Hobbys, etwas Schräges oder Besonderes, etwas Nettes über sich. Dann dreht die Person auf dem eigenen Handy die Frage; der Beamer zeigt, wer gedreht hat und welche Frage kam. Ohne Handy: Spin im Presenter oder auf der Fernbedienung. Keine Frage kommt doppelt, bis alle einmal dran waren. Den Beamer über den Projektor-Knopf der Startseite öffnen, sonst zeigt er selbst einen Drehen-Knopf. Selbst anfangen hilft.

Momo steht vor ihrer Haustür. Manchmal hat sie den Schlüssel dabei, manchmal nicht. Frag die Gruppe: Was passiert in beiden Fällen? Erst sammeln, dann weiter.

Gleiche Situation, ein Unterschied. Beide Katzen laufen los. Mit Schlüssel geht die Tür auf und Momo ist drin. Ohne Schlüssel bleibt die Tür zu und Momo schläft davor. Eine Frage, zwei Wege.

Jetzt schreiben wir genau das auf. if steht vor der Frage, else vor dem anderen Weg. Alles andere ist ganz normales Deutsch. Fahr mit der Maus über ein Wort im Code, dann leuchtet es im Bild auf.

Und jetzt als echtes Python. Oben unser Plan, unten derselbe Plan, den der Computer ausführen kann. if und else bleiben gleich, die Frage wird zu einer Variablen hat_schluessel, und was Momo tut, wird zu print. Ändere True zu False und frag: Was steht jetzt da?

print kennen wir schon von Momo, jetzt kurz in Ruhe: In die Klammern kommt das, was auf dem Bildschirm landen soll. Text braucht Anführungszeichen – sonst sucht Python einen Namen und findet nichts. Zwei prints, zwei Zeilen: von oben nach unten, eins nach dem anderen.

Zahlen kommen ohne Anführungszeichen. Der Unterschied ist echt: 7 + 3 rechnet Python aus und zeigt 10, "7 + 3" ist Text und bleibt stehen, wie es dasteht. Frag die Gruppe vorher, was bei den beiden Zeilen herauskommt – das sitzt danach.

Die dritte Sorte: True und False, Pythons Ja und Nein. Groß geschrieben, ohne Anführungszeichen. Auf 10 > 3 antwortet Python selbst mit True – genau das haben wir bei Momos Schlüssel schon benutzt. Und: Mehrere Werte in einem print, mit Komma getrennt, Python setzt Leerzeichen dazwischen. Die Namen für die Sorten kommen gleich bei den Variablen, hier reicht: Text, Zahl, Ja/Nein.

Jetzt selbst ausprobieren. Die Vorführung zeigt den Weg: suchen, Online-Compiler öffnen, Code einfügen, Run. Wer mag, scannt den Code. Aufgabe: den Text im print ändern, zum Beispiel in den eigenen Namen, und nochmal Run drücken. Enter zeigt die Vorführung nochmal.

Erinnerung an print("Hallo Welt!"). Jetzt kommt der Text in eine Box. Name links, Wert rechts, das = heißt: leg das hier hinein.

print(gruss) ohne Anführungszeichen: Python schaut in die Box. Frag: Was würde mit Anführungszeichen ausgegeben? Genau, das Wort gruss.

Gleiche Box, neuer Inhalt. Der alte Wert ist weg. Zwei prints, zwei Ausgaben, jeweils mit dem Wert, der gerade drin ist.

Vier Typen für den Anfang: str, int, float, bool. Anführungszeichen machen den Unterschied zwischen "3" und 3. type() verrät den Typ.

Rechte Seite zuerst: alter + 1 ergibt 4, das kommt zurück in alter. += ist die Kurzform. Am Ende steht 5 in der Box.

f-Strings: ein f vor die Anführungszeichen, Variablen in geschweifte Klammern. Python setzt die Werte ein.

input() gibt immer Text zurück, auch wenn jemand eine Zahl tippt. Mit int() umwandeln, sonst gibt "5" + 1 einen Fehler.

Namensregeln. Groß und klein zählt: alter und Alter sind zwei verschiedene Boxen, darum gibt print(alter) die 3 aus.

Für den Kurs brauchen wir PyCharm auf dem eigenen Rechner. Browser auf, pycharm download eintippen – genau das, was alle eintippen würden – und Suchen drücken. Dann das Ergebnis von jetbrains.com anklicken, keine Anzeigen und keine Download-Portale. Die Seite öffnet oben mit PyCharm Professional – das ist nicht die, die wir wollen. Nicht den ersten Download-Knopf drücken. Weiter nach unten scrollen, bis PyCharm Community Edition kommt. Die ist kostenlos und reicht für den ganzen Kurs. Unter Community Edition auf Download drücken und die Datei öffnen. Windows lädt eine .exe, macOS eine .dmg, Linux ein .tar.gz. Den Installer mit den Standardeinstellungen durchklicken. Enter zeigt die Vorführung nochmal.

Jetzt arbeiten alle selbst. QR-Code scannen oder pycharm download suchen, runterscrollen zur Community Edition, herunterladen und installieren. Herumgehen und bei Betriebssystem-Warnungen helfen. Ziel: PyCharm lässt sich öffnen. Wer fertig ist, hilft der Person daneben.

Der ganze Weg in einer Vorführung: „Los geht’s“ drücken, dann läuft sie am Stück. New Project, Name eintragen, Interpreter type bleibt Project venv, bei Python version muss etwas stehen – ist die Liste leer, fehlt Python: QR-Code links scannen, unter Windows „Add python.exe to PATH“ anhaken, PyCharm neu starten. Create legt Ordner und .venv an. Dann Rechtsklick auf den Projektordner, New, Python File, Namen eintippen, Enter; die .py-Endung kommt von PyCharm. print("Hallo Welt!") tippen, auf Anführungszeichen und Klammern achten, speichern muss man nicht. Oben der grüne Pfeil, unten erscheint Hallo Welt! und exit code 0. Danach rumgehen: Läuft das bei allen? Aufgabe: den Text ändern und nochmal ausführen. Enter oder der Knopf zeigt alles nochmal.

Bei Momos Tür stand hat_schluessel schon auf True – wir haben es selbst hingeschrieben. Woher kommt so ein True in echt? Aus einer Frage. 10 > 3 ist keine Rechnung, sondern eine Frage, und Python antwortet mit True. Erst fragen lassen: Was kommt bei 3 > 10 heraus?

Sechs Vergleiche, mehr sind es nicht. Größer, kleiner, und die beiden mit dem Gleichheitszeichen dahinter: größer oder gleich, kleiner oder gleich. Dann == für „ist dasselbe“ und != für „ist etwas anderes“. Der wichtigste Satz der ganzen Folie: Ein = legt etwas in eine Box, zwei == stellen eine Frage. Das verwechseln alle einmal, und Python sagt dann SyntaxError. Kurz warten lassen, bis es sitzt.

Und jetzt zusammen: Die Frage kommt direkt hinter das if. Bei Momo stand da eine fertige Variable, hier steht die Frage selbst. Python rechnet erst die Frage aus – alter >= 18 wird zu True – und schaut dann, ob es True ist. Der Doppelpunkt und die Einrückung sind wie gehabt.

else kennen wir von der Tür: der andere Weg. Neu ist elif – wenn die erste Frage Nein war, stell die nächste. Python geht von oben nach unten und nimmt den ersten Weg, der passt; der Rest wird nicht mal angeschaut. Frag: Was passiert bei 95, wenn die erste Frage >= 50 wäre? Dann käme nie jemand zu „sehr gut“.

not dreht die Antwort um: aus True wird False und umgekehrt. Praktisch, wenn man auf das Gegenteil reagieren will – not hat_schluessel liest sich wie „hat keinen Schlüssel“. Man kommt fast immer auch ohne not aus, aber manchmal ist es einfach die Zeile, die man laut vorlesen kann.

Zwei Fragen auf einmal. and will beide: nur wenn links und rechts True sind, kommt True heraus. or reicht eine von beiden. Zum Merken: and ist streng, or ist großzügig. Mit der Gruppe die vier Fälle durchgehen, das geht schneller als jede Erklärung.

Alles in einem kleinen Programm. Zeile für Zeile vorlesen lassen, dann laufen lassen. Aufgabe für zwischendurch: Ändert das Alter und das Ticket und sagt vorher, was herauskommt. Damit ist alles da, was wir gleich bei den Listen brauchen.

Halbzeit-Pause. Bis hier: print, Variablen, Vergleiche, if – ab jetzt baut alles darauf auf. „Noch Fragen?“ bringt nichts, deshalb stehen drei konkrete Fragen auf der Folie. Selbst kurz warten, ruhig zehn Sekunden. Wer nichts sagen will, kann auch zum Nachbarn fragen.

Momo hat fünf Fische gefangen, jeder mit seiner Länge. Mit dem, was wir kennen, sind das fünf Variablen. Frag: Was machen wir bei 100 Fischen? 100 Zeilen, 100 Namen – das will niemand.

Die fünf Boxen rücken zusammen und werden ein Korb mit Fächern. Ein Name für alle, und die Reihenfolge bleibt erhalten. Noch kein Python, erst die Idee.

In Python ist der Korb eine Liste: eckige Klammern außen, Kommas zwischen den Werten. print(fische) zeigt die ganze Liste mit Klammern.

Jedes Fach hat eine Nummer, den Index, und Python fängt bei 0 an. Frag vorher: Was gibt fische[3] aus? Viele sagen 8 – es ist 21, der vierte Fisch.

fische[2] = 25 funktioniert wie bei einer Variablen, nur für ein Fach: der alte Wert fliegt raus, der neue kommt rein. len zählt die Fächer, nicht die Werte zusammen.

append hängt einen Wert hinten an, die Liste wird länger. Der neue Fisch bekommt Index 5, len ist jetzt 6. Frag: Welcher Index ist der letzte? Immer len minus 1.

append legt hinten an, jetzt der Weg zurück. pop() ohne Klammerinhalt nimmt den letzten und gibt ihn zurück – man kann ihn also noch benutzen. pop(0) nimmt den ersten, und alle anderen rutschen eine Stelle nach vorne: aus Index 1 wird 0. remove sucht nach dem Wert statt nach der Stelle und wirft den ersten Treffer raus. Wichtig: pop will eine Stelle, remove einen Wert.

Und in die Mitte: insert will zwei Sachen – wo, und was. insert(1, 40) schiebt alles ab Stelle 1 nach hinten und macht Platz. Frag vorher: Wie lang ist die Liste danach? Immer eins mehr. Zum Schluss der Überblick: hinten dran append, an einer Stelle insert, raus mit pop oder remove. Mehr braucht man am Anfang nicht.

Erstes Rätsel, und gleich im Advent-of-Code-Stil: Jedes Gerät bekommt eine eigene Preisliste. Kopieren, in PyCharm die drei ersten Preise addieren, die Zahl hier abschicken. Teil 2 sind die letzten drei – da lohnt sich preise[-1]. Oben rechts erscheint, wer fertig ist; wer weiterblättert, findet das Rätsel unten rechts wieder.

Drei Fische, welcher ist der längste? Wir sehen es sofort an den Balken. Frag: Wie würdet ihr das dem Computer mit if erklären? Erst Ideen sammeln.

Mit if und elif geht es: für jeden Fisch prüfen, ob er länger als alle anderen ist. Die Vergleiche erscheinen rechts, der erste scheitert, der zweite passt. Bei drei Fischen ist das noch okay.

Jetzt sechs Fische. Jede Bedingung muss mit allen anderen vergleichen: das Gitter zeigt jedes Paar, 30 Vergleiche. Der Code hat schon drei Blöcke und es fehlen noch drei.

Hundert Fische: 9 900 Vergleiche. Und jeder neue Fisch heißt Code umschreiben. So nicht. Kurz wirken lassen.

Wie machen wir es selbst im Kopf? Einmal durchgehen und den längsten bisher merken. Momo läuft einmal am Korb entlang, bei der 30 tauscht sie, sonst nicht. Sechs Fische, sechs Blicke. Das ist eine Schleife – nächstes Thema.

Wir wollen jeden Fisch ausgeben. Mit dem, was wir kennen: fünf print-Zeilen, die fast gleich aussehen. Frag: Was ändert sich von Zeile zu Zeile? Nur die Nummer.

Die Idee aus dem letzten Kapitel: Momo läuft einmal am Korb entlang. Bei jedem Fisch landet der Wert in der Box fisch, oben zählt der Durchlauf mit, rechts erscheint die Ausgabe.

Genau so in Python: for fisch in fische, Doppelpunkt, darunter eingerückt, was pro Fisch passiert. Den Namen fisch dürfen wir frei wählen. Mit der Maus über fisch im Code fahren, dann leuchtet die Box.

Wichtigster Stolperstein: Einrückung. Eingerückt gehört zur Schleife und läuft fünfmal. print("fertig") ist nicht eingerückt und läuft einmal danach. Frag: Was passiert, wenn wir fertig einrücken?

Unterwegs etwas sammeln. gesamt startet vor der Schleife bei 0, in jedem Durchlauf kommt ein Fisch dazu. print steht wieder außerhalb, sonst würde jede Zwischensumme ausgegeben.

Zurück zum Problem mit den sechs Fischen. Jetzt mit Schleife: laengster startet mit dem ersten Fisch. Momo läuft durch, bei jedem Fisch die Frage: länger als laengster? Nur bei der 30 ist die Antwort ja, dann wird getauscht.

Gleiches Muster, andere Frage: Wie viele sind länger als 14? Ein Zähler startet bei 0, bei jedem Ja kommt 1 dazu. Die kleinen Fische treten zurück. Frag vorher: Was kommt raus? Vier.

Statt zählen sammeln: eine leere Liste, und append im if. Die großen Fische landen im neuen Korb. Das ist das Muster Filtern, das wir ständig brauchen, später auch mit Daten.

Links die if-Kette von vorhin, rechts die Schleife. Die Kette wächst mit jedem Fisch, die Schleife bleibt fünf Zeilen, egal wie lang die Liste ist. Genau deshalb sind Schleifen so wichtig.

Momo soll fünfmal springen. Es gibt keine Liste, also tippen wir eine: 0, 1, 2, 3, 4. Frag: Und wenn sie 100-mal springen soll?

range(5) macht die Zahlenreihe für uns. Wichtig: Sie startet bei 0 und hört vor der 5 auf. Fünf Zahlen, aber die 5 ist nicht dabei – der gestrichelte Pfosten.

Drei Zahlen in range: wo es losgeht, vor welcher Zahl es aufhört, wie groß der Schritt ist. Die Pfosten bleiben, nur die Nummern ändern sich. Frag: Wie bekommen wir 10, 20, 30?

Mit i rechnen: Jede Runde i mal 7, die Balken wachsen mit. Zwei Zeilen Code für eine ganze Einmaleins-Reihe. Aufgabe zum Mitdenken: Was ändern wir für die 9er-Reihe bis 10?

Neue Situation: Momo frisst, bis sie satt ist. Frag: Wie viele Bissen? Kommt drauf an. Bei for wissen wir vorher, wie oft. Bei while gibt es nur eine Frage, die vor jedem Bissen gestellt wird.

Der Hebel ist die Bedingung bauch < 12. Vor jedem Durchlauf wird sie geprüft: 0, 4, 8 sind kleiner als 12, also frisst Momo. Bei 12 ist sie falsch, der Hebel kippt, und print("Satt!") läuft.

Der häufigste while-Fehler: Die Variable in der Bedingung ändert sich nie. Dann ist die Bedingung für immer wahr, wie Bello, der seinen Schwanz jagt. In PyCharm mit dem roten Quadrat stoppen. Das passiert jedem mal.

while True läuft absichtlich für immer, und break ist der Notausgang. Ratespiel: 3 falsch, 9 falsch, 7 richtig, break. Gut, wenn man nicht weiß, wie viele Versuche jemand braucht.

continue ist das Gegenstück: nicht aufhören, sondern diesen Durchlauf abbrechen und mit dem nächsten weitermachen. Der faule Fisch wird übersprungen, die anderen isst Momo. Funktioniert in for und while.

Schleifen gehen nicht nur über Listen. Ein Text besteht aus Buchstaben, also läuft for auch da durch. Frag: Was gibt for buchstabe in "Hallo" aus?

Eine Schleife in einer Schleife: Die äußere zählt die Zeilen, die innere die Spalten. Die innere läuft für jede Zeile komplett durch. So funktionieren Tabellen, Bilder und Spielfelder.

Text mal Zahl wiederholt den Text. Mit i als Anzahl wird jede Zeile länger. Frag: Wie bekommen wir das Dreieck andersherum?

Simulation heißt: Wir rechnen Schritt für Schritt aus, wie sich etwas entwickelt. Hier Geld mit 10 Prozent Zinsen. Das gleiche Muster steckt in Wettermodellen, Physik und beim Training von KI-Modellen – Runde für Runde.

Rätsel-Runde zu Schleifen, zwei Aufgaben. Hier: Bellos Schrittzähler, 40 Tage. Teil 1 zählt die Tage über 10000 – Schleife, if, Zähler. Teil 2 will den längsten Lauf am Stück: der Zähler muss bei einem schwachen Tag wieder auf 0. Danach kommt Momos Fang, dann die Lösung.

Erstes Rätsel im Advent-of-Code-Stil. Jedes Gerät bekommt eine eigene Fischliste: kopieren, in PyCharm lösen, nur die Zahl abschicken. Teil 1 zählt Fische ab 20 cm, Teil 2 öffnet sich nach Teil 1: Momo frisst der Reihe nach, bis 300 cm nicht mehr passen – break. Oben rechts erscheint, wer gelöst hat. Wer weiterblättert, findet das Rätsel unten rechts wieder.

Die Lösung im Ganzen: oben Teil 1, unten Teil 2. Wir spielen sie mit der Beispielliste durch. Enter spielt eine Stufe nochmal ab.

Die Kamera fährt auf Teil 1. Mitlesen: Zeile 5 holt den nächsten Fisch, Zeile 6 prüft, Zeile 7 zählt nur bei True. Am Ende steht 3 in der Ausgabe.

Teil 2 mit einem kleinen Bauch von 50 cm, damit es schnell geht. Wichtig ist Zeile 14: erst prüfen, ob der Fisch noch passt, dann addieren. Bei 37 + 20 ist Schluss, break springt raus, Ausgabe 2.

Zurück zum Ganzen. Mit der eigenen Liste und 300 statt 50 kommen die eigenen Antworten heraus. Wer noch nicht fertig ist: unten rechts ist das Rätsel weiter offen.

Neues Kapitel. Drei Tiere, jedes wird begrüßt und frisst etwas. Dafür kopieren wir zwei Zeilen dreimal und ändern Name und Futter. Frag: Was ist daran unpraktisch?

Jetzt eine kleine Änderung: frisst gern. Zwei Kopien schaffen wir, die dritte vergessen wir. Genau so entstehen echte Bugs, wenn Code kopiert wird.

Die Idee: Die zwei Zeilen einmal als Rezept aufschreiben, mit Lücken für Tier und Futter. Dann nur noch das Rezept aufrufen und die Lücken füllen. Ändern müssen wir nur noch an einer Stelle.

In Python heißt das Rezept Funktion und wird mit def geschrieben. tier und futter sind Parameter, die Lücken. Beim Aufruf wandern die Werte in die Funktion – die Bälle. Erst der Aufruf führt den Code aus, def allein tut nichts.

Was passiert bei einem Aufruf genau? Der rote Punkt zeigt, wo Python gerade ist: Zeile 1, dann der Aufruf, rüber in die Funktion, zurück, weiter mit Zeile 4. Frag vorher: In welcher Reihenfolge erscheinen die Ausgaben?

Die Funktion als Maschine. Oben kommen Werte rein. x ist die Lücke und bekommt bei jedem Aufruf den Wert, der mitgegeben wird. Zweimal aufrufen, zweimal andere Ergebnisse.

Bisher hat die Funktion nur angezeigt. Mit return kommt das Ergebnis unten wieder heraus und kann in einer Variablen landen. Damit kann man weiterrechnen – so funktionieren auch len oder max.

Der häufigste Anfängerfehler: print statt return. Beide Maschinen zeigen scheinbar dasselbe, aber nur geben liefert etwas zurück. zeigen gibt None zurück – Python für: nichts.

Mehrere Parameter werden der Reihe nach gefüllt. Ein Standardwert springt ein, wenn beim Aufruf nichts mitgegeben wird. Frag: Was gibt fuettern("Hoppel", "Möhre") aus?

Funktionen sind wie Formeln aus der Schule: einmal aufschreiben, oft benutzen. Die Kreisfläche für drei Radien – der Kreis wächst, die Formel bleibt. Frag: Wie groß ist die Fläche bei r = 10?

Dieselbe Funktion, zweimal geschrieben. 3.14159 * r * r ist richtig und sagt nichts. Mit PI und quadrat steht in der Funktion wieder die Formel von der Tafel. Frag: Welche der beiden Zeilen würdet ihr in einem halben Jahr noch verstehen?

Umrechnen ist ein typischer Fall: Die Formel steckt in der Funktion, der Name sagt, was sie tut. 37 Grad Celsius sind 98,6 Fahrenheit – Körpertemperatur.

Woher kommt das 9 / 5 + 32? Mit dem Rautezeichen schreibt man eine Notiz für Menschen. Python liest die Zeile gar nicht – sie ist nur für die, die den Code später lesen. Auch hinter Code darf ein Kommentar stehen.

Zwei Parameter: Strecke und Zeit. Beide laufen 100 Meter, Bello ist doppelt so schnell. Die Reihenfolge der Argumente zählt: tempo(20, 100) wäre falsch.

Ein Aufruf darf im Aufruf stehen. Python rechnet von innen nach außen: erst die beiden Beschleunigungen, dann der Durchschnitt. Frag vorher: Was rechnet Python hier zuerst?

Die Faustformel aus der Fahrschule. Reaktionsweg und Bremsweg sind je eine kleine Funktion, anhalteweg addiert nur noch. Die Balken zeigen: doppeltes Tempo, mehr als dreifacher Weg. Das ist der Bauplan für alles Größere – kleine Funktionen, die andere benutzen.

Rätsel zu Mathe und Physik. Zwei Listen: Strecke und Zeit für 30 Läufe. Teil 1 zählt die Läufe über 5 m/s, Teil 2 addiert deren Strecken. Geht ohne Funktion, mit range(len(strecken)) – aber wer sich tempo(strecke, zeit) schreibt, liest die Schleife wie einen Satz. Genau das ist der Punkt: Funktionen machen die eigene Lösung lesbar.

Bisher gingen Zahlen rein und raus. Hier geht eine Liste rein: tier ist keine Kopie, sondern dieselbe Liste wie momo. Deshalb ist Momo nach dem Aufruf auch draußen satter. Und: Stelle 1 ist der Hunger, weil wir das festgelegt haben – genau das lösen später die Dictionaries.

Erste Code-Aufgabe: keine Zahl abschicken, sondern eine Funktion schreiben. Auf dem eigenen Gerät steht ein Editor, Python läuft direkt im Browser. Ausführen prüft die sichtbaren Tests, Abschicken zusätzlich einen versteckten. Achtung auf return statt print – genau daran scheitern die ersten Versuche. Danach die Rechteck-Funktion.

Erste Code-Aufgabe: Hier gibt es keine Zahl zum Abschicken, sondern eine Funktion. Auf dem eigenen Gerät steht ein Editor; Ausführen prüft die sichtbaren Tests, Abschicken zusätzlich zwei versteckte. Python läuft im Browser, ohne Internet. Wer lieber in PyCharm schreibt: Code hinüberkopieren und dann hier einfügen.

Rückblick: Den längsten Fisch haben wir mühsam mit einer Schleife gesucht. Das war nicht umsonst – so arbeitet max im Inneren. Aber Python bringt diese Funktionen schon mit.

sorted gibt eine neue Liste zurück, die alte bleibt, wie sie war. round mit zwei Stellen ist praktisch bei Geld und Messwerten, abs für Abstände.

Das kennen wir von input: Text zu Zahl mit int, Zahl zu Text mit str. type ist gut zum Nachschauen, wenn etwas nicht klappt – ist das jetzt Text oder Zahl?

enumerate, wenn man in der Schleife auch die Nummer braucht. zip, wenn zwei Listen zusammengehören, wie Namen und Futter. Beides spart Index-Rechnerei.

Texte haben Funktionen, die man mit Punkt aufruft: Methoden. split ist besonders wichtig, wenn man Daten aus Dateien liest. Es gibt viele mehr – help(str) zeigt alle.

Jede Funktion gibt etwas zurück, und das darf sofort weiter in die nächste. split macht Wörter, sorted ordnet sie, join klebt sie zusammen. Gelesen wird von innen nach außen – dasselbe wie bei den verschachtelten Aufrufen. Frag: Was passiert zuerst?

Rätsel zu den eingebauten Funktionen. Zwei Listen, die zusammengehören: Namen und Punkte. Teil 1 will den Namen mit den meisten Punkten – zip oder eine Schleife über die Stellen. Teil 2 die drei besten Punktzahlen zusammen, dafür ist sorted da. Die Antwort auf Teil 1 ist ein Name, Groß- und Kleinschreibung egal.

Niemand kennt alle Funktionen auswendig – nachschlagen gehört zum Handwerk. Eintippen, was man will, und das Ergebnis von docs.python.org nehmen, nicht das erste Blog. Dort stehen alle eingebauten Funktionen mit Beispiel. Enter zeigt die Vorführung nochmal.

Erst das Problem. Drei Katzen, je vier Angaben, alles Listen. Frag ins Publikum: Wie alt ist Luna? Sie müssen zählen. Und dann: Was steht an Stelle 3? Das weiß niemand mehr sicher. Genau da setzen die Dictionaries an.

Rückblick auf die Tier-Listen: momo[1] war das Alter, momo[3] ob sie hungrig ist. Frag: Wer weiß das noch, ohne nachzuschauen? Genau das ist das Problem.

Die Idee: Die Fächer bekommen Schilder mit Namen statt Nummern. Die Werte bleiben gleich, nur wie wir sie finden, ändert sich.

Geschweifte Klammern statt eckige. Links der Schlüssel, meistens ein Text, rechts der Wert. Lesen und ändern mit eckigen Klammern und dem Schlüssel. Das ist genau das Format, in dem später Daten aus dem Internet kommen.

Das häufigste Muster überhaupt: eine Liste, in der jedes Element ein Dictionary ist. Wie eine Tabelle: jede Zeile ein Tier, jede Spalte ein Schlüssel. Die Schleife liest ein Tier nach dem anderen.

Rätsel zu Dictionaries. Die Eingabe ist ein Dictionary: Name als Schlüssel, Alter als Wert. Teil 1 zählt alle Alter zusammen, Teil 2 sucht das älteste Tier – der Wert entscheidet, die Antwort ist der Schlüssel. Das älteste Tier ist immer eindeutig.

Neues Kapitel: Bibliotheken. Python bringt ein ganzes Regal an Modulen mit. Mit import holt man eins heraus und benutzt seine Funktionen mit Punkt: math.sqrt.

random kennen wir schon vom Würfeln. choice zieht aus einer Liste. Einmal ausführen lassen und vergleichen: Bei jedem kommt etwas anderes heraus.

Zwei Varianten: from math import sqrt holt nur eine Funktion. import statistics as st gibt einen Spitznamen – das sehen wir gleich bei numpy als np und pandas als pd, so schreibt das die ganze Welt.

Daten kommen oft aus einer Datei. open macht sie auf, read holt den ganzen Text. Das with schließt sie hinterher automatisch – ohne with vergisst man das close. Die Datei liegt neben der py-Datei im Projekt.

Eine offene Datei lässt sich wie eine Liste durchlaufen: Jeder Durchgang ist eine Zeile. strip schneidet den Zeilenumbruch ab, den man nicht sieht. Frag: Was passiert ohne strip? Dann steht zwischen den Namen eine Leerzeile.

Die großen Werkzeuge für KI und Daten sind nicht eingebaut, sondern Pakete. Installiert wird mit pip im Terminal von PyCharm: erst numpy allein, dann pandas und matplotlib in einem Befehl – mehrere Namen hintereinander gehen. Alles landet in der .venv des Projekts. Gemeinsam einmal ausführen.

Was macht import eigentlich? Ein Modul ist eine Kiste mit Werkzeug. import random holt die Kiste, benutzt wird sie mit dem Punkt. from random import randint legt ein einzelnes Werkzeug auf den Tisch – dann ohne Punkt. as np gibt der Kiste einen kurzen Namen, deshalb heißt es überall np und pd. Und der Hinweis unten: DataFrame(...) ist ein Bauplan, so etwas heißt Klasse – das kommt später.

Installiert ist installiert – benutzt wird ein Paket mit import. Hier random, das schon dabei war: würfeln, bis eine Sechs kommt. Genauso importierst du numpy, pandas und matplotlib, nur dass die vorher pip brauchten.

NumPy ist die Grundlage fast aller KI-Bibliotheken. Oben die Liste: Schleife, ein Wert nach dem anderen. Unten das Array: alles auf einmal. Bei Bildern mit Millionen Pixeln ist das der Unterschied zwischen Sekunden und Stunden.

pandas ist Excel in Python. Eine Tabelle aus einem Dictionary, und mit einer Bedingung filtern. Echte Daten kommen meist aus CSV-Dateien, das geht mit pd.read_csv.

Daten anschauen, bevor man damit rechnet. Drei Zeilen für ein Balkendiagramm, plt.show öffnet das Fenster. In PyCharm erscheint es als eigenes Fenster oder im SciView.

Zum Schluss ein Blick nach vorn. Bisher haben wir Funktionen selbst geschrieben. Hier geben wir nur Beispiele, und das Modell findet die Funktion y = 2x selbst. Genau das macht maschinelles Lernen, nur mit viel mehr Daten und Parametern.

Dasselbe für Pakete, die nicht von Python kommen: Name des Pakets, dann was man vorhat. Die offizielle Doku steht fast immer oben, und unten auf der Seite steht ein Beispiel zum Kopieren. Genau so arbeitet man sich in pandas, NumPy oder jede andere Bibliothek ein.

Letztes Rätsel: Schulmathe, aber programmiert. Teil 1 braucht den Durchschnitt – sum durch len – und dann eine zweite Runde durch die Liste. Teil 2 ist der größte Sprung von Tag zu Tag, mit abs, damit die Richtung egal ist. Wer mag, macht beides mit numpy in je einer Zeile; genau dafür sind die Bibliotheken da.

Letztes Kapitel: Programme, die mit anderen Programmen reden. Eine API ist wie ein Kellner: Wir bestellen, er bringt die Bestellung in die Küche und kommt mit der Antwort zurück. Wie die Küche arbeitet, ist uns egal.

In Python übernimmt das Paket requests die Rolle des Kellners, vorher pip install requests. get schickt die Anfrage an die Adresse. Der Status 200 heißt OK, 404 hieße: gibt es nicht.

Die Antwort ist Text im JSON-Format. Sieht aus wie ein Dictionary, und json() macht genau das daraus. Ab hier ist alles bekannt: Schlüssel lesen, Werte benutzen.

Die Folie fragt The Cat API wirklich. Neu ist: Die Studierenden holen die Katze selbst – auf dem eigenen Gerät steht ein Knopf, und alle Bildschirme zeigen dieselbe Katze und dieselbe Ausgabe. Ohne Handy geht es über den Knopf hier im Presenter oder auf der Fernbedienung. Braucht Internet am Laptop; ohne Netz bleibt die letzte Katze stehen.

Woher kam eigentlich die Adresse? Nach der API suchen, die Doku öffnen. Dort steht die Adresse, welche Optionen es gibt – und ganz wichtig, wie die Antwort aussieht. Genau das Format haben wir eben in Python ausgelesen: eine Liste mit einem Dictionary darin. Für jede andere API geht es genauso.

Drei Katzen, drei Listen: Namen, Hunger, Laune. Solange alles zusammenpasst, geht es. Frag die Gruppe: Was passiert, wenn eine Katze aus einer Liste gelöscht wird und aus den anderen nicht? Dann rutscht alles, und Bello hat plötzlich Kikis Laune. Das ist das Problem, für das es Objekte gibt.

Erster Schritt: alles, was zu einer Katze gehört, in eine Kiste. Das kennen wir schon – ein Dictionary. Verrutschen kann jetzt nichts mehr. Aber: Was die Katze kann, steht immer noch woanders, in irgendeiner Funktion. Das ist der Punkt, an dem Klassen anfangen.

Eine Klasse ist der Bauplan, ein Objekt ist ein Ding daraus. Wie ein Keksausstecher: einmal die Form, beliebig viele Kekse. Der Bauplan sagt, was jede Katze hat und was jede Katze kann. Jede einzelne Katze hat dann ihre eigenen Werte.

Der Bauplan als Code. class mit großem Anfangsbuchstaben, das ist Konvention. __init__ läuft beim Bauen und legt die Werte ab. self ist die Katze, um die es gerade geht – Python schiebt sie automatisch rein, deshalb steht sie in der Klammer, aber nicht beim Aufruf. Katze("Momo", 8) baut ein Exemplar.

An die Werte kommt man mit dem Punkt: momo.name, momo.hunger. Lesen geht, ändern auch. Der Punkt ist derselbe wie bei random.randint – links das Ding, rechts, was man davon will.

Jetzt das Verhalten. Eine Funktion in der Klasse heißt Methode, und ihr erster Parameter ist wieder self. momo.fuettern(5) heißt für Python: fuettern(momo, 5). Deshalb kann die Methode self.hunger ändern – sie weiß, um welche Katze es geht.

Ein Bauplan, drei Katzen, drei eigene Zustände. Momo füttern ändert nur Momo. Genau das war mit drei Listen nicht zu haben. Frag: Was ändert sich bei 100 Katzen am Code? Nichts – nur eine Schleife mehr.

Pointe zum Schluss: Objekte benutzt ihr seit dem ersten Tag. "Momo".upper() ruft eine Methode auf einem Text auf, fische.append(20) eine auf einer Liste. Und pd.DataFrame(...) von der Bibliotheken-Folie war eine Klasse – genau das Wort, das wir damals vertagt haben.

Letzte Code-Aufgabe: eine eigene Klasse. Auf dem Gerät steht das Gerüst, Ausführen prüft die sichtbaren Tests, Abschicken zusätzlich die versteckten. Achtet auf self in jeder Methode. Wer nicht weiterkommt, schaut auf die Folie mit der Katze zurück – dort steht alles, was gebraucht wird.

Das Finale, und diesmal ohne Stützräder: Die Eingabe ist kein fertiges Python mehr, sondern Text – eine Zeile pro Fang, Tag, Name, Anzahl. Erst einlesen und zerlegen (split), dann zählen. Teil 1 ist ein Dictionary, Teil 2 die längste Serie aufeinanderfolgender Tage derselben Katze. Tipp an die Gruppe: erst auf Papier an drei Zeilen durchspielen. Zeit lassen, das hier darf dauern.

Zweites Finale: eine Simulation. Die Regeln stehen auf der Folie, der Code muss sie nur befolgen – jede Runde alle hungriger, dann die hungrigste Katze füttern, nie unter null. Teil 1 ist der Gesamthunger am Ende, Teil 2 die Katze, die am häufigsten dran war. Wer eine Klasse nimmt, hat es leichter; nötig ist sie nicht. Genau das ist die Pointe der Objekte-Folien.

Bonus am Ende, wenn Zeit bleibt: keine Aufgabe, keine Rangliste. Momos Fang liegt durcheinander. Frag zuerst: Welcher Fisch ist der längste? Bei fünf Fischen sieht man es, bei tausend nicht mehr. Sortiert sind drei Fragen plötzlich einfach: der längste ist hinten, der kürzeste vorne, die Mitte in der Mitte.

Die einfachste Idee: immer nur zwei Nachbarn anschauen. Steht der Größere links, werden die beiden getauscht. Dann ein Schritt weiter. Nach einem Durchlauf ist der größte Wert ganz hinten – er ist nach oben gestiegen wie eine Blase, daher der Name. Das wiederholt sich, bis nichts mehr getauscht wird.

Derselbe Ablauf als Code, und es ist nur das, was wir kennen: zwei for-Schleifen und ein if. Die Zeile mit dem Komma tauscht zwei Werte in einem Rutsch – das kann Python, ohne Hilfsvariable. Die Balken laufen im gleichen Takt wie die Schleife.

Dieselbe Regel, jetzt mit zwanzig Werten über die ganze Leinwand. Einfach laufen lassen und schauen: der größte Wert wandert in jedem Durchlauf nach rechts, links bleibt lange Chaos. Am Ende die Zahl der Vergleiche merken – die drei Algorithmen starten alle mit denselben zwanzig Zahlen. Enter spielt es nochmal.

Andere Idee, gleiches Ziel: Suche den kleinsten Wert im Rest und hol ihn nach vorne. So wächst links ein sortierter Teil. Menschen sortieren Karten oft genau so.

Gleiche zwanzig Zahlen, andere Regel. Auffällig: Die grüne Wand wächst von links, und es wird kaum getauscht – aber die Vergleiche sind fast genauso viele wie bei Bubble Sort. Genau das ist der Unterschied zwischen tauschen und vergleichen.

Die Kartenspiel-Variante: Du nimmst eine Karte auf und schiebst sie so weit nach links, bis sie passt. Bei fast sortierten Listen ist das richtig schnell – Python nutzt diese Idee in seiner eingebauten Sortierung mit.

Die dritte Regel, und die mit dem angenehmsten Bild: Jeder Wert rutscht so weit nach links, bis er passt. Vergleicht die drei Zahlen am Ende. Wer mag, drückt Enter und schaut nochmal zu – das hier ist der Teil, bei dem Leute hängenbleiben, im guten Sinn.

Die vierte Regel, und die erste, die nicht mehr stur durch die Reihe läuft: teilen, bis jeder Teil nur noch einen Wert hat, dann Hälfte für Hälfte sortiert zusammenfügen. Die Idee steht rechts oben in drei Schritten. Zuschauen, wie die grünen Blöcke erst klein sind und dann immer größer werden. Am Ende auf die Vergleiche zeigen: deutlich weniger als bei den ersten drei, und der Abstand wächst mit der Länge der Liste. Enter spielt es nochmal.

Die fünfte: ein Wert wird zum Pivot – die blaue Säule –, alles Kleinere wandert nach links, alles Größere nach rechts. Danach steht das Pivot endgültig, und beide Seiten fangen für sich von vorne an. Der gestrichelte Rahmen zeigt, an welchem Stück gerade gearbeitet wird. Auch hier die Vergleiche mit Bubble Sort vergleichen. Das ist die Sortierung, die in der Praxis am häufigsten läuft. Enter spielt es nochmal.

Nicht Sekunden zählen, sondern Vergleiche. Bei 10 Werten sind es rund 100, bei 100 rund 10.000, bei 1000 rund eine Million: doppelt so viele Daten heißt viermal so viel Arbeit. Die eingebaute Sortierung wächst viel langsamer. Wer mehr wissen will, sucht nach O-Notation – das ist Stoff fürs erste Semester.

Und jetzt die Pointe: im Alltag schreibt das niemand selbst. sorted() gibt eine neue sortierte Liste, .sort() sortiert die vorhandene. reverse=True dreht um, key= sortiert nach etwas anderem, zum Beispiel nach Länge. Selbst schreiben lohnt sich trotzdem: man versteht, was die eine Zeile für einen erledigt.

Zum Abschluss die schlechten Ideen. Bogosort: mischen, nachschauen, ob es zufällig sortiert ist, sonst nochmal. Bei fünf Werten sind es im Schnitt 120 Versuche, bei zehn schon über drei Millionen, bei zwanzig länger als das Universum alt ist. Lustig, aber ein echtes Argument dafür, warum die Anzahl der Schritte zählt.

Stalin Sort: einmal durchgehen und alles wegwerfen, was nicht in die Reihenfolge passt. Das Ergebnis ist garantiert sortiert – nur eben nicht mehr dieselbe Liste. Ein Durchlauf, also so schnell wie es geht. Ein netter Test: Was fehlt am Ende, und warum ist das für echte Daten fatal?

Drei Karten zum Schluss: Sleep Sort schläft pro Wert so viele Sekunden und schreibt dann – bei großen Zahlen wartet man lange. Miracle Sort schaut immer wieder nach und hofft auf ein Wunder. Quantum Bogosort mischt und zerstört alle Universen, in denen es nicht sortiert ist. Wer Spaß daran hat: genau so fühlt sich Informatik oft an.

Kurz zurückschauen. Das ist keine Werbung, sondern eine Bestandsaufnahme: Variablen, Bedingungen, Listen, Schleifen, Funktionen, eingebaute Funktionen, Dictionaries, Bibliotheken, APIs, Klassen. Damit kommt man im ersten Semester mit. Was fehlt, ist Übung – und die kommt von selbst.

Empfehlungen, keine Hausaufgaben. 3Blue1Brown macht Mathe sichtbar – die Serie über neuronale Netze ist der beste Einstieg ins Thema, den es gratis gibt. Sebastian Lague baut Sachen und zeigt dabei, wie Programmieren sich anfühlt, wenn es Spaß macht. Computerphile für die Theorie, CS50 für einen kompletten Kurs. Sagen, welcher davon man selbst schaut.

Üben schlägt zuschauen. Advent of Code im Dezember ist genau das Format der letzten Tage. Exercism gibt Aufgaben mit Rückmeldung von Menschen. Und der beste Tipp bleibt: such dir etwas Nerviges aus dem eigenen Alltag und automatisier es – Dateien umbenennen, Noten ausrechnen, Stundenplan einlesen. Klein anfangen, fertig werden.

Danke fürs Mitmachen. Fragen gehen weiter per Mail, und die Folien bleiben unter derselben Adresse erreichbar. Wer will, macht die Rätsel zu Hause fertig.

This is our design system and style guide. Every visual decision for the Python pre-courses deck is documented here.

Three primary colors: Coral for action and emphasis, Mint for success and code, Sky for information and links.

Five supporting colors for personality and decoration. Rose is our warm pink highlight, Sun for warnings, Lavender for special content.

Three surface tiers: pure white for content, off-white for cards, warm tint for title slides. Code blocks are the only dark surface.

One font everywhere: JetBrains Mono. Variable weight. We primarily use bold and black. The type scale goes from display down to chrome.

Three button tiers: filled primary, outlined secondary, ghost. All are flat, no shadows, 2px borders, rounded-lg.

Small uppercase pills for categorizing content. Filled for strong presence, outlined for metadata. Each color has a semantic meaning.

One notification for the whole deck: a card in the top-right corner, newest on top, at most four. It holds four seconds and the thin bar shows how long. Mint means solved, sun means first place, sky is room news, coral is a problem.

The only dark element in the system. Catppuccin-inspired dark surface with pastel window dots matching our palette.

Persistent chrome: deck title top-left, progress bar bottom, page number bottom-right. All in text-muted so they never compete with content.

Three layout types: slide-bare for titles and drama, slide for all teaching content, slide-section for chapter breaks.

Generous margins. Desktop has 96px horizontal padding. Spacing scale from 4px to 96px. Five border-radius tiers.

Fast, subtle, purposeful animations. 80ms stagger between elements. All motion respects prefers-reduced-motion.

Two tools for teaching code: hovering a word links every token that means the same thing across both panels, and line focus dims everything but the live line. Click a word to pin the link while you talk.

One program in three stages. Shared tokens move to their new place, only new syntax fades in. Step it with the stage pills or the arrows.

Six animals carry every example in this course. Flat SVG, two-pixel outlines, tinted from the palette, so colour itself becomes data: three coral cats and one mint cat is a list with one odd element.

The things the cast acts on. A box is a variable, a basket is a list, a lever is a boolean, a door is a branch, a road is a sequence, a fence is a range.

Three worked scenes: a lever next to a boolean, a basket of fish next to a list, a street of houses next to a for loop. Picture on the left, code on the right, same words highlighted in both.