"Das ist es im Wesentlichen. Jedes Programm, dass Sie schon 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 mit diesen Bausteinen lösen lassen."
__[Chapter 1 The Way of the Program](http://greenteapress.com/thinkpython2/html/thinkpython2002.html)__
**Wichtig:** Bevor Sie anfangen dieses Jupyter-Notebook zu bearbeiten schauen Sie sich bitte zuerst [das Einführungsnotebook](einführung_jn.ipynb) sowie [das 0. Seminarnotebook](seminar00.ipynb) an. Diese enthalten wichtige Hinweise für das Verwenden von Jupyter-Notebooks. Wenn Sie die Notebooks in das selbe Verzeichnis heruntergeladen und nicht umbenannt haben, können Sie die Links verwenden um die entsprechenden Notebooks zu öffnen, andernfalls können Sie die Notebooks ebenfalls auf [Gitlab](https://scm.cms.hu-berlin.de/ibi/python/-/tree/master/notebooks) finden.
%% Cell type:markdown id: tags:
<h1>Inhalt<spanclass="tocSkip"></span></h1>
<divclass="toc"><ulclass="toc-item"><li><span><ahref="#Ihre-Lernziele:"data-toc-modified-id="Ihre-Lernziele:-1"><spanclass="toc-item-num">1 </span>Ihre Lernziele</a></span></li><li><span><ahref="#Exkurs:-Was-mir-an-Python-gefällt:"data-toc-modified-id="Exkurs:-Was-mir-an-Python-gefällt:-2"><spanclass="toc-item-num">2 </span>Exkurs: Was mir an Python gefällt:</a></span></li><li><span><ahref="#Programme"data-toc-modified-id="Programme-3"><spanclass="toc-item-num">3 </span>Programme</a></span><ulclass="toc-item"><li><span><ahref="#Eine-erste-Anweisung"data-toc-modified-id="Eine-erste-Anweisung-3.1"><spanclass="toc-item-num">3.1 </span>Eine erste Anweisung</a></span></li><li><span><ahref="#Python-Programme-starten"data-toc-modified-id="Python-Programme-starten-3.2"><spanclass="toc-item-num">3.2 </span>Python-Programme starten</a></span></li><li><span><ahref="#Arithmetik"data-toc-modified-id="Arithmetik-3.3"><spanclass="toc-item-num">3.3 </span>Arithmetik</a></span></li></ul></li><li><span><ahref="#Werte-und-Datentypen"data-toc-modified-id="Werte-und-Datentypen-4"><spanclass="toc-item-num">4 </span>Werte und Datentypen</a></span></li><li><span><ahref="#Formale-und-natürliche-Sprachen"data-toc-modified-id="Formale-und-natürliche-Sprachen-5"><spanclass="toc-item-num">5 </span>Formale und natürliche Sprachen</a></span></li><li><span><ahref="#Exkurs:-Programmierer"data-toc-modified-id="Exkurs:-Programmierer-6"><spanclass="toc-item-num">6 </span>Exkurs: Programmierer</a></span></li><li><span><ahref="#Debugging"data-toc-modified-id="Debugging-7"><spanclass="toc-item-num">7 </span>Debugging</a></span></li><li><span><ahref="#Glossar"data-toc-modified-id="Glossar-8"><spanclass="toc-item-num">8 </span>Glossar</a></span></li><li><span><ahref="#Übung"data-toc-modified-id="Übung-9"><spanclass="toc-item-num">9 </span>Übung</a></span><ulclass="toc-item"><li><span><ahref="#Aufgabe-1"data-toc-modified-id="Aufgabe-1-9.1"><spanclass="toc-item-num">9.1 </span>Aufgabe 1</a></span></li><li><span><ahref="#Aufgabe-2"data-toc-modified-id="Aufgabe-2-9.2"><spanclass="toc-item-num">9.2 </span>Aufgabe 2</a></span></li></ul></li></ul></div>
%% Cell type:markdown id: tags:
## Ihre Lernziele
Beschreiben Sie in 2-3 Stichpunkten was Sie heute lernen wollen. Sie können diesen Text durch Doppelklick bearbeiten.
-
-
-
%% Cell type:markdown id: tags:
## Exkurs: Was mir an Python gefällt:
Ich finde toll, dass mir Python Berechnungen mit Datumsangaben sehr vereinfacht:
Bitte beachten Sie, dass Sie **erst den Code ausführen (Strg + Enter)** und anschließend in das neue Eingabefeld Ihren Geburtstag eingeben.
%% Cell type:code id: tags:
```
import datetime
datum = input("Geben Sie Ihr Geburtsdatum im Format TT.MM.JJJJ an: ")
# Zahlen für Tag, Monat und Jahr extrahieren
(tag, monat, jahr) = (int(d) for d in datum.split('.'))
# Datumsobjekt anlegen
datum = datetime.datetime(jahr, monat, tag)
print("You were born on a", datum.strftime("%A"),)
```
%% Cell type:markdown id: tags:
## Programme
Was ist ein Programm?
> Eine Folge von Anweisungen, die genau beschreibt wie eine "Berechnung" ausgeführt werden muss
In jeder Programmiersprache sind die Details etwas anderes, aber es gibt ein paar grundlegende Instruktionen, die es in so gut wie jeder Programmiersprache gibt:
-**Eingabe (input)** Daten von der Tastatur, einer Datei, dem Netzwerk oder von irgendeinem anderen Gerät werden eingegeben
-**Ausgabe (output)** Darstellung von Daten auf dem Bildschirm, Speichern in einer Datei, Verschicken über das Netzwerk und so weiter
-**bedingte Ausführung (conditional execution)** Prüfe bestimmte Bedingungen und führe den entsprechenden Code aus
-**Wiederholung (repetition)** Führe eine beliebige Aktion wiederholt aus, normalerweise mit einigen Abweichungen
Das ist es im Wesentlichen. Jedes Programm, dass Sie schon 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 mit diesen Bausteinen lösen lassen.
Diese Bausteine bestehen aus kleineren Zeilen Code. Der Grundbaustein jedes Programms ist die **Anweisung**. Jedes Programm ist im Wesentlichen eine Folge von Anweisungen. Das erste Programm, das man häufig in Programmiersprachen schreibt heißt __[Hello World](https://de.wikipedia.org/wiki/Hallo-Welt-Programm)__. Es ist ein einfaches Programm mit nur einer Anweisung.
%% Cell type:code id: tags:
```
print("Hello World!")
```
%% Cell type:markdown id: tags:
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** übergeben:
%% Cell type:code id: tags:
```
print()
```
%% Cell type:markdown id: tags:
Zusammengefasst: Die **Anweisung** ruft eine **Funktion** mit dem Namen `print` auf, der das **Argument**`Hello World!` mit `()` und Gänsefüßschen eingeschlossen übergeben wurde.
%% Cell type:markdown id: tags:
### Python-Programme starten
Wenn wir ein Programm (hier einer der Blöcke mit Python-Code) starten, dann starten wir im Hintergrund den sogenannten **Python-Interpreter**. Das ist ein Programm, welches den Python-Code liest, für den Computer übersetzt und ausführt. Wir können den Python-Interpreter auch ohne Jupyter aufrufen und dort direkt Python-Anweisungen eingeben oder Programme starten, die wir 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.
**Tipp**: Nutzen Sie http://pythontutor.com, um Ihren Code nachvollziehen zu können und Fehler zu finden!
### Arithmetik
Neben Zeichenketten sind Zahlen ein wichtiges Mittel zur Informationsdarstellung. Wir können mit der `print`-Funktion auch Zahlen ausgeben, diese müssen wir nicht in Gänsefüßchen einschließen:
%% Cell type:code id: tags:
```
print(17)
```
%% Cell type:markdown id: tags:
Siebzehn ist eine **ganze Zahl** (*Englisch: Integer*), wir können aber auch **Gleitkommazahlen** (*Englisch: Float*) also Zahlen mit Dezimalanteil darstellen:
%% Cell type:code id: tags:
```
print(3.14159)
```
%% Cell type:markdown id: tags:
Dazu verwenden wir - anders als in Deutschland üblich - einen Punkt als Dezimaltrennzeichen anstelle eines Kommas. (Dies ist in den Ländern in denen Python entwickelt wurde so üblich.)
Arithmetische **Operatoren** ermöglichen die Verknüpfung von Zahlen durch Rechnen, z.B. `+` (Addition), `-` (Subtraktion), `*` (Multiplikation), `/` (Division), `**` (Exponentiation), `//` (ganzzahlige Division) und `%` (Modulo/Restoperator).
Modulo ist das Gegenstück zur ganzzahligen Division (//). Es wird immer der "Rest" berechnet. Schauen wir uns ein Beispiel an:
Wir teilen 14 durch 4.
- normale Division: `14 / 4 = 3.5`
- ganzzahlige Division: `14 // 4 = 3`
- modulo: `14 % 4 = 2`
Es wird also immer die Restzahl angegeben. Die 4 passt 3mal in die 14, allerdings bleiben dann 2 "Rest" übrig. (also 3 Rest 2).
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 für folgende Berechnungen aus:
- 40 + 2
- 43 - 1
- 6 * 7
- 84 / 2
- 6**2 + 6
- 42 // 8
- 42 % 8
Sie können die folgende Anweisung ändern oder ergänzen.
%% Cell type:code id: tags:
```
print(40+2)
```
%% Cell type:markdown id: tags:
Tipp: Wir können mehrere Anweisungen hintereinander ausführen, indem wir sie als **Folge** von Anweisungen zeilenweise untereinander 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 wir schon gesehen haben sind `"Hello World!"`, `17` und `3.1415926`. Diese Werte haben verschiedenen **Datentypen**:
-`"Hello World!"` ist eine **Zeichenkette** (Englisch: *string*)
-`17` ist eine **ganze Zahl** (Englisch: *integer*)
-`3.1415926` ist eine **Gleitkommazahl** (Englisch: *float*)
Wenn wir uns nicht sicher sind, welchen Datentyp ein Wert hat, können wir es mit der Funktion `type` herausfinden:
Diese gibt uns - je nach Datentyp - zum Beispiel die englischen Abkürzungen `str`, `int` und `float` zurück (die *string*, *integer* und *float* entsprechen). Probieren Sie es selbst mit verschiedenen Werten (z.B. 2, 42.0) aus:
%% Cell type:code id: tags:
```
type()
```
%% 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 passiert, wenn wir Werte wie `"42"` und `"3.14"`mit Gänsefüßchen einfassen wie Zeichenketten? Sind es Zeichenketten oder Zahlen? Finden Sie es heraus indem Sie den folgenden Codeblock nutzen.
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
In Python gibt es noch weitere Datentypen, die wir später kennenlernen werden. Hier schon einmal ein Überblick:
Besonders ausführlich wird der Unterschied zwischen natürlicher und formaler Sprache in [Abschnitt 1.6](http://greenteapress.com/thinkpython2/html/thinkpython2002.html#sec11) des englischen Buchs behandelt.
Grundsätzlich jedoch sind **natürliche Sprachen** Sprachen, die gesprochen werden, wie zum Beispiel Deutsch, Englisch oder Französisch. Sie werden nicht von Menschen entworfen und entwickeln sich natürlich.
**Formale Sprachen** sind von Menschen für bestimmte Zwecke entworfene Sprachen. Das hier relevanteste Beispiel sind **Programmiersprachen**.
Sie haben meist sehr strenge **Syntax-Regeln**, die ihre Struktur bestimmen. Dabei gibt es Regeln zu den erlaubten Zeichen und zu der erlaubten Struktur. Während der menschliche **Parser** häufig mit sprachlichen Regelbrüchen umgehen kann, kann es der **Parser** im Computer nicht.
>Die§ ist ein gr@mmatikalisch k0rrekter S@tz mit ungültigen Zeichen. Satz dieser nur erlaubte Zeichen aber Grammatik falsche hat.
Wichtige Unterschiede sind, dass natürliche Sprache zweideutig, redundant und voller Symbolismus sein darf, formale Sprache aber nicht.
%% 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 - 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:

Als Programmierer/innen machen wir häufiger Fehler. Diese Fehler werden **bugs** genannt und der Vorgang, Sie zu finden und zu beheben **debugging**. Dies kann zu starken (negativen) Gefühlen führen.
Es lässt sich darauf zurückführen, dass wir Computer unterbewusst wie Menschen behandeln und darum auf unkooperative Computer genauso reagieren wie auf unkooperative Mitmenschen. Es kann helfen darauf vorbereitet zu sein und den Computer als Mitarbeiter zu sehen, der sehr schnell und gut rechnen kann aber sehr genaue Anweisungen braucht.
Obwohl es sehr frustrierend sein kann zu lernen wie man diese Fehler findet und behebt ist es eine wertvolle Fähigkeit und in dieser Kategorie werden wir uns regelmäßig Tipps und Strategien des Debugging anschauen, die Ihnen hoffentlich helfen.
Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 1 gelernt haben:
- Anweisung:
- Programm:
- **`print`-Funktion**:
- Argument:
- Operator:
- Wert:
- Datentyp:
- Zeichenkette:
- ganze Zahl:
- Gleitkommazahl:
- bug:
- debugging:
Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit.
Sollten Sie einmal nicht weiterkommen, schauen Sie im Glossar von *Think Python* nach oder fragen Sie noch einmal nach.
%% 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 wir etwas neues ausprobieren, sollten wir 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?
- Was passiert, wenn Sie beim Aufruf der `print`-Funktion eine oder beide der Klammern weglassen?
Probieren Sie es aus:
%% Cell type:code id: tags:
```
print()
```
%% Cell type:markdown id: tags:
Solche Experimente helfen uns dabei das Gelesene einzuprägen. Zusätzlich werden mit Fehlermeldungen vertraut und haben eine Ahnung, was sie bedeuten könnten. Lieber jetzt ein paar Fehler absichtlich machen, als später unabsichtlich. Und letztlich lernen wir Programmieren nur, indem wir programmieren.
- Negative Zahlen können wir mit einem Minuszeichen darstellen: `-2`. Was passiert, wenn wir 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:
- In der Mathematik ist es kein Problem, eine Null vor einer Zahl zu schreiben: 02 ist gleich 2. Was passiert, wenn wir das in Python probieren?
- Was passiert, wenn wir zwei Werte ohne Operator dazwischen haben?
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
### Aufgabe 2
Nutzen Sie Python als Taschenrechner: Keine Sorge, während Sie hier zwar Textaufgaben lösen müssen ist dies nicht das Ziel der Übung. Wenn Sie nicht weiterkommen schauen Sie sich zuerst die Hinweiße an und fragen Sie gegebenenfalls um Hilfe. Es geht hier darum zu verstehen, wie man diese Aufgabe in Python lösen kann, der Rechenweg ist eher Zweitrangig.
- Wieviele Sekunden entsprechen 42 Minuten und 42 Sekunden?
- Wenn Sie ein Rennen über 10 Kilometer in 42 Minuten und 42 Sekunden beenden, was ist Ihre Durchschnittsgeschwindigkeit (**Zeit pro Meile** in Minuten und Sekunden)? Was ist Ihre Durchschnittsgeschwindigkeit in **Meilen pro Stunde**?
1. Zuerst müssen Sie herausfinden wie viele Meilen das Rennen lang ist. Das können Sie im vorherigen Teil der Aufgabe erfahren. <br>
2. Rechnen Sie zudem die Zeit in Sekunden um. Dazu können Sie wieder die Lösung aus dem vorherigen Teil der Aufgabe nehmen. <br>
3. Um die Zeit pro Meile zu errechnen, müssen Sie die Gesamtzeit durch die Anzahl an Meilen teilen. Rechnen Sie anschließend die Zeit von Sekunden in Minuten pro Meile um. <br>
4. Um dann die Geschwindigkeit in Meilen pro Stunde zu berechnen gehen Sie analog vor. Teilen Sie die Gesamtzahl an Meilen durch die Gesamtdauer des Rennens. Rechnen Sie anschließend das Ergebnis von **Meilen pro Sekunde** in **Meilen pro Stunde** um.
Die Durchschnittsgeschwindigkeit beträgt 6,88 Minuten pro Meile bzw. 8,73 Meilen pro Stunde.
</div>
</details>
%% Cell type:markdown id: tags:
 Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (nicht auf einem Pool-Rechner). Rufen Sie dazu im Menü "File" den Punkt "Download as"->"Notebook" auf und nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/).
Herzlichen Glückwunsch! Sie haben das erste Kapitel geschafft!
"Die **Zuweisung** ist eine besondere Form der Anweisung. Sie erzeugt eine neue Variable und gibt ihr einen Wert. Wenn bereits eine Variable mit dem selben Namen existiert wird dieser nur ein Wert zugewiesen:\n"
"Die **Zuweisung** ist eine besondere Form der Anweisung. Sie erzeugt eine neue Variable und gibt ihr einen Wert. \n"
[Chapter 2: Variables, expressions and statements](http://greenteapress.com/thinkpython2/html/thinkpython2003.html).
Eine der mächtigsten Fähigkeiten von Programmiersprachen ist, **Variablen** zu verändern. Variablen sind Namen, die auf einen Wert verweisen.
**Bevor Sie mit diesem Notebook starten, sollten Sie wiederholen, was Sie im letzten Notebook gelernt haben. Gehen Sie zurück und schauen Sie sich mindestens das Glossar an und wiederholen Sie die dort genannten Begriffe.**
%% Cell type:markdown id: tags:
<h1>Inhalt<spanclass="tocSkip"></span></h1>
<divclass="toc"><ulclass="toc-item"><li><span><ahref="#Ihre-Lernziele"data-toc-modified-id="Ihre-Lernziele-1"><spanclass="toc-item-num">1 </span>Ihre Lernziele</a></span></li><li><span><ahref="#Exkurs:-Was-mir-an-Python-gefällt"data-toc-modified-id="Exkurs:-Was-mir-an-Python-gefällt-2"><spanclass="toc-item-num">2 </span>Exkurs: Was mir an Python gefällt</a></span></li><li><span><ahref="#Zuweisung"data-toc-modified-id="Zuweisung-3"><spanclass="toc-item-num">3 </span>Zuweisung</a></span></li><li><span><ahref="#(Variablen)Namen"data-toc-modified-id="(Variablen)Namen-4"><spanclass="toc-item-num">4 </span>(Variablen)Namen</a></span></li><li><span><ahref="#Ausdrücke-und-Anweisungen"data-toc-modified-id="Ausdrücke-und-Anweisungen-5"><spanclass="toc-item-num">5 </span>Ausdrücke und Anweisungen</a></span></li><li><span><ahref="#Reihenfolge-von-Operatoren"data-toc-modified-id="Reihenfolge-von-Operatoren-6"><spanclass="toc-item-num">6 </span>Reihenfolge von Operatoren</a></span></li><li><span><ahref="#Operatoren-für-Zeichenketten"data-toc-modified-id="Operatoren-für-Zeichenketten-7"><spanclass="toc-item-num">7 </span>Operatoren für Zeichenketten</a></span></li><li><span><ahref="#Kommentare"data-toc-modified-id="Kommentare-8"><spanclass="toc-item-num">8 </span>Kommentare</a></span></li><li><span><ahref="#Debugging"data-toc-modified-id="Debugging-9"><spanclass="toc-item-num">9 </span>Debugging</a></span></li><li><span><ahref="#Glossar"data-toc-modified-id="Glossar-10"><spanclass="toc-item-num">10 </span>Glossar</a></span></li><li><span><ahref="#print-Tutorial"data-toc-modified-id="print-Tutorial-11"><spanclass="toc-item-num">11 </span><code>print</code> Tutorial</a></span></li><li><span><ahref="#Übung"data-toc-modified-id="Übung-12"><spanclass="toc-item-num">12 </span>Übung</a></span><ulclass="toc-item"><li><span><ahref="#Aufgabe-1"data-toc-modified-id="Aufgabe-1-12.1"><spanclass="toc-item-num">12.1 </span>Aufgabe 1</a></span></li><li><span><ahref="#Aufgabe-2"data-toc-modified-id="Aufgabe-2-12.2"><spanclass="toc-item-num">12.2 </span>Aufgabe 2</a></span></li></ul></li></ul></div>
%% Cell type:markdown id: tags:
## 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:
-
-
-
## Exkurs: Was mir an Python gefällt
Dieses Programm durchsucht alle Jupyter Notebooks in dem Verzeichnis in dem dieses Notebook gespeichert ist.
%% Cell type:code id: tags:
```
import os
query = "Experiment"
# Suche nach query in s; falls gefunden: Fundstelle + hervorgehobene Anfrage zurückgeben
# alle Python-Notebooks im aktuellen Verzeichnis durchsuchen
for entry in os.listdir():
if entry.endswith(".ipynb"):
with open(entry, "rt") as f:
for line in f:
result = search(line, query)
if result:
print(entry + ":", result)
```
%% Cell type:markdown id: tags:
## Zuweisung
Die **Zuweisung** ist eine besondere Form der Anweisung. Sie erzeugt eine neue Variable und gibt ihr einen Wert. Wenn bereits eine Variable mit dem selben Namen existiert wird dieser nur ein Wert zugewiesen:
Die **Zuweisung** ist eine besondere Form der Anweisung. Sie erzeugt eine neue Variable und gibt ihr einen Wert.
Wenn bereits eine Variable mit dem selben Namen existiert wird dieser nur ein Wert zugewiesen:
%% Cell type:code id: tags:
```
nachricht = "Das ist ein ganz einfacher Mechanismus."
n = 17
pi = 3.141592653589793
```
%% Cell type:markdown id: tags:
In diesem Beispiel sehen wir drei Zuweisungen:
- die Erste weist die Zeichenkette `"Das ist ein ganz einfacher Mechanismus."` einer Variable mit dem Namen `nachricht` zu
- die Zweite weist die Zahl `17` der Variablen `n` zu und
- die Dritte weist (einen Näherungswert für) Pi der Variablen `pi` zu.
Legen Sie selbst ein paar Variablen an und weisen Sie Ihnen Werte zu:
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
## (Variablen)Namen
Variablen (und auch Funktionen) benötigen Namen. Als Programmierer_innen sollten wir Namen wählen, die aussagekräftig sind und dokumentieren, wofür die Variable (oder Funktion) verwendet wird. Folgende Regeln gelten:
Der Name `0das_gibt_Aerger` ist nicht erlaubt, weil er mit einer Zahl beginnt. Probieren wir ein paar andere Namen aus. Führen Sie dafür den Code aus, um zu sehen was passiert. Dabei kann es zu Fehlermeldungen kommen, diese bedeuten nicht, dass Sie etwas falsch gemacht haben. Lesen Sie die Fehlermeldungen durch bevor Sie die anschließenden Erklärungen lesen.
%% Cell type:code id: tags:
```
mehr@ = 100
```
%% Cell type:code id: tags:
```
class = 'Advanced Theoretical Zymurgy'
```
%% Cell type:markdown id: tags:
**Erklärungen:**
- Der Name `mehr@` ist nicht erlaubt, weil das Zeichen `@` nicht zu den Zeichen gehört, aus denen ein Name bestehen darf.
- Der Name `class` ist anders, denn er enthält nur erlaubte Zeichen. Warum gibt es dennoch einen Fehler? Der Grund ist, dass `class` ein sogenanntes **Schlüsselwort** ist. Schlüsselwörter helfen Python, die Struktur eines Programms zu erkennen und dürfen daher nicht als Namen für Variablen (und Funktionen) verwendet werden. In Python 3 gibt es die folgenden Schlüsselwörter: `False None True and as assert break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield`. Sie brauchen sich die Liste nicht zu merken. In den meisten Entwicklungsumgebungen (Programmen zum Bearbeiten von Quellcode - wie z.B. Jupyter) werden diese Wörter farblich hervorgehoben und Sie werden somit gewarnt, falls Sie eines dieser Wörter als Variablennamen verwenden wollen.

([Keep it simple, stupid](http://www.commitstrip.com/en/2016/09/01/keep-it-simple-stupid/), CommitStrip.com)
%% Cell type:markdown id: tags:
## Ausdrücke und Anweisungen
Ein **Ausdruck** ist eine Kombination von Werten, Variablen und Operatoren. Wir haben Ausdrücke bereits kennengelernt: In der Anweisung
%% Cell type:code id: tags:
```
print(1 + 2 + 3 + 4 + 5)
```
%% Cell type:markdown id: tags:
weiter oben gibt die `print`-Funktion den Wert des Ausdrucks `1 + 2 + 3 + 4 + 5` aus. In diesem Beispiel ist der Ausdruck `1 + 2 + 3 + 4 + 5` eine Kombination von Werten (1, 2, 3, 4, und 5) und dem Operator `+`.
Jeder Wert ist selbst ein Ausdruck und auch jede Variable ist ein Ausdruck. Das folgende sind also alles Ausdrücke:
%% Cell type:code id: tags:
```
42
n
n+25
```
%% Cell type:markdown id: tags:
Wenn wir einen Ausdruck am Ende einer Code-Box in Jupyter eingeben, dann wird der Ausdruck **ausgewertet** (also dessen Wert berechnet) und das Ergebnis ausgegeben. Allerdings passiert sonst nicht viel - der Wert wird nicht gespeichert und kann so nicht weiterverwendet werden. Wir können aber beispielsweise mit einer Zuweisung (wie oben gesehen) den Wert eines Ausdrucks einer Variablen zuweisen.
**Anweisungen** haben wir in Kapitel 1 schon kennengelernt (als die Bausteine eines Programms). Anweisungen sind Codestücke, die eine Auswirkung haben - also z.B. einer Variablen einen Wert zuweisen oder ein Ergebnis anzeigen:
%% Cell type:code id: tags:
```
n = 17
print(n)
```
%% Cell type:markdown id: tags:
Die erste Zeile ist eine Zuweisung, die der Variablen `n` einen Wert zuweist. Die zweite Zeile ruft die Funktion `print` auf, um den Wert von `n` auszugeben.
Wenn wir eine Anweisung starten (mit "Run Cell" aus dem "Cell"-Menü, oder `STRG-ENTER`), dann wird die Anweisung **ausgeführt**, d.h., der Python-Interpreter tut, was immer die Anweisung verlangt.
Schreiben Sie eine Folge von drei Anweisungen:
1. Weisen Sie einer Variable `radius` den Wert 3 zu.
2. Weisen Sie einer Variable `umfang` den (Wert des) Ausdrucks zu, der den Umfang eines Kreises mit dem Radius `radius` berechnet
3. Geben Sie den Wert der Variablen `umfang` mit der Funktion `print` aus.
- Exponentiation hat die nächsthöhere Priorität, daher ergibt
%% Cell type:code id: tags:
```
1 + 2**3
```
%% Cell type:markdown id: tags:
9 (und nicht 27) und
%% Cell type:code id: tags:
```
2 * 3**2
```
%% Cell type:markdown id: tags:
ergibt 18 (und nicht 36).
- Multiplikation und Division haben eine höhere Priorität als Addition und Subtraktion. Daher ergibt
%% Cell type:code id: tags:
```
2*3-1
```
%% Cell type:markdown id: tags:
5 und nicht 4 und
%% Cell type:code id: tags:
```
6+4/2
```
%% Cell type:markdown id: tags:
ergibt 8 und nicht 5.
- Operatoren mit der gleichen Priorität werden von links nach rechts ausgewertet (außer Exponentiation). Im Ausdruck `degrees / 2 * pi` wird also zuerst dividiert und dann wird mit `pi` multipliziert. Um stattdessen durch `pi` zu dividieren, können wir Klammern verwenden oder stattdessen `degrees / 2 / pi` schreiben.
Wir müssen uns die Reihenfolge nicht merken. Wenn wir uns nicht sicher sind, verwenden wir einfach Klammern, um die Reihenfolge festzulegen.
Ändern Sie den folgenden Ausdruck so ab, dass zuerst 2 und 3.141 addiert werden und das Ergebnis mit 4 multipliziert wird:
%% Cell type:code id: tags:
```
2 + 3.141 * 4
```
%% Cell type:markdown id: tags:
Die Ausgabe sollte dann 20.564 statt 14.564 betragen.
## Operatoren für Zeichenketten
Im Allgemeinen können wir mathematische Operatoren nicht für Zeichenketten verwenden, auch wenn die Zeichenketten wie Zahlen aussehen:
Mit dem Operator `+` können wir Zeichenketten verknüpfen (oder verketten). D.h., die Zeichenketten werden hinereinander geschrieben.
%% Cell type:code id: tags:
```
a = "Donau"
b = "dampf"
c = "schiff"
a + b + c
```
%% Cell type:markdown id: tags:
Mit dem Operator `*` können wir eine Zeichkette wiederholen:
%% Cell type:code id: tags:
```
c * 3
```
%% Cell type:markdown id: tags:
Dabei muss einer der beiden Werte eine Zeichenkette sein und der andere eine ganze Zahl. Probieren Sie aus, ob die Reihenfolge von Zeichenkette und Zahl egal ist:
%% Cell type:code id: tags:
```
3*c
```
%% Cell type:markdown id: tags:
Die beiden Operatoren funktionieren ähnlich wie bei Zahlen: So wie `4*3` gleich `4+4+4` ist, ist `dampf*3` gleich `dampfdampfdampf`. Allerdings gibt es einen wichtigen Unterschied: Welche Eigenschaft erfüllt die Addition bei Zahlen, die die Verknüpfung von Zeichenketten nicht erfüllt?
-
-
-
-
## Kommentare
Sobald Programme größer und komplexer werden, wird es schwer, sie zu verstehen. Die Information, die im Programmcode steckt, ist sehr dicht und es fällt oft schwer, nur durch einen Blick auf den Programmcode herauszufinden, was der Code macht und warum.
Daher ist es eine gute Idee, Notizen in natürlicher Sprache einzufügen, die erklären, was das Programm macht. Diese Notizen heißen **Kommentare** und sie beginnen mit dem Zeichen `#`:
%% Cell type:code id: tags:
```
pi = 3.141592653589793
radius = 7
# die Fläche eines Kreises berechnen
flaeche = 2 * pi * radius**2
```
%% Cell type:markdown id: tags:
Wir können Kommentare auch am Ende einer Zeile hinzufügen:
%% Cell type:code id: tags:
```
flaeche = 2 * pi * radius**2 # die Fläche eines Kreises berechnen
```
%% Cell type:markdown id: tags:
Alles ab `#` bis zum Ende der Zeile wird ignoriert und hat keine Auswirkung auf die Ausführung des Programms.
- Kommentare werden in der Entwicklungsumgebung oft farblich hervorgehoben, was zusätzlich die Orientierung erleichtert.
- Kommentare sind am hilfreichsten, wenn sie das nicht-Offensichtliche erklären
- Wir können davon ausgehen, dass der/die Leser/in herausfinden kann, *was* das Programm macht, daher sollten wir eher erklären *warum* das an der Stelle gemacht wird.
Der folgende Kommentar ist beispielsweise redundant und daher nutzlos:
%% Cell type:code id: tags:
```
v = 5 # v den Wert 5 zuweisen
```
%% Cell type:markdown id: tags:
Dieser Kommentar dagegen enthält nützliche Information, die sich nicht im Quellcode befindet:
%% Cell type:code id: tags:
```
v = 5 # Geschwindigkeit in Meter pro Sekunde
```
%% Cell type:markdown id: tags:
Mit aussagekräftigen Variablennamen können wir uns Kommentare sparen, allerdings werden Ausdrücke durch sehr komplexe oder lange Namen schwer lesbar. Wir müssen also einen guten Mittelweg finden.
Finden Sie heraus, was das folgende Programm tut und fügen Sie aussagekräftige Kommentare hinzu:
Wieviele Kommentare in einem Programm gut und notwendig sind ist durchaus umstritten. Wenn Sie mögen, können Sie einen Ausschnitt des Diskurses dazu hier verfolgen:
- ["Good code is its own best documentation." (Steve McConnell)](http://de.wikipedia.org/wiki/Steve_McConnell)
- ["Yes your Code does need comments" (Mike Grouchy)](http://mikegrouchy.com/blog/2013/03/yes-your-code-does-need-comments.html)

([Programming Elements – Comments](https://prairieworldcomicsblog.wordpress.com/2018/01/26/programming-elements-comments/), William Wise)
%% Cell type:markdown id: tags:
## Debugging
Programme können drei Arten von Fehlern enthalten:
- Syntax-Fehler ("syntax error") – Fehler in der **Syntax**, also der Struktur, des Programmes. Das Programm ist nicht ausführbar bis der Fehler behoben ist. Vor allem zu Beginn, werden Sie vermutlich viele Syntax- Fehler machen, zum Beispiel in dem Sie eine Klammer vergessen. Je mehr Übung Sie haben, desto weniger Syntax-Fehler werden Sie machen. Zudem werden Sie diese auch schneller finden.
- Laufzeit-Fehler ("runtime error") – Laufzeit-Fehler treten erst auf, während das Programm läuft. Sie werden auch **exceptions** genannt, da sie üblicherweise bedeuten, dass etwas außergewöhnliches (und schlechtes) passiert ist. In einfachen Programmen sind Laufzeitfehler selten, Sie werden Ihnen vermutlich noch eine Weile nicht begegnen.
- Semantische Fehler sind Fehler in der **Semantik** – also Fehler, die mit der Bedeutung des Programms zusammenhängen. Das Programm läuft ohne eine Fehlermeldung auszugeben, aber das Ergebnis ist nicht so wie erwartet. Das Programm tut genau das, was Sie ihm gesagt haben. Semantische Fehler zu finden ist schwierig, da von der Ausgabe aus rückwärts durch das Programm gearbeitet werden muss. Häufig ist es hilfreich zusätzliche `print`-Anweisungen einzufügen, die Zwischenergebnisse ausgeben, sodass der Punkt gefunden werden kann, an dem die erwarteten Ergebnisse von den tatsächlichen abweichen.
%% Cell type:markdown id: tags:
## Glossar
Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 2 gelernt haben:
- Variable:
- Zuweisung: Eine Zuweisung ist eine Anweisung, bei der einer Variable ein Wert zugewiesen wird
- Schlüsselwort:
- Ausdruck:
- Zeichenketten verknüpfen:
- Kommentar:
- Syntaxfehler:
- Laufzeitfehler:
- semantischer Fehler:
- `print`-Funktion:
Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit.
%% Cell type:markdown id: tags:
## `print` Tutorial
Hier lernen Sie einige Tricks kennen, um mit der `print`-Funktion ihre Ausgabe formatieren können.
Bis jetzt haben Sie gelernt, dass man sich mit Hilfe der `print`-Funktion Zeichenketten, Zahlen, Variablen, etc. ausgeben lassen kann.
Zeichenketten müssen dabei immer in Anführungszeichen stehen.
%% Cell type:code id: tags:
```
print("Hallo Welt!")
print(42)
print(52-10)
```
%% Cell type:markdown id: tags:
Man kann auch mehrere Argumente übergeben, diese müssen durch ein Komma getrennt werden.
Die Ausgabe erfolgt mit einem Leerzeichen getrennt.
%% Cell type:code id: tags:
```
print(42, 35.32-9.0, "Hallo Welt")
```
%% Cell type:markdown id: tags:
und natürlich können Sie sich auch Variablen ausgeben lassen:
%% Cell type:code id: tags:
```
a = 42
b = "Die Antwort lautet:"
print(b,a)
```
%% Cell type:markdown id: tags:
Um längere Ausgaben, mehrere Variablen ,etc. schöner zu formatieren, gibt es einige Tricks.
Einmal kann man der Funktionen einen extra Parameter übergeben, der einstellt, durch welches Zeichen die verschiedenen Argumente getrennt werden sollen.
Standardmäßig und wie oben gesehen, wird die Ausgabe mehrerer Argumente jeweils durch ein Leerzeichen getrennt.
Durch Hinzufügen des Parameter `print(b,a ,sep=" ")` (MERKE: `sep` steht für `separator`) können Sie spezifizieren, welches Zeichen als Trennzeichen genommen wird. Schauen wir uns einige Beispiele an:
%% Cell type:code id: tags:
```
a = 42
b = "Die Antwort lautet:"
# wenn `sep` nicht angegeben ist, wird standardmäßig ein Leerzeichen zwischen den Argumenten in `print` verwendet
print(b,a)
# Jetzt geben wir explizit an, dass der separator ein Leerzeichen sein soll, d.h., die Ausgabe ändert sich nicht.
print(b,a, sep = " ")
# Jetzt soll der separator zwei Leerzeichen sein:
print(b,a, sep = " ")
# und jetzt soll der separator ein `tab` (4 Leerzeichen) sein, das wird durch `\t`angegeben
print(b,a, sep = "\t")
# nun soll der separator ein Zeilenumbruch sein, das wird durch `\n`angegeben
print(b,a, sep = "\n")
# zum schluss kann man noch triple quotes (drei Anführungszeichen am Anfang und drei am Ende) nutzen,
# um Text in mehreren Zeilen zu schreiben: ''' '''
print('''
Erste Zeile
Zweite Zeile
''')
```
%% Cell type:markdown id: tags:
Die Befehle `\t`und `\n` funktionieren auch innerhalb einer Zeichenkette:
%% Cell type:code id: tags:
```
print("Hallo \t Welt,\n die Antwort lautet\n42")
```
%% Cell type:markdown id: tags:
## Übung
### Aufgabe 1
Wenn wir etwas neues lernen, sollten wir es immer gleich ausprobieren. Wir sollten auch versuchen absichtlich ein paar Fehler einzubauen, um zu schauen, was dann passiert und zu lernen, wie die Fehlermeldungen aussehen.
- Wir haben gesehen, dass `n = 42` erlaubt ist. Was ist mit `42 = n`?
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
- Und wie sieht es mit `x = y = 1` aus? (Lassen Sie sich danach die Werte für `x` und `y` mit Hilfe der `print`-Funktion ausgeben.)
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
- In einigen Programmiersprachen müssen Anweisungen mit einem Semikolon (;) beendet werden. Was passiert, falls wir in Python ein Semikolon ans Ende einer Anweisung schreiben?
%% Cell type:markdown id: tags:
- Und was passiert, wenn wir einen Punkt (.) ans Ende einer Anweisung schreiben?
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
### Aufgabe 2
Nutzen Sie Python als Taschenrechner. Denken Sie auch hier wieder daran, dass wir nicht zwingend Ihre mathematischen Fähigkeiten testen wollen. Nutzten Sie erst die Hinweise und versuchen Sie einander zu helfen aber zögern Sie nicht uns zu fragen. Es ist wichtiger, dass Sie verstehen, wie Sie die Aufgabe in Python umsetzen als die mathematischen Grundlagen zu verstehen.
- Wie groß ist das Volumen einer Kugel mit dem Radius 5?
- Angenommen, der Preis des Buches "Once upon an Algorithm" ist 29,99€, aber wir bekommen es mit 40% Rabatt, weil wir eine Bildungseinrichtung sind. Der Versand kostet 3€ für das erste Buch und 0,75€ für jedes weitere Buch. Wir wollen 60 Exemplare für das IBI bestellen - was kostet uns das insgesamt?
- Wenn ich mein Haus um 6:52 Uhr verlasse und 1 Kilometer gemütlich laufe (8:15 Minuten pro Kilometer), dann 3 Kilometer schneller (7:12 Minuten pro Kilometer) und dann nochmal 1 Kilometer gemütlich, wann komme ich dann zum Frühstück an?
1. Konvertieren Sie die Zeit von Minuten zu Sekunden. Wie viele Sekunden werden für einen gemütlichen Kilometer benötigt, wie viele für einen schnellen?
2. Wie viele Sekunden brauchen Sie insgesamt. Muliplizieren Sie Ihre Sekundenanzahlen mit der Anzahl an Kilometern.
3. Konvertieren Sie die Sekunden zurück in Minuten. Mit '//' können Sie eine Division durchführen, in der der Rest ignoriert wird und mit '%' erhalten Sie dann den Rest.
4. Addieren Sie die Zeit, die der Sprecher unterwegs ist zur Startzeit. Achten Sie dabei darauf, dass die Minutenanzahl sinnvoll ist.... (Das also nicht zum Beispiel 6:62 als Ergebnis herauskommt, sondern dies zu 7:02 ungewandelt würde)
</div>
</details>
%% Cell type:code id: tags:
```
# Geben Sie hier Ihren Ausdruck zur Berechnung ein
 Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (nicht auf einem Pool-Rechner). Rufen Sie dazu im Menü "File" den Punkt "Download as"->"Notebook" auf und nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/).
%% Cell type:markdown id: tags:
Herzlichen Glückwunsch! Sie haben das 2. Kapitel geschafft!