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
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:
```
print("Wird noch ausgefüllt.")
```
%% Cell type:markdown id: tags:
## 2: Variablen, Ausdrücke und Anweisungen
Weiter geht es in [Kapitel 2](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.
### Zuweisung
Die **Zuweisung** ist eine besondere Form der Anweisung. Sie erzeugt eine neue Variable (falls Sie nicht schon existierte) und gibt ihr einen Wert:
%% 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:
1. die erste weist die Zeichenkette `"Das ist ein ganz einfacher Mechanismus."` einer Variable mit dem Namen `nachricht` zu
2. die zweite weist die Zahl `17` der Variablen `n` zu und
3. 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/in sollten wir Namen wählen, die aussagekräftig sind und dokumentieren, wofür die Variable (oder Funktion) verwendet wird. Folgende Regeln gelten: Variablennamen
Der Name `0das_gibt_Aerger` ist nicht erlaubt, weil er mit einer Zahl beginnt. Probieren wir ein paar andere Namen aus (führen Sie den Code aus, um die Fehlermeldungen zu sehen):
%% 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.
%% 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
```
%% Cell type:code id: tags:
```
n
```
%% Cell type:code id: tags:
```
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.
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
Prüfen Sie ihr Ergebnis - ist alles korrekt? Notieren Sie hier kurz, welche Schwierigkeiten Ihnen begegnet sind:
-
-
-
### Reihenfolge von Operatoren
Enthält ein Ausdruck mehrere Operatoren, so werden diese in der folgenden Reihenfolge ausgewertet:
- Zuerst werden Klammern ausgewertet (wie in der Mathematik dürfen wir Klammern verwenden, um die Reihenfolge bei der Berechnung festzulegen):
%% Cell type:code id: tags:
```
2 * (3-1)
```
%% Cell type:markdown id: tags:
ist also 4 und
%% Cell type:code id: tags:
```
(1+1)**(5-2)
```
%% Cell type:markdown id: tags:
ist 8
- 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 (ausser 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 5 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:
%% Cell type:code id: tags:
```
'2' - '1'
```
%% Cell type:code id: tags:
```
'acht' / 'zwei'
```
%% Cell type:markdown id: tags:
Es gibt aber zwei Ausnahmen: `+` und `*`:
%% 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 Zeichenketten verknüpfen (oder verketten). D.h., die beiden Zeichenketten werden hinereinander geschrieben.
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:
```
```
%% 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.1415926
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 # assign 5 to v
```
%% 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:
Übrigens können wir uns mit aussagekräftigen Variablennamen auch Kommentare sparen. (Andererseits werden Ausdrücke durch sehr lange Namen auch schwerer 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:
Exkurs: 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://en.wikipedia.org/wiki/Steve_McConnell))
Programme können drei Arten von Fehlern enthalten:
- Syntax-Fehler ("syntax error")
- Laufzeit-Fehler ("runtime error")
- Semantische Fehler
Lesen Sie mehr zu den Unterschieden in [Abschnitt 2.8](http://greenteapress.com/thinkpython2/html/thinkpython2003.html#sec23).
%% 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:
- Schlüsselwort:
- Ausdruck:
- Zeichenketten verknüpfen:
- Kommentar:
- Syntaxfehler:
- Laufzeitfehler:
- semantischer Fehler:
Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit.
%% 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.
- 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 schaut 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:code id: tags:
```
```
%% 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:
- Das Volumen einer Kugel mit dem Radius r ist 4/3 π r³. Wie groß ist das Volumen einer Kugel mit dem Radius 5?
%% Cell type:code id: tags:
```
# Geben Sie hier Ihren Ausdruck zur Berechnung ein
```
%% Cell type:markdown id: tags:
- 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?
%% Cell type:code id: tags:
```
# Geben Sie hier Ihren Ausdruck zur Berechnung ein
```
%% Cell type:markdown id: tags:
- Wenn ich mein Haus um 6:52 Uhr verlasse und 1 Meile gemütlich laufe (8:15 Minuten pro Meile), dann 3 Meilen schneller (7:12 Minuten pro Meile) und dann nochmal 1 Meile gemütlich, wann komme ich dann zum Frühstück an?
%% Cell type:code id: tags:
```
# Geben Sie hier Ihren Ausdruck zur Berechnung ein
```
%% 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/).
