{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Programmierung in Python \n",
"\n",
"**Univ.-Prof. Dr. Martin Hepp,** Universität der Bundeswehr München\n",
"
\n",
"\n",
"## Einheit 1: Erste Schritte in Python \n",
"**Version: 2020-02-05**\n",
"
\n",
"[**http://www.ebusiness-unibw.org/wiki/Teaching/PIP**](http://www.ebusiness-unibw.org/wiki/Teaching/PIP)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Syntaktische Konventionen\n",
"\n",
"### Keine Zeilenummern"
]
},
{
"cell_type": "markdown",
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"**Ohne Zeilennummern:
**\n",
"(Python etc.)\n",
"```python\n",
"a = 1\n",
"b = 2\n",
"print(a)\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"**Mit Zeilennummern:
**\n",
"(nur in älteren Sprachen)\n",
"```\n",
"10 a = 1\n",
"20 b = 2\n",
"30 print(a)```"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Groß-/Kleinschreibung\n",
"Groß-/Kleinschreibung muss beachtet werden:\n",
"```python\n",
" a = 10 # die Variable a wird definiert\n",
" print(A) # die Variable A gibt es aber nicht\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Reservierte Namen\n",
"Namen, die für Befehle etc. verwendet werden, dürfen nicht als Namen für Werte oder Objekte genutzt werden.\n",
"\n",
"Es gibt\n",
"- **Schlüsselwörter** für echte Sprachelemente (\"keywords\")\n",
"und\n",
"- **Namen für vordefinierte Objekte und Methoden** (\"Built-ins\")."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Schlüsselwörter für echte Sprachelemente (\"keywords\")**"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"Here is a list of the Python keywords. Enter any keyword to get more help.\n",
"\n",
"False class from or\n",
"None continue global pass\n",
"True def if raise\n",
"and del import return\n",
"as elif in try\n",
"assert else is while\n",
"async except lambda with\n",
"await finally nonlocal yield\n",
"break for not \n",
"\n"
]
}
],
"source": [
"help('keywords')"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Namen für vordefinierte Objekte und Methoden (\"Built-ins\")**"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ArithmeticError AssertionError AttributeError BaseException \n",
"BlockingIOError BrokenPipeError BufferError BytesWarning \n",
"ChildProcessError ConnectionAbortedError ConnectionError ConnectionRefusedError \n",
"ConnectionResetError DeprecationWarning EOFError Ellipsis \n",
"EnvironmentError Exception False FileExistsError \n",
"FileNotFoundError FloatingPointError FutureWarning GeneratorExit \n",
"IOError ImportError ImportWarning IndentationError \n",
"IndexError InterruptedError IsADirectoryError KeyError \n",
"KeyboardInterrupt LookupError MemoryError ModuleNotFoundError \n",
"NameError None NotADirectoryError NotImplemented \n",
"NotImplementedError OSError OverflowError PendingDeprecationWarning \n",
"PermissionError ProcessLookupError RecursionError ReferenceError \n",
"ResourceWarning RuntimeError RuntimeWarning StopAsyncIteration \n",
"StopIteration SyntaxError SyntaxWarning SystemError \n",
"SystemExit TabError TimeoutError True \n",
"TypeError UnboundLocalError UnicodeDecodeError UnicodeEncodeError \n",
"UnicodeError UnicodeTranslateError UnicodeWarning UserWarning \n",
"ValueError Warning ZeroDivisionError __IPYTHON__ \n",
"__build_class__ __debug__ __doc__ __import__ \n",
"__loader__ __name__ __package__ __spec__ \n",
"abs all any ascii \n",
"bin bool breakpoint bytearray \n",
"bytes callable chr classmethod \n",
"compile complex copyright credits \n",
"delattr dict dir display \n",
"divmod enumerate eval exec \n",
"filter float format frozenset \n",
"get_ipython getattr globals hasattr \n",
"hash help hex id \n",
"input int isinstance issubclass \n",
"iter len license list \n",
"locals map max memoryview \n",
"min next object oct \n",
"open ord pow print \n",
"property range repr reversed \n",
"round set setattr slice \n",
"sorted staticmethod str sum \n",
"super tuple type vars \n",
"zip \n"
]
}
],
"source": [
"import builtins\n",
"seq = list(dir(builtins))\n",
"seq.sort()\n",
"max_len = len(max(seq, key=len))\n",
"chunks = [seq[pos:pos + 4] for pos in range(0, len(seq), 4)]\n",
"for chunk in chunks:\n",
" print(\"\".join([item.ljust(max_len + 1) for item in chunk]))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Zuweisungs- und Vergleichsoperator\n",
"Die meisten Programmiersprachen unterscheiden zwischen"
]
},
{
"cell_type": "markdown",
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "-"
}
},
"source": [
"- **Zuweisung** (\"a soll den Wert 5 erhalten\")\n",
"und\n",
"- **Vergleich** (\"Entspricht a dem Wert 5?\")\n",
"von Werten und Ausdrücken."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"# Python\n",
"\n",
"# Zuweisung\n",
"a = 5\n",
"# Vergleich \n",
"# Entspricht a dem Wert 5?\n",
"print(a == 5)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Stil und Formatierung\n",
"### Namen\n",
"Namen für Werte (in anderen Programmiersprachen \"Variablen\") sollten aussagekräftig und ohne Umlaute gewählt werden.\n",
"```python\n",
"dauer = 5\n",
"zins = 0.01```"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Wenn der Name aus mehreren Wörtern besteht, werden diese durch einen Unterstrich (\\_) verbunden:\n",
"```python\n",
"dauer_in_jahren = 5```\n",
"\n",
"Variablennamen sollten stets in **Kleinbuchstaben** sein."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"Für Konstanten verwendet man dagegen Namen in Großbuchstaben:\n",
"```python\n",
"PI = 3.1415\n",
"ABSOLUTER_NULLPUNKT = -273.15 # Grad Celsius```"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Leerzeichen\n",
"Vor und nach Operanden wie + oder - gehört jeweils ein Leerzeichen:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"zins = 1 + 0.02"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"source": [
"Unnötige Einrückungen sind nicht erlaubt:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"zins = 1 + 0.02\n",
" zinseszins = guthaben * (1 + zins)**4"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Stilistische Konventionen**\n",
"\n",
"- Keine sonstigen unnötigen Leerzeichen, besonders nicht am Zeilenende.\n",
"- Unnötige Leerzeilen nur sparsam verwenden.\n",
"- Es gibt noch weitere stilistische Konventionen:\n",
" - [PEP 8](https://www.python.org/dev/peps/pep-0008/)\n",
" - [Google Python Styleguide](http://google.github.io/styleguide/pyguide.html)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Grundlegende Datenstrukturen\n",
"\n",
"- Alles in Python ist genaugenommen ein Objekt - jeder Wert, jedes Unterprogramm etc. \n",
"\n",
"- Alle Objekte, also auch Werte liegen irgendwo im Arbeitsspeicher des Computers.\n",
"\n",
"- Die Position nennt man die **Adresse**. Sie entspricht der Nummer der Speicherzelle, an der die Daten abgelegt sind, die das Objekt repräsentieren."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Namen und Objekte\n",
"#### Alles in Python ist ein Objekt\n",
"- Objekte können, müssen aber keinen Namen haben.\n",
"```python\n",
"print(\"Hallo Welt\")\n",
"print(42)```\n",
"- Hier haben die Zeichenfolge \"Hallo Welt\" und die Zahl 42 keinen Namen, sind aber trotzdem Objekte mit einer Adresse."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Die Adresse eines Objektes im Speicher kann man mit der Funktion `id(name)` zeigen:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" \n",
"4579809392 4541229456\n"
]
}
],
"source": [
"print(type(\"Hallo Welt\"), type(42))\n",
"print(id(\"Hallo Welt\"), id(42))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"- `str` und `int` sind die Typen der Objekte\n",
"- str/String = Zeichenkette und int/Integer = Ganzzahl\n",
"- Die Zahlen darunter sind die Adressen des Objektes."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Objekte _können_ Namen haben"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"mein_text = \"Hallo Welt\"\n",
"meine_zahl = 42"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"Diese Namen verweisen auf die **Adresse** des Objektes:"
]
},
{
"cell_type": "code",
"execution_count": 117,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"4579625328\n",
"4541229456\n"
]
}
],
"source": [
"print(id(mein_text))\n",
"print(id(meine_zahl))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Das ist ein wesentlicher Unterschied zu anderen Programmiersprachen.\n",
"In Python führt eine Anweisung wie\n",
"```python\n",
"variable = 1234```\n",
"nicht dazu, dass eine Variable ***erzeugt*** wird, die mit dem Wert 1234 ***initial gefüllt*** wird."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Stattdessen wird geprüft, ob es das Objekt der Zahl 1234 schon gibt. Falls nicht, wird eines im Speicher erzeugt. \n",
"Dann wird die Adresse dieses Objektes als Verweis dem Namen `variable` zugewiesen, also damit verbunden.\n",
"\n",
"Der Name `variable` wird also mit dem Objekt/Wert verbunden.\n",
"\n",
"[\\[vgl. Fredrik Lundh: Call by Object\\]](http://effbot.org/zone/call-by-object.htm)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Mehrere Anweisungen wie\n",
"```python\n",
"zahl_1 = 42\n",
"zahl_2 = 42\n",
"zahl_3 = 42\n",
"```\n",
"führen in der Regel (*) daher nicht dazu, dass drei Variablen erzeugt werden, \n",
"sondern dass drei Namen definiert werden, über die man die Ganzzahl 42 ansprechen kann.\n",
"\n",
"(*) Im Detail hängt das davon ab, ob Python schnell feststellen kann, ob es diesen Wert schon im Speicher gibt."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Mehrfachzuweisung\n",
"Man kann übrigens auch in einer Anweisung mehrere Namen für ein und dasselbe Objekt definieren:"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"a = b = c = 3"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"**Verständnischeck:**\n",
"Wenn wir nun \n",
"```python\n",
"b = 4```\n",
"ausführen, was passiert?"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3 3 3\n",
"3 4 3\n"
]
}
],
"source": [
"a = b = c = 3\n",
"print(a, b, c)\n",
"b = 4\n",
"print(a, b, c)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Nur der Wert von `b` ändert sich, weil die Verweise der anderen Namen nicht berührt werden."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Mutable und Immutable Objects\n",
"Es gibt in Python Objekte, \n",
"- die man verändern kann (**\"Mutable Objects\"**), und \n",
"- solche, die unveränderlich sind (**\"Immutable Objects\"**). \n",
"\n",
"Zahlen und Zeichenketten sind unveränderlich."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Das heißt aber nicht, dass man den Wert von Variablen dieser Typen nicht ändern könnte:"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Uni\n",
"FH\n"
]
}
],
"source": [
"text = \"Uni\"\n",
"print(text)\n",
"text = \"FH\"\n",
"print(text)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"2\n"
]
}
],
"source": [
"zahl = 1\n",
"print(zahl)\n",
"zahl = zahl + 1\n",
"print(zahl)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"Hier wird jeweils nicht die Variable mit einem neuen **Wert** überschrieben, sondern der neue Wert als neues Objekt erzeugt und die Variable (der Name) **mit der Adresse des neuen Objektes verbunden.**"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Ausgabe mit `print`\n",
"Man kann den Wert jeder Variable und jeden mathematischen Ausdruck mit dem Befehl `print()` auf dem Bildschirm anzeigen lassen:"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"5\n",
"Hallo\n",
"Toll!\n"
]
}
],
"source": [
"print(1 + 4)\n",
"print('Hallo')\n",
"print('Toll!')"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"cell_style": "split"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1 15 Hallo 10.3\n"
]
}
],
"source": [
"# Mehrere Werte werden\n",
"# durch Kommata getrennt\n",
"print(1, 5 * 3, 'Hallo', 10.3)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Numerische Werte\n",
"Numerische Werte, wie\n",
"- Zahlen wie 5 oder -1.23\n",
"- Mathematische Konstanten wie $\\pi$ oder $e$\n",
"- Unendlich ($\\infty/-\\infty$) und Not-a-Number\n",
"sind die häufigsten Arten von Objekten in den meisten Programmen."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Ganze Zahlen\n",
"Ganze Zahlen werden in Python durch den Datentyp `int` repräsentiert und können beliebig große Werte annehmen (vgl. [Numeric Types — int, float, complex](https://docs.python.org/3/library/stdtypes.html#typesnumeric))."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"a = 15\n",
"b = -7\n",
"c = 240"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Man kann auch eine andere Basis als 10 wählen und dadurch elegant **Binärzahlen** und **Hexadezimalzahlen** erzeugen:"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"15 240\n"
]
}
],
"source": [
"# Binärzahlen\n",
"a = 0b00001111\n",
"# Hexadezimalzahlen\n",
"c = 0xF0\n",
"print(a, c)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Gleitkommazahlen\n",
"Wenn ein übergebener Wert einen Dezimalpunkt oder einen Exponenten enthält, wird daraus in Python ein Objekt vom Typ `float` erzeugt. "
]
},
{
"cell_type": "code",
"execution_count": 118,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.3333333333333333\n",
"1.0\n"
]
}
],
"source": [
"wert_1 = float(1/3)\n",
"print(wert_1)\n",
"print(wert_1 * 3)"
]
},
{
"cell_type": "code",
"execution_count": 120,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.9999999999999998\n"
]
}
],
"source": [
"# Achtung, Genauigkeitprobleme!\n",
"wert_2 = wert_1 / 10000\n",
"print((wert_2 * 10000 * 3))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Bei einem Python-Objekt vom typ `float` handelt es sich (auf fast jedem Computersystem) um eine Gleitkommazahl mit 64 Bit. "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"Die Genauigkeit und der Wertebereich entsprechen daher dem, was in anderen Programmiersprachen der Typ `double` bietet."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Man muss dazu wissen, dass Python in den neueren Versionen versucht, die Beschränkungen von Gleitkommazahlen bei der Ausgabe durch geschickte Rundungsregeln zu verbergen. So wird $1/3$ intern als eine Gleitkommazahl mit einer begrenzten Anzahl an Stellen gespeichert.\n",
"\n",
"Zu den Beschränkungen und Fehlerquellen beim Rechnen mit Gleitkommazahlen vgl. [Floating Point Arithmetic: Issues and Limitations](https://docs.python.org/3/tutorial/floatingpoint.html)."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Dezimalzahlen\n",
"Wenn es wichtig ist, dass Zahlen genau in der gegebenen Genauigkeit gespeichert und verarbeitet werden, sind Dezimalzahlen mit einer festen Stellenzahl besser geeignet.\n",
"\n",
"Dies betrifft insbesondere Geldbeträge.\n",
"\n",
"Weitere Informationen: https://docs.python.org/3/library/decimal.html"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Unendlich ($\\infty$)\n",
"Der Wert unendlich kann in Python auf zwei Wegen erhalten werden:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"positive_infinity = float('inf')\n",
"negative_infinity = float('-inf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"import math\n",
"positive_infinity_2 = math.inf\n",
"negative_infinity2 = -math.inf"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Not-a-Number (NaN)\n",
"Es gibt Operationen, bei denen sich das Ergebnis nicht als reelle Zahl abspeichern lässt. Ferner kann bei der Verarbeitung eigentlich numerischer Werte durch Datenqualitätsprobleme der Fall eintreten, dass einzelne Werte keine Zahlen sind.\n",
"Für diesen Fall gibt es einen besonderen Wert, der sich **NaN** für \"Not a number\" nennt.\n",
"Beispiele:\n",
"- ${\\infty}/{\\infty}$\n",
"- Quadratwurzel aus negativen Werten"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"not_a_number = float('NaN')\n",
"print(100 * not_a_number)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"Der wesentliche Nutzen dieses Wertes besteht darin, dass man die Ungültigkeit einer Berechnung erkennen kann."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"**Hinweis:** Es gibt auch einen Datentyp `None`, der immer dann zurückgeliefert wird, wenn eine Operation 'nichts' ergibt."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Mathematische Operationen"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Arithmetische Operationen"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"a = 1\n",
"b = 2 \n",
"c = 3"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3\n"
]
}
],
"source": [
"# Grundrechenarten\n",
"d = a + b\n",
"print(d)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2\n"
]
}
],
"source": [
"e = c - a\n",
"print(e)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"4\n"
]
}
],
"source": [
"f = b * e\n",
"print(f)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2.0\n",
"2.5\n"
]
}
],
"source": [
"g = f / b\n",
"print(g)\n",
"print(5 / 2)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"**Achtung:** Seit Python 3.0 ist die Standard-Division eine Gleitkommadivision, 5 / 2 ist also 2.5. In früheren Versionen wurde wurde standardmäßig eine ganzzahlige Division durchgeführt, also 5/2 = 2 (Rest 1)."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Potenz\n",
"$x^y$ in Python als `x**y`\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"128\n"
]
}
],
"source": [
"# Potenzfunktionen\n",
"h = 2**7 # 2^7 = 128\n",
"print(h)\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Wurzel\n",
"Direkt in Python gibt es keine Funktion für die Quadratwurzel, weil man dies einfach als Potenzfunktion mit einem Bruch als Exponenten ausdrücken kann:"
]
},
{
"cell_type": "markdown",
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "-"
}
},
"source": [
"$\\sqrt{x} = x^\\frac{1}{2}$\n",
"\n",
"$\\sqrt[3]{x} = x^\\frac{1}{3}$"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"cell_style": "split"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"4.0\n",
"4.0\n"
]
}
],
"source": [
"# Quadratwurzel\n",
"a = 16\n",
"print(a**(1/2))\n",
"print(a**0.5)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Es gibt auch ein spezielles Modul `math` mit zusätzlichen mathematischen Methoden."
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"4.0\n"
]
}
],
"source": [
"import math\n",
"\n",
"a = 16\n",
"print(math.sqrt(a))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Ganzzahlige Division"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2\n"
]
}
],
"source": [
"a = 5\n",
"b = 2\n",
"print(a // b)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Divisionsrest (modulo)\n",
"- **Tip 1:** Nützlich, um zu prüfen, ob eine Zahl gerade ist.\n",
"- **Tip 2:** Auch nützlich, wenn man den Wertebereich einer Zahl begrenzen will."
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n"
]
}
],
"source": [
"# Modulo / Divisionsrest\n",
"print(a % b)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Umwandlung des Datentyps numerischer Werte"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"cell_style": "split"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3\n",
"3\n",
"3\n"
]
}
],
"source": [
"# float als int\n",
"# Was passiert?\n",
"print(int(3.1))\n",
"print(int(3.5))\n",
"print(int(3.8))"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"7.0\n"
]
}
],
"source": [
"# int als float\n",
"print(float(7))"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"cell_style": "center",
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0b11111111\n",
"11111111\n",
"11111111\n",
"\n"
]
}
],
"source": [
"# int als Binärzahl\n",
"print(bin(255))\n",
"\n",
"zahl_als_binaerzahl = bin(255)\n",
"print(zahl_als_binaerzahl[2:])\n",
"print(type(zahl_als_binaerzahl))"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"cell_style": "center",
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0xff\n"
]
}
],
"source": [
"# int als Hexadezimalzahl\n",
"print(hex(255))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Rundung\n",
"Bei der Umwandlung einer Gleitkommazahl in eine Ganzzahl mit `int()`ist die Art der Rundung nicht eindeutig."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"source": [
"#### Runden mit `round()`\n",
"\n",
"Mit der Funktion `round(, )` kann man mathematisch korrekt runden.\n",
"\n",
"Wenn keine Stellenanzahl angegeben wird, wird auf die nächste ganze Zahl gerundet."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Beispiel:**"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"4\n"
]
}
],
"source": [
"# Runden\n",
"# round(value[, n])\n",
"print(round(3.5))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"Der optionale zweite Parameter gibt an, wieviele Nachkommastellen gewünscht werden:"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3.142\n"
]
}
],
"source": [
"# Wir runden Pi auf drei Stellen nach dem Komma\n",
"print(round(3.1415926, 3))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Abrunden mit `math.floor()`\n",
"Mit der Funktion `math.floor()` kann auf die nächstkleinere ganze Zahl abgerundet werden."
]
},
{
"cell_type": "code",
"execution_count": 64,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3\n",
"-4\n"
]
}
],
"source": [
"import math\n",
"\n",
"zahl = 3.8\n",
"print(math.floor(zahl))\n",
"negative_zahl = -3.8\n",
"print(math.floor(negative_zahl))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Aufrunden mit `math.ceil()`\n",
"Mit der Funktion `math.ceil()` kann auf die nächstgrößere ganze Zahl aufgerundet werden."
]
},
{
"cell_type": "code",
"execution_count": 65,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"4\n",
"-3\n"
]
}
],
"source": [
"import math\n",
"\n",
"zahl = 3.8\n",
"print(math.ceil(zahl))\n",
"negative_zahl = -3.8\n",
"print(math.ceil(negative_zahl))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Wahrheitswerte (Boolesche Werte)\n",
"Ähnlich wie wir in der elementaren Algebra mit Zahlen arbeiten, kann man in der sogenannten Booleschen Algebra mit den Wahrheitswerten `wahr(true)` und `unwahr(false)` arbeiten. \n",
"Als Operatoren stehen uns **AND** (Konjunktion), **OR** (Disjunktion), **XOR** (Kontravalenz) und **NOT** (Negation) zur Verfügung. "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Zwei (oder mehr) Boolesche Werte kann man mit den Operatoren AND, OR oder XOR verknüpfen.\n",
"Mit NOT kann man einen Booleschen Wert invertieren:\n",
"\n",
"|a|b|a AND b|a OR b|NOT a|a XOR b|\n",
"|:---:|:---:|:-------:|:------:|:-----:|:-------:|\n",
"|False|False|False|False|True|False|\n",
"|True|False|False|True|False|True|\n",
"|False|True|False|True|True|True|\n",
"|True|True|True|True|False|False|\n",
"\n",
"Praktisch relevant ist dies z.B. bei Suchmaschinen \n",
"\n",
"`\"finde alle Bücher, die entweder 'Informatik' oder 'BWL' im Titel enthalten\"`\n",
"\n",
"und bei Bedingungen in Geschäftsprozessen \n",
"\n",
"`\"Kreditkarte_gültig AND Produkt_lieferbar\"`."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Boolesche Werte und Operatoren in Python"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"cell_style": "split"
},
"outputs": [],
"source": [
"# Wahr und Falsch sind vordefinierte Werte\n",
"# Achtung: Schreibweise!\n",
"a = True\n",
"b = False"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n",
"True\n",
"False\n",
"True\n"
]
}
],
"source": [
"# Logische Operatoren\n",
"print(a and b)\n",
"print(a or b)\n",
"print(not a)\n",
"# Work-around für XOR\n",
"print(bool(a) ^ bool(b))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Boolesche Werte lassen sich in Ganzzahlen umwandeln"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"0\n"
]
}
],
"source": [
"print(int(True))\n",
"print(int(False))"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"140.95\n"
]
}
],
"source": [
"# Ziemlich nützlich bei Berechnungen\n",
"versandkostenpflichtig = True\n",
"versandkosten = 5.95\n",
"nettobetrag = 135.00\n",
"bruttobetrag = nettobetrag + versandkosten * versandkostenpflichtig\n",
"print(bruttobetrag)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Vergleichsoperatoren\n",
"In einem Programm muss man oft den Wert von Objekten vergleichen, z.B. den Lagerbestand mit einer Mindestmenge. Dazu gibt es sogenannte **Vergleichsoperatoren**. Das Ergebnis ist immer ein Boole'scher Wert, also `True` oder `False`. "
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"a = 90\n",
"b = 60\n",
"c = 60"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n"
]
}
],
"source": [
"print(a < b)"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"print(a > b)"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n"
]
}
],
"source": [
"print(a < a)"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"print(a <= a)"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"print(a >= a)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Wertevergleich oder Identitätsvergleich?\n",
"Wenn man Ausdrücke oder Objekte vergleicht, muss man sich überlegen, ob man \n",
"\n",
"1. den **Wert** der Ausdrücke vergleichen will, \n",
"oder \n",
"2. ob geprüft werden soll, ob es sich um **dasselbe Objekt** handelt.\n",
"\n",
"**Wertevergleich mit `a == b`**\n",
"\n",
"**Identitätsvergleich mit `a is b`**"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Bei numerischen Ausdrücken gibt es i.d.R. keinen Unterschied:**"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n",
"True\n"
]
}
],
"source": [
"print(3 * 5 == 15)\n",
"print(3 * 5 is 15)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"Allerdings sollte man sich nicht darauf verlassen, dass derselbe Wert auch durch dasselbe Objekt repräsentiert wird und daher stets Werte vergleichen, wenn man numerische Größen vergleicht, und nicht die Identität der Objekte."
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n",
"True\n"
]
}
],
"source": [
"# Dito bei Strings \n",
"a = \"Text\"\n",
"b = \"Text\"\n",
"print(a == b)\n",
"print(a is b)\n",
"# Warum?"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Bei änderbaren Objekten (Mutables) sieht es aber anders aus:**"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n",
"False\n",
"True\n",
"True\n"
]
}
],
"source": [
"a = [1, 2]\n",
"b = [1, 2]\n",
"c = b\n",
"print(a == b)\n",
"print(a is b)\n",
"print(c == b)\n",
"print(c is b)"
]
},
{
"cell_type": "markdown",
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"Das liegt daran, dass änderbare Objekten im Speicher eigene Plätze einnehmen, weil der Computer ja nicht wissen kann, ob sie immer identisch bleiben. "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Beim Wertevergleich mit == wird automatisch eine Typumwandlung versucht:**"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"print(5 == 5.0)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Beim Identitätsvergleich sind verschiedene Datentypen verschiedene Objekte, selbst wenn sich ihre Werte umwandeln ließen:**"
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n",
"False\n"
]
}
],
"source": [
"print(5 is 5.0)\n",
"print(True is 1)"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n",
"True\n",
"True\n"
]
}
],
"source": [
"# Aber:\n",
"print(5 is int(5.0))\n",
"print(int(True) is 1)\n",
"print(True is bool(1))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Trigonometrische und sonstige mathematische Funktionen\n",
"\n",
"Siehe auch https://docs.python.org/3/library/math.html."
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3.141592653589793\n",
"2.718281828459045\n"
]
}
],
"source": [
"import math\n",
"\n",
"# Pi\n",
"print(math.pi)\n",
"# Eulersche Zahl\n",
"print(math.e)"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"4.0\n",
"0.8939966636005579\n",
"-1.0\n",
"-1.2246467991473532e-16\n",
"8.0\n"
]
}
],
"source": [
"# Quadratwurzel\n",
"print(math.sqrt(16))\n",
"# Sinus\n",
"print(math.sin(90))\n",
"# Cosinus\n",
"print(math.cos(math.pi))\n",
"# Tangens\n",
"print(math.tan(math.pi))\n",
"# Log2\n",
"print(math.log2(256))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Komplexe Datentypen\n",
"Als komplexe Datentypen bezeichnet man solche, die eine adressierbare Struktur an Unterelementen haben."
]
},
{
"cell_type": "markdown",
"metadata": {
"cell_style": "split"
},
"source": [
"- Zeichenketten \n",
"\n",
"| 0 | 1 | 2 |\n",
"| --- | --- | --- |\n",
"| W | O | W |"
]
},
{
"cell_type": "markdown",
"metadata": {
"cell_style": "split"
},
"source": [
"- Listen\n",
"- Dictionaries\n",
"- Tuples\n",
"- Mengen / Sets\n",
"- sonstige, auch benutzerdefinierte Objekte"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Zeichenketten"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {},
"outputs": [],
"source": [
"# Zeichenkette\n",
"my_string_1 = 'UniBwM'\n",
"my_string_2 = \"UniBwM\""
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {},
"outputs": [],
"source": [
"# Die Wahl zwischen einfachen und doppelten Anführungszeichen erlaubt es elegant, \n",
"# die jeweils andere Form innerhalb der Zeichenkette zu verwenden:\n",
"my_string_3 = \"Die Abkürzung für unsere Universität lautet 'UniBwM'.\"\n",
"my_string_3 = 'Die Abkürzung für unsere Universität lautet \"UniBwM\".'"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"# Mehrzeilige Zeichenketten erfordern DREI Anführungszeichen:\n",
"my_long_string_1 = \"\"\"Herr von Ribbeck auf Ribbeck im Havelland,\n",
"Ein Birnbaum in seinem Garten stand,\n",
"Und kam die goldene Herbsteszeit,\n",
"Und die Birnen leuchteten weit und breit,\n",
"Da stopfte, wenn’s Mittag vom Thurme scholl,\n",
"Der von Ribbeck sich beide Taschen voll,\n",
"Und kam in Pantinen ein Junge daher,\n",
"So rief er: 'Junge, wist’ ne Beer?'\n",
"Und kam ein Mädel, so rief er: 'Lütt Dirn'\n",
"Kumm man röwer, ick hebb’ ne Birn.\"\"\""
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"my_long_string_2 = '''Herr von Ribbeck auf Ribbeck im Havelland,\n",
"Ein Birnbaum in seinem Garten stand,\n",
"Und kam die goldene Herbsteszeit,\n",
"Und die Birnen leuchteten weit und breit,\n",
"Da stopfte, wenn’s Mittag vom Thurme scholl,\n",
"Der von Ribbeck sich beide Taschen voll,\n",
"Und kam in Pantinen ein Junge daher,\n",
"So rief er: \"Junge, wist’ ne Beer?\"\n",
"Und kam ein Mädel, so rief er: \"Lütt Dirn\"\n",
"Kumm man röwer, ick hebb’ ne Birn.'''"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### Addition von Zeichenketten"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Ich studiere an der UniBwM\n",
"Text 135\n",
"Text 135\n"
]
}
],
"source": [
"my_string_1 = \"UniBwM\"\n",
"print('Ich studiere an der ' + my_string_1)\n",
"\n",
"# Addition mit einem Nicht-String\n",
"print('Text 1' + str(5 * 7))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### Multiplikation von Zeichenketten"
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ABCDABCDABCD\n"
]
}
],
"source": [
"print('ABCD' * 3)"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"============================================================\n",
"Progamm ABCD Version 1.0\n",
"============================================================\n"
]
}
],
"source": [
"# Nützlich z.B. für\n",
"print('=' * 60)\n",
"print('Progamm ABCD Version 1.0')\n",
"print('=' * 60)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Aber man kann keine Zeichenketten** ***miteinander*** **multiplizieren:**"
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {},
"outputs": [
{
"ename": "TypeError",
"evalue": "can't multiply sequence by non-int of type 'str'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mmy_string_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'11'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0msecond_string\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'2'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_string_test\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0msecond_string\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m: can't multiply sequence by non-int of type 'str'"
]
}
],
"source": [
"my_string_test = '11'\n",
"second_string = '2'\n",
"print(my_string_test * second_string)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### Länge ermitteln"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"5\n"
]
}
],
"source": [
"my_string = \"LOTTO\"\n",
"print(len(my_string))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### Sonderzeichen in Zeichenketten (Escaping)\n",
"Für eine vollständige Liste siehe z.B. [List of Python Escape sequence characters with examples](https://linuxconfig.org/list-of-python-escape-sequence-characters-with-examples)."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"text\n",
"neueZeile\n"
]
}
],
"source": [
"# Zeilenumbruch\n",
"print('text\\nneue Zeile')"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"wert 1\twert2\twert3\n"
]
}
],
"source": [
"# Tabulator\n",
"print('wert 1\\twert2\\twert3')"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"a \\ b\n"
]
}
],
"source": [
"# Backslash\n",
"print('a \\\\ b')"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Er sagte 'Hallo'\n",
"Er sagte \"Hallo\"\n"
]
}
],
"source": [
"# Anführungszeichen\n",
"print('Er sagte \\'Hallo\\'')\n",
"print(\"Er sagte \\\"Hallo\\\"\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### f-Strings (nicht klausurrelevant)\n",
"Schon immer gab es in Python die Möglichkeit, Werte in eine Zeichenkette einzubetten und zu formatieren, damit man einen Ergebnisstring nicht aufwändig zusammenfügen muss.\n",
"\n",
"Seit der Version 3.6 existiert ein [deutlich verbesserter Mechanismus, der sich 'f-Strings'](https://docs.python.org/3/reference/lexical_analysis.html#f-strings) nennt.\n",
"\n",
"Wenn man vor eine Zeichenkette den Buchstaben 'f' setzt, kann man innerhalb geschweifter Klammern beliebige Python-Ausdrücke einfügen:"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Beispiel für f-Strings:**\n",
"Die Ausdrücke innerhalb der geschweiften Klammern werden durch ihren Wert ersetzt."
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hallo Franz!\n",
"Der Umfang eines Kreises mit dem Radius r=2 ist 6.283185307179586.\n"
]
}
],
"source": [
"import math\n",
"\n",
"name = 'Franz'\n",
"print(f'Hallo {name}!')\n",
"print(f'Der Umfang eines Kreises mit dem Radius r=2 ist {math.pi * 2}.')"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### Formattierung von Werten innerhalb von f-Strings (nicht klausurrelevant) \n",
"Man kann die Werte in der Ausgabe auch formattieren. Dazu setzt man hinter den Ausdruck einen Doppelpunkt und dann verschiedene Angaben, wie\n",
"- die gesamte Breite in Zeichen **inklusive des Dezimaltrenners** (Punkt oder Komma),\n",
"- die Anzahl Nachkommastellen,\n",
"- ob fehlende Stellen vor dem Dezimalpunkt mit Leerzeichen, Nullen oder einem anderen Zeichen aufgefüllt werden sollen, sowie\n",
"- den Datentyp (oft `f` für eine Gleitkommazahl)."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### Formattierung von Werten innerhalb von f-Strings (nicht klausurrelevant) \n",
"`f'{:.f}'`\n",
"\n",
"Mit führender Null:\n",
"\n",
"`f'{:0.f}'`\n",
"\n",
"[Link zur vollständigen Dokumentation der Formatierungsanweisungen](https://docs.python.org/3/library/string.html#formatspec)."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### Beispiel "
]
},
{
"cell_type": "code",
"execution_count": 69,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Pi ohne Nachkommastellen: 3\n",
"Pi mit zwei Nachkommastellen: 3.14\n",
"Pi mit vier Nachkommastellen: 3.1416\n"
]
}
],
"source": [
"print(f'Pi ohne Nachkommastellen: {math.pi:.0f}')\n",
"print(f'Pi mit zwei Nachkommastellen: {math.pi:.2f}')\n",
"print(f'Pi mit vier Nachkommastellen: {math.pi:.4f}')"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### Beispiel "
]
},
{
"cell_type": "code",
"execution_count": 94,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Wert 1: 3.6 Wert 2:345.7\n",
"Wert 1:003.6 Wert 2:345.7\n"
]
}
],
"source": [
"a = 3.5678\n",
"b = 345.7\n",
"# Fünf Stellen Gesamtlänge, eine Nachkommastelle\n",
"# Fehlende Stellen vor dem Wert werden mit Leerzeichen aufgefüllt.\n",
"print(f'Wert 1:{a:5.1f} Wert 2:{b:5.1f}')\n",
"# Dito, aber Auffüllung mit Nullen\n",
"print(f'Wert 1:{a:05.1f} Wert 2:{b:05.1f}')"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### Weitere Hilfsfunktionen für Strings"
]
},
{
"cell_type": "code",
"execution_count": 122,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"unibwm ist toll\n",
"UNIBWM IST TOLL\n",
"['UniBwM', 'ist', 'toll']\n"
]
}
],
"source": [
"# https://docs.python.org/3/library/stdtypes.html\n",
"text = \"UniBwM ist toll\"\n",
"print(text.lower())\n",
"print(text.upper())\n",
"print(text.split(\" \"))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Aufsplitten mit `.split()`**"
]
},
{
"cell_type": "code",
"execution_count": 123,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['Der erste Satz', ' Und nun der zweite Satz', '']\n"
]
}
],
"source": [
"text_2 = \"Der erste Satz. Und nun der zweite Satz.\"\n",
"print(text_2.split(\".\"))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"**Whitespace (Leerzeichen etc.) entfernen mit `.strip()`**"
]
},
{
"cell_type": "code",
"execution_count": 124,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"= Hallo =\n"
]
}
],
"source": [
"text_3 = \" = Hallo = \"\n",
"print(text_3.strip()) "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"`endswith()` und `startswith()` für Zeichenketten.\n",
"\n",
"Mit diesen beiden Funktionen kann man prüfen, ob eine Zeichenkette mit einer Zeichenfolge beginnt oder endet."
]
},
{
"cell_type": "code",
"execution_count": 111,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n",
"True\n"
]
}
],
"source": [
"text = \"Universität der Bundeswehr\"\n",
"print(text.startswith('Uni'))\n",
"print(text.endswith('Bundeswehr'))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Listen\n",
"Listen sind komplexe Variablen aus mehreren Unterelementen beliebigen Typs. Die Unterelemente können einzeln adressiert und auch geändert werden.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1, True, 'UniBwM']\n"
]
}
],
"source": [
"# Liste\n",
"my_list = [1, 2, 5, 9]\n",
"my_list_mixed = [1, True, 'UniBwM']\n",
"print(my_list_mixed)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### Adressierung von Listenelementen und Listenbereichen\n",
"Unterelemente können einzeln adressiert und auch geändert werden. Das Format ist dabei\n",
"```\n",
"[::]\n",
"\n",
" - Name der Liste\n",
" - Index des ersten Listenelements\n",
" - Index des ersten Elements, das nicht mehr enthalten sein soll\n",
" - Schrittweite (-1 für rückwärts)```"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### Einzelnes Listenelement\n",
"Listenelemente können einzeln adressiert werden. Das erste Element hat den Index 0."
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"2\n",
"5\n"
]
}
],
"source": [
"my_list = [1, 2, 5, 9]\n",
"print(my_list[0])\n",
"print(my_list[1])\n",
"print(my_list[2])"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Listenelemente können auch einzeln geändert werden:**"
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1, True, 'LMU München']\n"
]
}
],
"source": [
"my_list_mixed = [1, True, 'UniBwM']\n",
"my_list_mixed[2] = 'LMU München'\n",
"print(my_list_mixed)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### Bereiche\n",
"Man kann auch Bereiche adressieren. Dazu gibt man den Index des ersten Elements und das erste nicht mehr gewünschte Element an.\n",
"\n",
"Wenn man einen der beiden Werte wegläßt, wird der Anfang bzw. das Ende der Liste verwendet."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['two', 'three', 'four', 'five']\n"
]
}
],
"source": [
"my_list = ['one', 'two', 'three',\n",
" 'four', 'five']\n",
"# Alle ab dem zweiten Element\n",
"print(my_list[1:])"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['one', 'two']\n",
"['two', 'three']\n"
]
}
],
"source": [
"# Alle bis zum zweiten Element\n",
"print(my_list[:2])\n",
"# Alle vom zweiten bis zum dritten Element\n",
"print(my_list[1:3])"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Alle Elemente ohne die letzten beiden:"
]
},
{
"cell_type": "code",
"execution_count": 114,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['one', 'two', 'three']\n"
]
}
],
"source": [
"my_list = ['one', 'two', 'three', 'four', 'five']\n",
"print(my_list[:-2])"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Bereiche ersetzen\n",
"Man kann auch Bereiche einer Liste ändern oder die Liste dadurch verkürzen oder verlängern."
]
},
{
"cell_type": "code",
"execution_count": 97,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['one', 'zwei', 'drei', 'four', 'five']\n"
]
}
],
"source": [
"my_list = ['one', 'two', 'three', 'four', 'five']\n",
"my_list[1:3] = ['zwei', 'drei']\n",
"print(my_list)"
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['one_and_two', 'three', 'four', 'five']\n"
]
}
],
"source": [
"my_list = ['one', 'two', 'three', 'four', 'five']\n",
"my_list[0:2] = ['one_and_two']\n",
"print(my_list)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Achtung:** Wenn man einen Listen**BEREICH** ändert, muss man eine **Liste** übergeben. "
]
},
{
"cell_type": "code",
"execution_count": 98,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['one_and_two', 'three', 'four', 'five']\n"
]
}
],
"source": [
"my_list = ['one', 'two', 'three', 'four', 'five']\n",
"my_list[0:2] = ['one_and_two']\n",
"print(my_list)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Sonst versucht Python, den Wert **als Liste seiner Unterelemente** zu verstehen, zum Beispiel eine Zeichenkette in eine Liste von Buchstaben zu zerlegen."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['A', 'B', 'C', 'three', 'four', 'five']\n"
]
}
],
"source": [
"my_list = ['one', 'two', 'three', 'four', 'five']\n",
"my_list[0:2] = 'ABC' # ABC ist hier eine Zeichenkette\n",
"# Python versucht, den übergebenen Wert in Unterlemente zu zerlegen \n",
"# und diese einzufügen.\n",
"# Daher werden hier die drei Buchstaben A, B und C als neue Listenelemente \n",
"# eingefügt.\n",
"print(my_list)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Wenn man **ein** Listenelement ändert, muss man **ein Element übergeben**:"
]
},
{
"cell_type": "code",
"execution_count": 69,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['one', 'two', 'drei', 'four', 'five']\n"
]
}
],
"source": [
"my_list = ['one', 'two', 'three', 'four', 'five']\n",
"my_list[2] = 'drei'\n",
"print(my_list)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Wenn man an einer Position **MEHRERE** neue Elemente einfügen will, \n",
"muss man diese Position **als Bereich der Länge 1** adressieren. Das geschieht im folgenden durch \n",
"`my_list[2:3]`."
]
},
{
"cell_type": "code",
"execution_count": 70,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['one', 'two', 'drei_a', 'drei_b', 'four', 'five']\n"
]
}
],
"source": [
"my_list = ['one', 'two', 'three', 'four', 'five']\n",
"my_list[2:3] = ['drei_a', 'drei_b']\n",
"print(my_list)"
]
},
{
"cell_type": "code",
"execution_count": 71,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['one', 'two', ['drei_a', 'drei_b'], 'four', 'five']\n"
]
}
],
"source": [
"# Sonst würde an dieser Stelle eine Liste als Element eingefügt:\n",
"my_list = ['one', 'two', 'three', 'four', 'five']\n",
"my_list[2] = ['drei_a', 'drei_b']\n",
"print(my_list)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Schrittweite\n",
"Man kann auch eine Schrittweite angeben und damit erreichen, dass nur jedes n-te Element aus der Liste zurückgeliefert wird."
]
},
{
"cell_type": "code",
"execution_count": 100,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['one', 'three', 'five']\n"
]
}
],
"source": [
"my_list = ['one', 'two', 'three', 'four', 'five', 'six']\n",
"# Jedes zweite Element zwischen 0 und 4\n",
"print(my_list[0:5:2])"
]
},
{
"cell_type": "code",
"execution_count": 103,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['one', 'four']\n"
]
}
],
"source": [
"# Jedes dritte Element\n",
"print(my_list[::3])"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Negative Schrittweite für rückwärts:**"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['six', 'five', 'four', 'three', 'two', 'one']\n"
]
}
],
"source": [
"my_list = ['one', 'two', 'three', 'four', 'five', 'six']\n",
"\n",
"# Alle Elemente in umgekehrter Reihenfolge\n",
"print(my_list[::-1])"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### Verlängern der Liste mit `append()`\n",
"Mit der Funktion `append()` kann man einen Wert am Ende einer Liste hinzufügen."
]
},
{
"cell_type": "code",
"execution_count": 105,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['one', 'two', 'three']\n"
]
}
],
"source": [
"my_list = ['one', 'two']\n",
"my_list.append('three')\n",
"print(my_list)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### Erweitern der Liste mit `extend()`\n",
"Mit der Funktion `extend()` kann man eine Liste am Ende der Liste hinzufügen."
]
},
{
"cell_type": "code",
"execution_count": 106,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['one', 'two', 'three', 'four']\n"
]
}
],
"source": [
"my_list = ['one', 'two']\n",
"my_list.extend(['three', 'four'])\n",
"print(my_list)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Kontrollfrage:\n",
"Was passiert, wenn Sie der Methode `append()` als Parameter eine **LISTE** übergeben?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"my_list = ['one', 'two']\n",
"my_list.append(['three', 'four'])"
]
},
{
"cell_type": "code",
"execution_count": 74,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['one', 'two', ['three', 'four']]\n"
]
}
],
"source": [
"print(my_list)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wie Sie sehen, wird in diesem Fall die Liste `['three', 'four']` als Element an dritter Stelle eingefügt. Das dritte Element ist danach also selbst eine Liste."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Kontrollfrage\n",
"Was passiert, wenn Sie der Methode `extend()` als Parameter einen einzelnen Wert übergeben?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"my_list = ['one', 'two']\n",
"my_list.extend('three')"
]
},
{
"cell_type": "code",
"execution_count": 75,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['one', 'two', 't', 'h', 'r', 'e', 'e']\n"
]
}
],
"source": [
"print(my_list)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wie Sie sehen versucht Python, den Wert **als Liste seiner Unterelemente** zu verstehen, zum Beispiel eine Zeichenkette in eine Liste von Buchstaben zu zerlegen."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Wenn eine atomare Variable übergeben wird und diese Zerlegung nicht möglich ist, gibt es eine Fehlermeldung:"
]
},
{
"cell_type": "code",
"execution_count": 107,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"ename": "TypeError",
"evalue": "'int' object is not iterable",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mmy_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'one'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'two'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmy_list\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mTypeError\u001b[0m: 'int' object is not iterable"
]
}
],
"source": [
"my_list = ['one', 'two']\n",
"my_list.extend(1)\n",
"print(my_list)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### Entfernen von Elementen aus einer Liste\n",
"Wenn man ein Element aus einer Liste entfernen möchte, kann man dies über seinen **Wert** mit der Funktion `remove()` erreichen. Wenn stattdessen die **Position** des Elementes bekannt ist, gibt es eine Funktion `pop()`."
]
},
{
"cell_type": "code",
"execution_count": 85,
"metadata": {
"cell_style": "split"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['Peter', 'Mary']\n"
]
}
],
"source": [
"liste = ['Peter', 'Paul', 'Mary']\n",
"liste.remove('Paul')\n",
"print(liste)"
]
},
{
"cell_type": "code",
"execution_count": 87,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['Paul', 'Mary']\n"
]
}
],
"source": [
"liste = ['Peter', 'Paul', 'Mary']\n",
"liste.pop(0)\n",
"print(liste)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"`pop()` (ohne Parameter) entfernt das Element am Ende der Liste:"
]
},
{
"cell_type": "code",
"execution_count": 115,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['Peter', 'Paul']\n"
]
}
],
"source": [
"liste = ['Peter', 'Paul', 'Mary']\n",
"liste.pop()\n",
"print(liste)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"`pop()` mit oder ohne Parameter liefert das entfernte Element als Ergebnis zurück. "
]
},
{
"cell_type": "code",
"execution_count": 88,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Peter\n"
]
}
],
"source": [
"liste = ['Peter', 'Paul', 'Mary']\n",
"print(liste.pop(0))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Stapel (Stack) und Last in, first out**\n",
"\n",
"`pop()` kann man sehr verwenden, um einen Stapel (Stack) zu implementieren oder in anderen Zusammenhängen das [LIFO-Prinzip (\"last in, first out\")](https://de.wikipedia.org/wiki/Last_In_%E2%80%93_First_Out) anzuwenden."
]
},
{
"cell_type": "markdown",
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "-"
}
},
"source": [
"| Position | Name |\n",
"|---|---|\n",
"| 2 | Paul |\n",
"| 1 | Mary |\n",
"| 0 | Peter |\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"cell_style": "split"
},
"source": [
"`Ein neues Element Linda wird oben auf den Stapel gelegt:`\n",
"\n",
"| Position | Name |\n",
"|---|---|\n",
"| **3** | **Linda** |\n",
"| 2 | Paul |\n",
"| 1 | Mary |\n",
"| 0 | Peter |"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"cell_style": "center",
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Unser Team: ['Peter', 'Mary', 'Paul', 'Linda']\n",
"Unser Team: ['Peter', 'Mary', 'Paul', 'Linda', 'Frank']\n",
"Leider müssen wir Frank wieder entlassen.\n",
"Unser Team: ['Peter', 'Mary', 'Paul', 'Linda']\n"
]
}
],
"source": [
"mitarbeiter = ['Peter', 'Mary', 'Paul', 'Linda']\n",
"print('Unser Team: '+ str(mitarbeiter))\n",
"mitarbeiter.append('Frank')\n",
"print('Unser Team: '+ str(mitarbeiter))\n",
"# Wer zuletzt eingestellt wurde, wird zuerst wieder entlassen.\n",
"name = mitarbeiter.pop()\n",
"print('Leider müssen wir ' + str(name) + ' wieder entlassen.')\n",
"print('Unser Team: '+ str(mitarbeiter))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### Sortieren von Listen\n",
"Man kann Listen einfach sortieren. Dazu gibt hat eine Liste die Funktion `sort()`. Sie sortiert die Elemente in der ursprünglichen Liste um."
]
},
{
"cell_type": "code",
"execution_count": 117,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1, 2, 3, 4, 5, 6]\n",
"['Anton', 'Mary', 'Peter', 'Zoe']\n"
]
}
],
"source": [
"my_list = [1, 6, 5, 3, 2, 4]\n",
"my_list.sort()\n",
"print(my_list)\n",
"\n",
"woerter_liste = ['Peter', 'Mary', 'Zoe', 'Anton']\n",
"woerter_liste.sort()\n",
"print(woerter_liste)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Achtung:** `sort()` ist eine Funktion, **die das Objekt verändert.**\n",
"Es wird keine sortierte Version zurückgeliefert, **sondern das Objekt am bisherigen Ort sortiert.**"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"None\n"
]
}
],
"source": [
"meine_liste = [1, 2, 3, 0, 7, 4, 13]\n",
"print(meine_liste.sort())"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### Inverse Sortierfolge\n",
"Mit dem Parameter `reverse=True` kann man die Sortierreihenfolge umkehren."
]
},
{
"cell_type": "code",
"execution_count": 79,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[6, 5, 4, 3, 2, 1]\n"
]
}
],
"source": [
"my_list = [1, 6, 5, 3, 2, 4]\n",
"my_list.sort(reverse=True)\n",
"print(my_list)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Es ist möglich, **Listen mit verschiedenen Datentypen** zu sortieren, sofern für jedes mögliche Wertepaar ein Vergleichsoperator definiert ist."
]
},
{
"cell_type": "code",
"execution_count": 118,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1, 1.5, 2, 7.2]\n"
]
}
],
"source": [
"# Gemischte Liste\n",
"gemischte_liste_1 = [1, 1.5, 2, 7.2]\n",
"gemischte_liste_1.sort()\n",
"print(gemischte_liste_1)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Die **Sortierung funktioniert** aber **nicht, wenn** eine Liste Elemente enthält, für die **kein Vergleichsoperator definiert ist.**"
]
},
{
"cell_type": "code",
"execution_count": 110,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"ename": "TypeError",
"evalue": "'<' not supported between instances of 'str' and 'int'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mgemischte_liste_2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Zoe'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgemischte_liste_2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msort\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgemischte_liste_2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mTypeError\u001b[0m: '<' not supported between instances of 'str' and 'int'"
]
}
],
"source": [
"gemischte_liste_2 = [1, 'Zoe', False]\n",
"gemischte_liste_2.sort()\n",
"print(gemischte_liste_2)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### Suchen in Listen"
]
},
{
"cell_type": "code",
"execution_count": 80,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n"
]
}
],
"source": [
"# Prüfen, ob Element in Liste enthalten\n",
"my_liste_3 = [1, 4, 9, 7]\n",
"print(2 in my_liste_3)"
]
},
{
"cell_type": "code",
"execution_count": 83,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Täter gefunden!\n"
]
}
],
"source": [
"my_liste_4 = ['Hepp', 'Mueller', 'Meier']\n",
"if 'Mueller' in my_liste_4:\n",
" print('Täter gefunden!')"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"`index()` liefert die erste Position eines passenden Wertes:"
]
},
{
"cell_type": "code",
"execution_count": 84,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n"
]
}
],
"source": [
"my_liste_4 = ['Hepp', 'Mueller', 'Meier']\n",
"if 'Mueller' in my_liste_4:\n",
" print(my_liste_4.index('Mueller'))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Tuples\n",
"Tuples sind strukturierte Datentypen aus mehreren Elementen. Sie sind Immutables, können also nicht verändert werden. Man kann aber natürlich ein neues Tuples aus geänderten Werten erzeugen."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"##### Beispiele"
]
},
{
"cell_type": "code",
"execution_count": 83,
"metadata": {},
"outputs": [],
"source": [
"# Tuple\n",
"my_tuple = (1, 3, 9)\n",
"my_tuple_mixed = (1, True, 'UniBwM')\n",
"latitude = 48.0803\n",
"longitude = 11.6382\n",
"geo_position = (latitude, longitude)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"##### Entpacken eines Tuples in mehrere Zielvariablen\n",
"Man kann ein Tupel elegant in seine Bestandteile zerlegen und diese einzelnen Variablen zuweisen. Voraussetzung ist nur, dass auf der linken Seite ebensoviele Variablen genannt werden wie das Tupel Bestandteile hat."
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"48.0803\n"
]
}
],
"source": [
"geo_position = (48.0803, 11.6382)\n",
"lat, lon = geo_position\n",
"print(lat)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"cell_style": "split",
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"A\n"
]
}
],
"source": [
"# Das funktioniert auch \n",
"# mit anderen komplexen Datentypen\n",
"text = \"ABC\"\n",
"x, y, z = text\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Auch die Elemente eines Tuples können einzeln adressiert werden:**"
]
},
{
"cell_type": "code",
"execution_count": 85,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"48.0803\n"
]
}
],
"source": [
"print(geo_position[0])"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"11.6382\n"
]
}
],
"source": [
"print(geo_position[1])"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Die Unterelemente eines Tuples können aber nicht geändert werden:"
]
},
{
"cell_type": "code",
"execution_count": 86,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"ename": "TypeError",
"evalue": "'tuple' object does not support item assignment",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Die Unterelemente eines Tuples können aber nicht geändert werden:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgeo_position\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m44.123\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
]
}
],
"source": [
"geo_position[0] = 44.123"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true,
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Dictionaries\n",
"Dictionaries sind Datenstrukturen, in denen Paare aus Eigenschaften (Properties) und Werte (Values) gespeichert werden können. Dier Werte können über ihren Namen angesprochen werden:"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Martin Hepp\n",
"WOW\n"
]
}
],
"source": [
"my_dict_empty = {}\n",
"my_dict_simple = {'name' : 'Martin Hepp'}\n",
"my_dict = {'name' : 'Martin Hepp', \n",
" 'fakultaet' : 'WOW', \n",
" 'geburtsjahr' : 1971}\n",
"print(my_dict['name'])\n",
"print(my_dict['fakultaet'])"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'name': 'Martin Hepp', 'fakultaet': 'WOW', 'geburtsjahr': 1971}\n",
"{'name': 'Martin Hepp', 'fakultaet': 'INF', 'geburtsjahr': 1971}\n",
"{'name': 'Martin Hepp', 'fakultaet': 'INF', 'geburtsjahr': 1971, 'lieblingsvorlesung': 'Programmierung in Python'}\n"
]
}
],
"source": [
"# Elemente können geändert und hinzugefügt werden\n",
"print(my_dict)\n",
"my_dict['fakultaet'] = 'INF'\n",
"print(my_dict)\n",
"my_dict['lieblingsvorlesung'] = 'Programmierung in Python'\n",
"print(my_dict)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Wenn es den Schlüssel ('key') nicht gibt, wird eine Fehlermeldung produziert:**"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"ename": "KeyError",
"evalue": "'einkommen'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'einkommen'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mKeyError\u001b[0m: 'einkommen'"
]
}
],
"source": [
"print(my_dict['einkommen'])"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Das kann man mit der Methode `get()` vermeiden:**"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"None\n"
]
}
],
"source": [
"print(my_dict.get('einkommen'))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Man kann auch einen Default-Wert vorgeben (normalerweise `None`).**\n",
"\n",
"Dieser Wert wird zurückgeliefert, wenn es die Eigenschaft bisher nicht gibt."
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Unbekannt\n",
"0\n"
]
}
],
"source": [
"print(my_dict.get('einkommen', 'Unbekannt'))\n",
"print(my_dict.get('einkommen', 0))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Beispiel:**"
]
},
{
"cell_type": "code",
"execution_count": 92,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{}\n"
]
}
],
"source": [
"adresse = {}\n",
"print(adresse)"
]
},
{
"cell_type": "code",
"execution_count": 93,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"85577\n",
"{'plz': '85577', 'sonderfeld': 'Bemerkungen bitte hier'}\n"
]
}
],
"source": [
"adresse = {}\n",
"adresse['plz'] = '85577'\n",
"print(adresse['plz'])\n",
"adresse['sonderfeld'] = 'Bemerkungen bitte hier'\n",
"print(adresse)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"**Liste von Dictionaries:**"
]
},
{
"cell_type": "code",
"execution_count": 94,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[{'name': 'Frank Farian'}, {'name': 'Lady Gaga', 'bemerkung': 'Supercool!'}, {'name': 'John Lennon'}]\n"
]
}
],
"source": [
"gast_1 = {'name' : 'Frank Farian'}\n",
"gast_2 = {'name' : 'Lady Gaga'}\n",
"gast_3 = {'name' : 'John Lennon'}\n",
"\n",
"gaesteliste = []\n",
"gaesteliste.append(gast_1)\n",
"gaesteliste.append(gast_2)\n",
"gaesteliste.append(gast_3)\n",
"gast_2['bemerkung'] = 'Supercool!'\n",
"print(gaesteliste)\n"
]
},
{
"cell_type": "code",
"execution_count": 95,
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Frank Farian \n",
"Lady Gaga Supercool!\n",
"John Lennon \n"
]
}
],
"source": [
"for gast in gaesteliste:\n",
" print(gast['name'], gast.get('bemerkung', ''))"
]
},
{
"cell_type": "code",
"execution_count": 96,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[{'name': 'Frank Farian'}, {'name': 'Lady Gaga', 'bemerkung': 'Supercool!'}, {'name': 'John Lennon'}]\n"
]
}
],
"source": [
"gast_2['bemerkung'] = 'Supercool!'\n",
"print(gaesteliste)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Sets (Mengen)"
]
},
{
"cell_type": "code",
"execution_count": 97,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'gelb', 'rot', 'blau', 'gruen'}\n"
]
}
],
"source": [
"a = set(['rot', 'gruen', 'blau', 'gelb'])\n",
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 98,
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{' ', '.', 'i', 'h', 'e', 'Z', 'k', 's', 'n', 'c', 'D', 't'}\n"
]
}
],
"source": [
"a = 'Dies ist eine Zeichenkette.'\n",
"# Nun schauen wir, welche Buchstaben hierin vorkommen.\n",
"zeichenvorrat = set(a)\n",
"print(zeichenvorrat)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Named Tuples (nicht klausurrelevant)\n",
"\n",
"- Nicht Gegenstand dieser Vorlesung\n",
"- [Python Reference: Named Tuples](https://docs.python.org/3/library/collections.html#collections.namedtuple)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Benutzereingabe mit ```input()```"
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Ihr Name? Hepp\n"
]
}
],
"source": [
"# Benutzereingabe mit input([text])\n",
"# Ergebnis ist Zeichenkette (s.u.)\n",
"eingabe = input('Ihr Name? ')"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Typumwandlung (Type Cast)\n",
"#### Zeichenkette in Ganzzahl (int)"
]
},
{
"cell_type": "code",
"execution_count": 100,
"metadata": {},
"outputs": [],
"source": [
"zahl_als_text = \"7\"\n",
"zahl_als_int = int(zahl_als_text)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"#### Zeichenkette als Gleitkommazahl (float)"
]
},
{
"cell_type": "code",
"execution_count": 101,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"float_als_text = \"3.1415\"\n",
"float_als_zahl = float(float_als_text)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Zahl als Zeichenkette (String)"
]
},
{
"cell_type": "code",
"execution_count": 102,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"zahl_als_text = str(7)\n",
"float_als_text = (str(3.1415))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Umwandlung einer Zahl in eine Zeichenkette"
]
},
{
"cell_type": "code",
"execution_count": 121,
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"84\n",
"4242\n"
]
}
],
"source": [
"a = 42\n",
"a_string = str(a)\n",
"\n",
"# Was ist hier der Unterschied?\n",
"print(a * 2)\n",
"print(a_string * 2)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Übungsaufgaben\n",
"\n",
"Siehe separate Notebooks auf der [Seite zur Veranstaltung](http://www.ebusiness-unibw.org/wiki/Teaching/PIP)."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "skip"
}
},
"source": [
"## Erweiterungen\n",
"Die folgenden Erweiterungen sind nicht Gegenstand der aktuellen Vorlesung und werden hier nur der Vollständigkeit halber genannt."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "skip"
}
},
"source": [
"### Type Checking in Python\n",
"\n",
"https://realpython.com/python-type-checking/"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Quellenangaben und weiterführende Literatur\n",
"\\[Pyt2019\\] Python Software Foundation. Python 3.8.0 Documentation. [https://docs.python.org/3/](https://docs.python.org/3/)."
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true,
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Vielen Dank! \n",
" \n",
"[**http://www.ebusiness-unibw.org/wiki/Teaching/PIP**](http://www.ebusiness-unibw.org/wiki/Teaching/PIP)"
]
}
],
"metadata": {
"anaconda-cloud": {},
"celltoolbar": "Slideshow",
"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.7.1"
},
"rise": {
"backimage": "background.png",
"center": false,
"enable_chalkboard": false,
"footer": "Univ.-Prof. Dr. Martin Hepp, martin.hepp@unibw.de",
"header": "Programmierung in Python",
"showSlideNumber": "pdf",
"slideNumber": "c/t",
"theme": "chesterish",
"transition": "none"
},
"toc": {
"base_numbering": 1,
"nav_menu": {},
"number_sections": true,
"sideBar": true,
"skip_h1_title": false,
"title_cell": "Table of Contents",
"title_sidebar": "Inhaltsverzeichnis",
"toc_cell": false,
"toc_position": {
"height": "calc(100% - 180px)",
"left": "10px",
"top": "150px",
"width": "192.042px"
},
"toc_section_display": true,
"toc_window_display": false
}
},
"nbformat": 4,
"nbformat_minor": 1
}