Diese Notebooks sind im Wesentlichen eine Übersetzung der 2. Ausgabe des Buches "Think Python" von Allen B. Downey. Sie finden den originalen Text hier: http://greenteapress.com/wp/think-python-2e/.
## Lernziele + Ablauf dieses Seminars
- Unser **Lernziel** ist, dass Sie **Programmieren lernen** (mit Python :-). Bis dahin ist es ein weiter Weg. Der beste Tipp ist: üben, üben, üben.
- Wir versuchen es dieses Mal mit folgendem **Ablauf** im Seminar:
1. Sie arbeiten als Pair-Programming-Team diese Jupyter-Notebooks durch.
- Währenddessen bin ich für Sie da, um Fragen zu beantworten und Probleme zu lösen.
- Sie können Codeschnippsel und Fragen im [gemeinsamen Etherpad](https://pad.okfn.org/p/ibi_spp) ablegen.
2. Nach ca. 15 Minuten unterbrechen wir das Programmieren und Sie wechseln die Rollen (Navigator<->Fahrerin).
- Jetzt besteht die Möglichkeit, Fragen zu stellen und Probleme im Plenum anzusprechen. Dazu nutzen wir auch das [Etherpad](https://pad.okfn.org/p/ibi_spp).
3. Wie wiederholen die Schritte 1.+2. bis zum Ende des Seminars.
4. Nach dem Seminar arbeiten Sie bitte die übrigen Notebooks gemeinsam durch, insbesondere die Übungen.
- Wir werden im Seminar entscheiden, bis zu welchem Notebook Sie kommen sollten.
## Tipps
- Arbeiten Sie die Notebooks selbständig im Team durch und **probieren Sie möglichst viel aus**. Seien Sie kreativ, neugierig und manchmal auch destruktiv. Denn auch durch Fehler lernen Sie.
-**Sie können alles in Ihrem Notebook bearbeiten** ... nutzen Sie diese Möglichkeit. Ergänzen Sie also Text, löschen Sie, was Sie überflüssig finden, fügen Sie Ihre eigenen Notizen oder Programme hinzu. Dieses Notebook kann Ihr "Portfolio" werden: eine Demonstration dessen, was Sie schon können.
- Es gibt wiederkehrende Abschnitte in den Notebooks:
-**Exkurse** sind Material, welches Sie sich nur anschauen brauchen, falls es Sie interessiert. Bitte schauen Sie sich die Exkurse eher zu Hause an, als während des Seminars, damit Sie vorwärts kommen. Die Inhalte der Exkurse sind nicht notwendig, um vorwärts zu kommen, aber hilfreich, um mehr zu lernen.
-**Debugging**-Abschnitte erklären, wie Sie Fehler finden und beheben können.
-**Glossar**-Abschnitte listen die Begriffe auf, die im Kapitel vermittelt wurden. Es ist eine gute Übung für zu Hause, jeden Begriff dort noch einmal in eigenen Worten zu definieren.
- Schließlich gibt es **Übungen**, diese sollten Sie unbedingt durchführen und erst fortfahren, sobald Sie die Aufgaben lösen konnten und verstanden haben bzw. die Aufgaben nach dem Seminar lösen.
-**Falls Sie mal nicht weiterkommen:** helfen Sie sich gegenseitig und versuchen Sie verschiedene Dinge. Schreiben Sie Ihr Problem z.B. einfach mal ganz genau hier im Notebook auf. Oft hilft das Aufschreiben eines Problems schon bei der Lösung eines Problems.
- Je nachdem wie gut Sie in den letzten beiden Seminaren aufgepasst haben (oder sich Dinge eingeprägt haben), kommt Ihnen einiges schon bekannt vor ... entscheiden Sie selbst, wie schnell Sie vorwärts kommen. Das Ziel ist, dass Sie diese Inhalte hier verstehen und später wieder abrufen können.
- Für die **Fortgeschrittenen**: am besten schauen Sie sich nochmal kurz alle Abschnitte an und entscheiden selbst, was Sie überspringen können. Falls Sie einige der Übungsaufgaben noch nicht durchgeführt haben, ist das jetzt eine gute Möglichkeit. Und ansonsten gibt es am Ende des [3. Kapitels](seminar03.ipynb) eine Knobelaufgabe.
## Hinweise zur Benutzung von Jupyter
- Sie kommen deutlich schneller vorwärts, wenn Sie **Tastaturkürzel** nutzen (und nicht die Maus). Im "Help"-Menü gibt es dazu den "Keyboard Shortcuts"-Eintrag. Sie können aber auch einfach die Tastenkombination `ESC h` drücken (das bedeutet: die `ESC`-Taste drücken und dann die Taste `h`). Wichtigste Kombinationen: `ESC b` fügt einen neuen Block ein, `STRG-ENTER` (oder `STRG-RETURN`, also `STRG` gedrückt halten und dann `RETURN` drücken) führt den aktuellen Block aus, `ESC m` ändert den Typ des aktuellen Blocks auf Markdown (und `ESC y` zu Python), usw.
- Alternativ können Sie auch die Knöpfe oben mit der Maus bedienen.
- Es gibt zwei **Arten von Blöcken**: "Code" ist für Python-Code, "Markdown" ist für Texte, die Sie mit Hilfe der [Markdown-Syntax](https://de.wikipedia.org/wiki/Markdown#Auszeichnungsbeispiele) formatieren können.
- Sie können auf Text doppelt klicken, um sich den Markdown-Quellcode anzuzeigen. Probieren Sie es mit diesem Text aus.
- Wenn Sie mal etwas "kaputtgespielt" haben, hilft es evtl., im "Kernel"-Menü den "Restart"-Eintrag auszuwählen.
- Mit der Funktion `help` können Sie in Python zu vielen Funktionen Hilfe erhalten. Die offizielle Python-Dokumentation finden Sie hier: https://docs.python.org/3/.
## Ihre Lernziele
Beschreiben Sie in 2-3 Stichpunkten kurz was Sie im Seminar heute lernen wollen. Klicken Sie dazu doppelt auf diesen Text und bearbeiten Sie dann den Text:
-
-
-
%% Cell type:markdown id: tags:
## Exkurs: Was mir an Python gefällt
In dieser Rubrik, die immer am Anfang eines Kapitels steht, möchte ich Ihnen zeigen, wofür ich Python nutze und warum ich es mag. Sie werden vielleicht noch nicht verstehen, was ich genau mache, aber Sie sehen damit schon einmal die Möglichkeiten von Python und können später darauf zurückgreifen. Da dies auch ein Exkurs ist, können Sie diese Rubrik gerne auch erst einmal überspringen.
Ich finde toll, dass ich mit Python ganz einfach Zufallsexperimente durchtesten kann. Das hilft mir, Stochastik besser zu verstehen. Z.B. das Würfeln mit zwei Würfeln:
%% Cell type:code id: tags:
```
import random # Zufallszahlen, siehe https://docs.python.org/3/library/random.html
# Werte initialisieren, größtermöglicher Wert bei zwei Würfeln: 6+6=12
"Wir können effektiver programmieren, wenn wir eine **Entwicklungsumgebung** benutzen. Meistens ist das ein Texteditor, der einem das Programmieren erleichtert, indem z.B. der Quelltext farblich hervorgehoben wird - wir hier in Jupyter auch. Es gibt einen [seit Jahren schwelenden \"Streit\"](https://en.wikipedia.org/wiki/Editor_war), welcher Editor der beste ist: Emacs oder Vi. Randall Munroe (Autor des Webcomics [XKCD](https://xkcd.com/)) hat das auf seine ganz eigene Art verarbeitet:\n",
"Wir können effektiver programmieren, wenn wir eine **Entwicklungsumgebung** benutzen. Meistens ist das ein Texteditor, der einem das Programmieren erleichtert, indem z.B. der Quelltext farblich hervorgehoben wird - wie hier in Jupyter auch. Es gibt einen [seit Jahren schwelenden \"Streit\"](https://en.wikipedia.org/wiki/Editor_war), welcher Editor der beste ist: Emacs oder Vi. Randall Munroe (Autor des Webcomics [XKCD](https://xkcd.com/)) hat das auf seine ganz eigene Art verarbeitet:\n",
"\n",
"\n",
Beschreiben Sie in 2-3 Stichpunkten kurz was Sie im Seminar heute lernen wollen. Klicken Sie dazu doppelt auf diesen Text und bearbeiten Sie dann den Text:
-
-
-
%% Cell type:markdown id: tags:
### Exkurs: Was mir an Python gefällt
In dieser Rubrik, die immer am Anfang eines Kapitels steht, möchte ich Ihnen zeigen, wofür ich Python nutze und warum ich es mag. Sie werden vielleicht noch nicht verstehen, was ich genau mache, aber Sie sehen damit schon einmal die Möglichkeiten von Python und können später darauf zurückgreifen. Da dies auch ein Exkurs ist, können Sie diese Rubrik gerne auch erst einmal überspringen.
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
### Programme
Was ist ein Programm?
> a sequence of instructions that speci
es how to perform a computation
In jeder Programmiersprache sind die Details etwas anderes, aber es gibt ein paar grundlegende Instruktionen, die es in so gut wie jeder Programmiersprache gibt:
- **conditional execution:** check for certain conditions and run appropriate code
- **repetition:** perform some action repeatedly, usually with some variation
Das ist's im Wesentlichen. Jedes Programm welches Sie schon einmal verwendet haben, besteht im Grunde nur aus diesen Bausteinen. Programmieren heißt also, ein großes Problem in viele kleine Aufgaben zu zerlegen, die sich damit lösen lassen.
%% Cell type:markdown id: tags:
### eine erste Anweisung
Der Grundbaustein eines jeden Programs ist die **Anweisung** - jedes Programm ist eine Folge von Anweisungen. Ein einfaches Programm mit nur einer Anweisung ist das berühmte *Hello World* (Exkurs: [Warum "Hello World"?](https://en.wikipedia.org/wiki/%22Hello,_World!%22_program)):
%% Cell type:code id: tags:
```
print("Hello World!")
```
%% Cell type:markdown id: tags:
(Sie können das Programm aufrufen, indem Sie in die Box mit dem Programm klicken und dann auf den "Play"-Button oben klicken oder die Tastenkombination `STRG+ENTER` drücken oder "Run Cells" im "Cell"-Menü aufrufen.)
Diese Anweisung ruft die **Funktion** `print` auf und übergibt ihr das **Argument** "Hello World!", was in diesem Fall eine **Zeichenkette** ist (das erkennen wir an den Gänsefüßchen). Die Argumente einer Funktion werden immer nach dem Namen der Funktion in Klammern übergeben.
Das Ergebnis dieses Funktionsaufrufs ist, dass die Zeichenkette auf dem Bildschirm ausgegeben wird.
Probieren Sie es nun selber und geben Sie eine Zeichenkette Ihrer Wahl aus, indem Sie die Zeichenkette in Gänsefüßchen der `print`-Funktion als Argument (zwischen den Klammern) übergeben:
%% Cell type:code id: tags:
```
print()
```
%% Cell type:markdown id: tags:
Zusammengefasst: `print("Hello World!")` ist eine Anweisung, die eine Funktion aufruft und aus den folgenden Bestandteilen besteht:
- dem Namen der Funktion, die aufgerufen wird - `print`
- den Argumenten, die der Funktion übergeben werden - in Klammern `()` eingeschlossen
- konkret, dem Argument `"Hello World!"` - einer Zeichenkette, die mit Gänsefüßchen `""` eingeschlossen ist
Jeglicher Aufruf einer Funktion besteht im Wesentlichen aus diesen Bestandteilen.
### Python-Programme starten
Wenn Sie ein Programm (eine der vielen Boxen mit Python-Code hier) starten, dann starten Sie im Hintergrund den sogenannten **Python-Interpreter**. Das ist ein Programm, welches Ihren Python-Code liest, für den Computer übersetzt und ausführt. Sie können den Python-Interpreter auch ohne Jupyter aufrufen und dann direkt Python-Anweisungen eingeben oder Programme starten, die Sie in einer Datei gespeichert haben. Für den Anfang bleiben wir aber bei Jupyter, weil wir hier Programme und Erklärungen leicht kombinieren können.
### Arithmetik
Neben Zeichenketten sind Zahlen ein wichtiges Mittel zur Informationsdarstellung. Sie können mit der `print`-Funktion auch Zahlen ausgeben, diese müssen Sie nicht in Gänsefüßchen einschließen:
%% Cell type:code id: tags:
```
print(17)
```
%% Cell type:markdown id: tags:
Die 17 ist eine ganze Zahl (**Integer**), sie können aber auch Zahlen mit Dezimalanteil (**Float**) verwenden:
%% Cell type:code id: tags:
```
print(3.149265)
```
%% Cell type:markdown id: tags:
Dazu verwenden wir als Dezimaltrennzeichen den Punkt `.`, nicht das Komma. (Weil das Komma eher in Deutschland verbreitet ist und der Punkt in den Ländern, in denen Python entwicklt wurde.)
Arithmetische **Operatoren** ermöglichen die Verknüpfung von Zahlen durch Rechnen, z.B. `+` (Addition), `-` (Subtraktion), `*` (Multiplikation), `/` (Division) und `**` (Exponentiation).
Wir können eine Berechnung direkt mit `print` ausgeben:
%% Cell type:code id: tags:
```
print(1 + 2 + 3 + 4 + 5)
```
%% Cell type:markdown id: tags:
Probieren Sie es selbst aus für folgende Berechnungen:
- 40 + 2
- 43 - 1
- 6 * 7
- 84 / 2
- `6**2 + 6`
indem Sie die folgende Anweisung ändern oder ergänzen:
%% Cell type:code id: tags:
```
print(40 + 2)
```
%% Cell type:markdown id: tags:
Tipp: Sie können auch mehrere Anweisungen hintereinander ausführen, indem Sie sie als **Folge** von Anweisungen zeilenweise hintereinander schreiben:
%% Cell type:code id: tags:
```
print("Der Umfang eines Kreises mit dem Radius 3 ist:")
print(2 * 3.1415926 * 3)
```
%% Cell type:markdown id: tags:
### Werte und Datentypen
Ein **Wert**, also z.B. eine Zahl oder eine Zeichenkette, ist eines der grundlegenden Dinge, die in einem Programm verarbeitet werden. Beispiele für Werte, die Sie schon gesehen haben sind `"Hello World!"`, `17` und `3.1415926`. Diese Werte haben verschiedenen **Datentypen**:
- `"Hello World!"` ist eine **Zeichenkette** (string* auf Englisch)
- `17` ist eine **ganze Zahl** (*integer* auf Englisch)
- `3.1415926` ist eine **Fließkommazahl** (*float* auf Englisch)
Wenn Sie sich nicht sicher sind, welchen Datentyp ein Wert hat, können Sie es mit der Funktion `type` herausfinden:
%% Cell type:code id: tags:
```
type("Hello World!")
```
%% Cell type:markdown id: tags:
Diese gibt Ihnen - je nach Datentyp - die englischen Abkürzungen `str`, `int` und `float` zurück. Probieren Sie es selbst aus, mit verschiedenen Werten, z.B. 2, 42.0, usw.:
%% Cell type:code id: tags:
```
type(2)
```
%% Cell type:markdown id: tags:
Übrigens: `type` funktioniert auch mit anderen Arten von "Typen". Probieren Sie es mal aus, indem Sie der `type`-Funktion die `print`-Funktion übergeben:
%% Cell type:code id: tags:
```
type(print)
```
%% Cell type:markdown id: tags:
Was ist mit Werten wie z.B. `"42"` oder `"3.14"`? Sie sehen wie Zahlen aus, aber wir haben Sie mit Gänsefüßchen umfasst wie bei Zeichenketten? Finden Sie heraus, welchen Typ diese beiden Werte haben, indem Sie sie als Argument in den folgenden Funktionsaufruf einsetzen:
%% Cell type:code id: tags:
```
type()
```
%% Cell type:markdown id: tags:
Sind es Zeichenketten oder Zahlen?
### Formale und natürliche Sprachen
Exkurs: Wenn Ihnen der Unterschied zwischen einer natürlichen Sprache (z.B. Englisch) und einer formalen Sprache (z.B., der Programmiersprache Python) noch nicht ganz klar ist, lesen Sie den [Abschnitt 1.6](http://greenteapress.com/thinkpython2/html/thinkpython2002.html#sec11) im Python-Kurs.
%% Cell type:markdown id: tags:
### Exkurs: Programmierer
Wir können effektiver programmieren, wenn wir eine **Entwicklungsumgebung** benutzen. Meistens ist das ein Texteditor, der einem das Programmieren erleichtert, indem z.B. der Quelltext farblich hervorgehoben wird - wir hier in Jupyter auch. Es gibt einen [seit Jahren schwelenden "Streit"](https://en.wikipedia.org/wiki/Editor_war), welcher Editor der beste ist: Emacs oder Vi. Randall Munroe (Autor des Webcomics [XKCD](https://xkcd.com/)) hat das auf seine ganz eigene Art verarbeitet:
Wir können effektiver programmieren, wenn wir eine **Entwicklungsumgebung** benutzen. Meistens ist das ein Texteditor, der einem das Programmieren erleichtert, indem z.B. der Quelltext farblich hervorgehoben wird - wie hier in Jupyter auch. Es gibt einen [seit Jahren schwelenden "Streit"](https://en.wikipedia.org/wiki/Editor_war), welcher Editor der beste ist: Emacs oder Vi. Randall Munroe (Autor des Webcomics [XKCD](https://xkcd.com/)) hat das auf seine ganz eigene Art verarbeitet:
Unter der Rubrik "Debugging" werden wir uns regelmäßig am Ende eines Kapitels Tipps zum Finden und Beheben von Fehlern anschauen.
Exkurs: Als Programmierer/innen machen wir häufiger Fehler. Diese Fehler werden **bugs** genannt und der Vorgang, Sie zu finden und zu beheben **debugging**. Fehler sind ärgerlich und können zu bösartigen Gefühlen dem Computer gegenüber führen ... lesen Sie im [Abschnitt 1.7](http://greenteapress.com/thinkpython2/html/thinkpython2002.html#sec12), wie Sie damit umgehen können.
%% Cell type:markdown id: tags:
### Glossar
Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 1 gelernt haben:
- Anweisung:
- Programm:
- `print`-Funktion: gibt den übergebenen Wert auf dem Bildschirm aus
- Argument:
- Operator:
- Wert:
- Datentyp:
- Zeichenkette:
- ganze Zahl:
- Fließkommazahl:
- bug:
- debugging:
Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit.
%% Cell type:markdown id: tags:
### Zusammenfassung
Neben vielen neuen Begriffen haben wir folgende wichtige Programmierfähigkeiten gelernt:
- wir können Werte und Berechnungen durchführen und mit Hilfe der `print`-Funktion ausgeben
- wir können die Datentypen Zeichenkette, ganze Zahl und Fließkommazahl voneinander unterscheiden und den Datentyp eines gegebenen Wertes mit Hilfe der `type`-Funktion herausfinden
- wir können mehrere Anweisungen hintereinanderausführen, indem wir sie als Folge zeilenweise hintereinander schreiben
%% Cell type:markdown id: tags:
### Übung
Diese Übung ist ein wichtiger Teil des Seminars. Bitte fahren Sie erst fort, wenn Sie die Aufgaben selbständig lösen konnten. Sie geben Ihnen die Möglichkeit, das gelernte zu überprüfen und zu vertiefen.
#### Aufgabe 1
Wann immer Sie etwas neues ausprobieren, sollten Sie versuchen, absichtlich einen Fehler zu machen. Probieren Sie z.B.
- Was passiert, wenn Sie im "Hello World"-Programm eines der Gänsefüßchen weglassen?
- Was passiert, wenn Sie beide weglassen?
- Was passiert, wenn sie `print` falsch schreiben?
Probieren Sie es aus:
%% Cell type:code id: tags:
```
print("Hello World!")
```
%% Cell type:markdown id: tags:
Solche Experimente helfen Ihnen, sich das, was Sie gelesen haben, einzuprägen. Und Sie werden mit Fehlermeldungen vertraut und haben eine Ahnung, was Sie bedeuten können. Lieber jetzt ein paar Fehler absichtlich machen, als später unabsichtlich. Und letztlich lernen Sie programmieren nur, indem Sie es tun.
Probieren Sie folgendes aus:
- Was passiert, wenn Sie beim Aufruf der `print`-Funktion eine oder beide der Klammern weglassen?
%% Cell type:code id: tags:
```
print("Hello World!")
print(42)
```
%% Cell type:markdown id: tags:
- Negative Zahlen können Sie mit einem Minuszeichen darstellen: `-2`. Was passiert, wenn Sie ein Plus-Zeichen vor eine Zahl stellen? Was ergibt `2++2`? Was ergibt `2+-+2`? Probieren Sie es mit verschiedenen Kombinationen von Plus- und Minus-Zeichen aus, bis Ihnen klar ist, was passiert:
%% Cell type:code id: tags:
```
print(-2)
```
%% Cell type:markdown id: tags:
- In der Mathematik ist es kein Problem, eine Null vor einer Zahl zu schreiben: 02 ist gleich 2. Was passiert, wenn Sie das in Python probieren?
%% Cell type:code id: tags:
```
print()
```
%% Cell type:markdown id: tags:
- Was passiert, wenn Sie zwei Werte ohne Operator dazwischen haben?
%% Cell type:code id: tags:
```
print()
```
%% Cell type:markdown id: tags:
#### Aufgabe 2
Nutzen Sie Python als Taschenrechner:
- Wieviele Sekunden entsprechen 42 Minuten und 42 Sekunden?
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
- Wieviele Meilen entsprechen 10 Kilometer (Hinweis: eine Meile ist 1.61 Kilometer lang)
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
- Wenn Sie ein Rennen über 10 Kilometer in 42 Minuten und 42 Sekunden beenden, was ist Ihre Durchschnittsgeschwindigkeit (Zeit pro Kilometer in Minuten und Sekunden)? Was ist Ihre Durchschnittsgeschwindigkeit in Kilometer pro Stunde?
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
 Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (nicht auf diesem Rechner). Nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/).
