"Das folgende Skript simuliert ein Request-Objekt in Flask nach dem Versand eines HTML-Formulars. Dabei ist das Ziel, die Daten aus dem Formular in irgendeiner Form weiter zu verarbeiten."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Die Eigenschaft `request.form` ist nach dem Versand eines Formular ein `ImmutableMultiDict`. Das ist ein besonderer Datentyp in Flask, der auf einer Klasse aus [werkzeug](http://werkzeug.pocoo.org/docs/0.12/) basiert.\n",
"\n",
"Daher weisen wir zunächst einer Variablen ein so genanntes [MultiDict](http://werkzeug.pocoo.org/docs/0.12/datastructures/#werkzeug.datastructures.MultiDict) zu, das im Kontext von Flask ein komplexer Datentyp ist. Er hat die Form einer [Liste](https://docs.python.org/2/tutorial/introduction.html#lists) von [Tupeln](https://docs.python.org/2/tutorial/datastructures.html#tuples-and-sequences)."
"Nun greifen wir zum Warmwerden auf die Werte dieser Variablen zu."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hund\n"
]
}
],
"source": [
"print(form_data['tier'])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.4.3"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
%% Cell type:markdown id: tags:
# Das Request-Objekt in Flask
Das folgende Skript simuliert ein Request-Objekt in Flask nach dem Versand eines HTML-Formulars. Dabei ist das Ziel, die Daten aus dem Formular in irgendeiner Form weiter zu verarbeiten.
%% Cell type:markdown id: tags:
Die Eigenschaft `request.form` ist nach dem Versand eines Formular ein `ImmutableMultiDict`. Das ist ein besonderer Datentyp in Flask, der auf einer Klasse aus [werkzeug](http://werkzeug.pocoo.org/docs/0.12/) basiert.
Daher weisen wir zunächst einer Variablen ein so genanntes [MultiDict](http://werkzeug.pocoo.org/docs/0.12/datastructures/#werkzeug.datastructures.MultiDict) zu, das im Kontext von Flask ein komplexer Datentyp ist. Er hat die Form einer [Liste](https://docs.python.org/2/tutorial/introduction.html#lists) von [Tupeln](https://docs.python.org/2/tutorial/datastructures.html#tuples-and-sequences).
Jede Skript- oder Programmiersprache besteht aus Bestandteilen, die man wie die Zutaten der Küche eines bestimmten Landes sehen kann. Es gibt die arabische, die japanische, die mexikanische und die deutsche Küche. Und es gibt PHP, Ruby, C und [viele weitere Programmiersprachen](https://en.wikipedia.org/wiki/Comparison_of_programming_languages). Und es gibt Python.
Um einen kurzen Überblick in die pythonische Küche zu erlangen, wollen wir im folgenden die typischen Zutaten der pythonischen Küche vorstellen und am Ende ein erstes Gericht kochen.
%% Cell type:code id: tags:
``` python
%%HTML
<adata-flickr-embed="true"data-footer="true"href="https://www.flickr.com/photos/chris_fynn/17306765722/in/photolist-snkGus-caHnR1-xu821-rpTLoy-aHVVCa-9HCtuM-5TBbf9-5pdsTN-6uFfXS-as8AVu-ryWb7m-8ENynw-fKgdBp-dcnUCL-969ph6-6jJQy5-ogzafq-6PdEtv-aeQtWj-9Kx2Kf-6CyvD1-8EKodZ-6Pk8DB-7szfrX-6CYNJz-cXoYkw-9X4va3-aeyj55-7WP55r-eQoRR5-dUwpRX-aeyqYh-govHd6-i4dLKh-aeyiMN-begQVa-b7HMoX-8vaDer-7wq3Ya-5ETLwq-5hscmj-aevBiP-8arifu-aevtUv-nBuFiJ-4frgBF-aeybvw-6jED5P-dzEHCi-aeyj9u"title="Mysore - Fruit vendor"><imgsrc="https://c1.staticflickr.com/9/8803/17306765722_a2d0be2f9e_n.jpg"width="320"height="213"alt="Mysore - Fruit vendor"></a><scriptasyncsrc="//embedr.flickr.com/assets/client-code.js"charset="utf-8"></script>
```
%% Output
%% Cell type:markdown id: tags:
## Ausgaben
%% Cell type:code id: tags:
``` python
print("Hallo Welt!")
```
%% Output
Hallo Welt!
%% Cell type:markdown id: tags:
Damit sagen wir der Community der Pythonköchinnen und -köche, dass wir jetzt auch dabei sind. Außerdem gibt uns dieser Ausgabebefehl in Zukunft die Möglichkeit, in der Richtung *Maschine -> Mensch* zu kommunizieren. Mit `print()` können also Ergebnisse von Berechnungen, Eingabeaufforderungen u.ä. ausgegeben werden.
%% Cell type:markdown id: tags:
## Kommentare
Kommentare sind nützlich und sinnvoll, wenn sie den Code genauer beschreiben und anderen Menschen Hinweise geben, was ein Programmteil für Aufgaben hat, was in Zukunft noch zu tun ist oder was nicht funktioniert.
%% Cell type:code id: tags:
``` python
# Ein einzeiliger Kommentar
print("Ein Kommentar hat am Anfang eine Raute.")
```
%% Output
Ein Kommentar hat am Anfang eine Raute.
%% Cell type:markdown id: tags:
## Variablen und Datentypen
**Variablen** speichern Werte, die wir häufiger in unseren Programmen brauchen. Diese verschiedenen Arten von Daten werden **Datentypen** genannt.
%% Cell type:markdown id: tags:
### Numbers
%% Cell type:markdown id: tags:
Hier haben wir eine Ganzzahl, auch Integer genannt, in der Variablen `sinn_des_lebens` gespeichert. Ganzzahlen gehören in Python zum Datentyp **Numbers**.
%% Cell type:code id: tags:
``` python
sinn_des_lebens=42
print(sinn_des_lebens)
```
%% Output
42
%% Cell type:code id: tags:
``` python
print(42+3)
```
%% Output
45
%% Cell type:markdown id: tags:
Hier haben wir eine Fließkommazahl gespeichert und ausgegeben. Auch sie gehört zu den **Numbers**.
%% Cell type:code id: tags:
``` python
preis=1.99
print(preis)
```
%% Output
1.99
%% Cell type:markdown id: tags:
### String (Zeichenkette)
%% Cell type:markdown id: tags:
In Variablen lassen sich sehr unterschiedliche Arten von Werten speichern. Eben haben wir eine Zeichenkette, auch **String** genannt, in der Variablen `tier` gespeichert.
%% Cell type:code id: tags:
``` python
tier="Giraffe"
print(tier)
```
%% Output
Giraffe
%% Cell type:markdown id: tags:
### Liste
%% Cell type:markdown id: tags:
Jetzt haben wir eine **Liste** in der Variablen `tiere` gespeichert und wieder ausgegeben.
%% Cell type:code id: tags:
``` python
tiere=["Giraffe","Salamander","Iltis"]
print(tiere)
```
%% Output
['Giraffe', 'Salamander', 'Iltis']
%% Cell type:markdown id: tags:
### Dictionary (Verzeichnis)
%% Cell type:markdown id: tags:
Dieser Datentyp wird **Dictionary** genannt, weil er wie eine Art Verzeichnis funktioniert: Links stehen die Bezeichner, rechts die dazugehörigen Werte.
%% Cell type:code id: tags:
``` python
elefant={
"name":"Dieter",
"alter":12,
"gewicht":5800
}
print(elefant)
```
%% Output
{'name': 'Dieter', 'gewicht': 5800, 'alter': 12}
%% Cell type:markdown id: tags:
### Boolean (Wahrheitswert)
%% Cell type:markdown id: tags:
`True` und `False` sind die beiden Werte des **boolschen Datentyps**. Mit ihm werden eindeutige Zustände ausgedrückt wie "an" und "aus".
%% Cell type:code id: tags:
``` python
schalter_1=False
schalter_2=True
print(schalter_1)
```
%% Output
False
%% Cell type:markdown id: tags:
### Zusammenfassung und weiterführende Informationen
**Numbers**, **String**, **List**, **Dictionary** und **Boolean** sind *Datentypen* in Python. Es gibt noch viele weitere, die aber an dieser Stelle erst einmal keine Rolle spielen. Sehr ausführlich werden Variablen und Datentypen auf der Website [Datentypen und Variablen](http://www.python-kurs.eu/python3_variablen.php) erläutert.
%% Cell type:markdown id: tags:
Wer lieber einen Film schauen möchte, findet z.B. das Thema **Listen** gut erklärt im folgenden Video. Auf Youtube gibt es noch mehr Filme dieser Art.
Man spricht von einer Fallunterscheidung oder bedingten Anweisung, wenn ein Codeblock an eine Bedingung geknüpft ist. Der Codeblock wird folglich nur ausgeführt, wenn die Bedingung erfüllt wird.
Eine **bedingte Anweisung** wird mit `if` formuliert:
%% Cell type:code id: tags:
``` python
kartoffeln=3
ifkartoffeln>=4:
print("Es gibt Kartoffelsalat.")
```
%% Cell type:markdown id: tags:
In Z1 wird der Variablen `kartoffeln` der Wert `3` zugewiesen. In Z3 wird geprüft, ob es vier oder mehr Kartoffeln gibt. Wenn ja, reicht es für Kartoffelsalat. Es reicht nicht...
%% Cell type:markdown id: tags:
Will man auch eine Ausgabe sehen, wenn die Kartoffeln nicht für den Salat reichen, ist eine **Verzweigung** angebracht:
%% Cell type:code id: tags:
``` python
kartoffeln=3
ifkartoffeln>=4:
print("Es gibt Kartoffelsalat.")
else:
print("Die Kartoffeln reichen nicht. Leider.")
```
%% Output
Die Kartoffeln reichen nicht. Leider.
%% Cell type:markdown id: tags:
Eine weitere Variante von Verzweigungen ist möglich, wenn mehr Zweige gebraucht werden:
%% Cell type:code id: tags:
``` python
kartoffeln=3
ifkartoffeln>=4:
print("Es gibt Kartoffelsalat.")
elifkartoffeln==3:
print("Das gibt genau einen Kartoffelpuffer.")
else:
print("Die Kartoffeln reichen nicht. Leider.")
```
%% Output
Das gibt genau einen Kartoffelpuffer.
%% Cell type:markdown id: tags:
Mit bedingten Anweisungen und Verzweigungen haben wir sozusagen die Kartoffel der pythonischen Küche kennengelernt. Diese **Kontrollstruktur** ermöglicht es, ein Programm den Umständen bzw. Bedingungen entsprechend unterschiedliche Pfade einzuschlagen.
%% Cell type:markdown id: tags:
## Operatoren
In den meisten Programmiersprachen gibt es Operatoren, die - wie der Name schon sagt - Operationen mit den Daten eines Programms ermöglichen. In dem letzten Beispiel oben kommen z.B. die **Vergleichsoperatoren**`==` und `>=` vor. Außerdem gibt es noch **Rechenoperatoren** für die Grundrechenarten, `+`, `-`, `*` und `/`. Weitere Operatoren sind [in entsprechenden Onlinereferenzen zu finden](http://www.python-kurs.eu/python3_operatoren.php).
%% Cell type:markdown id: tags:
## Schleifen
Mit Schleifen können Vorgänge in Programmen wiederholt werden. In der Regel hat eine Schleife eine *Abbruchbedingung*. Wenn diese erfüllt ist, wird die Schleife verlassen und das Programm danach fortgesetzt.
%% Cell type:markdown id: tags:
### for-Schleife
Die **for-Schleife** wird eingesetzt, wenn die Anzahl der Male, die sie laufen soll, bekannt ist.
%% Cell type:code id: tags:
``` python
tiere=['Hund','Katze','Maus']
fortierintiere:
print(tier)
```
%% Output
Hund
Katze
Maus
%% Cell type:markdown id: tags:
Hier werden die Elemente einer Liste von Anfang bis Ende durchlaufen. `tier` ist dabei immer der aktuelle Wert in einem Durchlauf. Wenn die Liste komplett durchlaufen wurde, wird die Schleife verlassen und das Programm danach fortgesetzt.
%% Cell type:markdown id: tags:
Es gibt noch weitere Schleifen, die aber an dieser Stelle noch nicht so wichtig sind. Interessierte können darüber [online nachlesen](http://www.python-kurs.eu/python3_schleifen.php).
%% Cell type:markdown id: tags:
## Funktionen
Funktionen schließen Programmteile ein, die häufiger verwendet werden. Man sagt auch, die Programmteile werden *gekapselt*. Nach außen sind diese teilweise sehr komplexen Programmteile unter einem sinnvollen und aufschlussreichen Namen erreichbar.
Zunächst muss eine Funkion definiert werden:
%% Cell type:code id: tags:
``` python
importtime
# Funktionsdefinition
defberechne_tagesabschnitt():
zeitstempel=time.time()
# print("{} Sekunden sind seit 1970 vergangen.".format(zeitstempel))
Das Programm ist absichtlich etwas komplexer, um einige Dinge zeigen zu können:
1. Es wird ein so genanntes Modul importiert: `time`
1. Es wird von Variablen Gebrauch gemacht, die verschiedene Zwischenergebnisse speichern.
1. Es werden Funktionen verwendet, die schon in Python "eingebaut" sind: `time()`, `localtime()` und `print()`.
1. Es wird eine Verzweigung verwendet, die einen Wert untersucht und danach entscheidet, wie das Programm weitergeht.
1. Es werden verschiedene Ausgaben getätigt.
%% Cell type:markdown id: tags:
Man könnte sagen, dass für die Ausgabe "Es ist..." ziemlich viel Aufwand getrieben wird. Dieser Aufwand wird aber in der Funktion `berechne_tagesabschnitt()` gekapselt. Diese wird zunächst mit dem Schlüsselwort `def`*definiert*. Deshalb spricht man hier auch von der *Funktionsdefinition*.
%% Cell type:markdown id: tags:
Um nun von der Funktion Gebrauch machen zu können, muss sie aufgerufen werden. Dies geschieht mit dem *Funktionsaufruf* in Z25.
%% Cell type:markdown id: tags:
### Funktionen mit Parametern
Funktionen machen dann erst richtig Spaß, wenn man ihnen Argumente übergeben kann. Dafür muss die erste Zeile einer Funktion, die *Funktionssignatur*, Parameter enthalten, die Argumente beim Funktionsaufruf auffangen können.
%% Cell type:code id: tags:
``` python
defverdoppeln(zahl):
print(zahl*2)
verdoppeln(4)
```
%% Output
8
%% Cell type:markdown id: tags:
Die Funktion stellt einen Parameter bereit, der einen übergebenen Wert "auffängt" wie ein Eimer. Dieser wird dann innerhalb der Funktion, im *Funktionsrumpf* weiterverarbeitet.
Beim Funktionsaufruf wird eine beliebige Zahl übergeben, und egal welche es ist, die Funktion verdoppelt sie und gibt das Ergebnis aus.
%% Cell type:markdown id: tags:
### Funktionen mit Rückgabewert
Die zunächst letzte Variante von Funktionen liefert nach getaner Arbeit einen Wert zurück.
%% Cell type:code id: tags:
``` python
defverdoppeln(zahl):
returnzahl*2
ergebnis=verdoppeln(4)
```
%% Cell type:markdown id: tags:
Hier wird das Ergebnis der Verdopplung nicht sofort ausgegeben, sondern zunächst mit `return` an die aufrufende Stelle zurückgegeben. Dort muss der Rückgabewert in einer Variablen gespeichert werden, da er sonst verloren geht. Mit der Variablen `ergebnis` kann nun in der Folge des Programms weitergearbeitet werden. Eine Ausgabe erfolgt also ggf. später.
%% Cell type:markdown id: tags:
## Zusammenfassung
Die pythonische Küche verfügt noch über weit mehr Zutaten und Techniken, die in diesem Crashkurs Python nicht alle genannt werden können. Es wurden jedoch einige wesentliche Teile der Programmiersprache vorgestellt, die für den Bau von Webseiten z.B. mit [Flask](http://flask.pocoo.org/) zunächst ausreichend sind.
