{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Einführung in die Python-Programmierung" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Basiert auf \"Introduction to Python programming\" von J.R. Johansson (CC-BY). Anpassungen und Übersetzung durch mich (unter CC-BY).\n", "\n", "Original verfügbar unter [http://github.com/jrjohansson/scientific-python-lectures](http://github.com/jrjohansson/scientific-python-lectures)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Umgang mit Jupyter-Notebooks" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Jupyter-Notebooks erlauben es, Code und Erläuerungen zu kombinieren.\n", "\n", "Für Code gibt es Code-Zellen. Code kann mit \"Strg+Enter\" ausgeführt werden und das Ergebnis erscheint direkt darunter.\n", "\n", "Probieren Sie es aus:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "24" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "1 + 23" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Neue Codezeilen können mit \"Alt+Enter\" hinzugefügt werden.\n", "\n", "Probiere Sie es aus:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# Erzeuge mir einen Freund mit Alt+Enter\n", "# dd: Zelle löschen" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Operatoren" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Die Operatoren in Python funktionieren wie bei einem grafischen Taschenrechner. Auch Rechenregeln wie Punkt-Vor-Strich werden berücksichtigt:\n", "\n", "* Addition: `+`\n", "* Subtraktion: `-`\n", "* Multiplikation: `*`\n", "* Division: `/`, `//` (Ganzzahldivision),\n", "* Restdivision (Modulo): `%`\n", "* Potenz: `**`\n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "1 + 2" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-1" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "1 - 2" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.5" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "3 / 2" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "3 // 2" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "5 % 2" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "125" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(3 + 2) ** 3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Vergleiche" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Die boolschen Operatoren sind `and`, `not` und `or`. " ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "True and False" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "False and False" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "True and True" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "False or True" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "not True" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 0 False\n", "# != 0 True\n", "3 and 0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Vergleichsoperatoren ähnlich wie bei SQL:\n", "\n", "- `>`, `<`\n", "- `>=` (größer oder gleich)\n", "- `<=` (kleiner oder gleich)\n", "- `==` Gleichheit (doppelt, ein einzelnes = ist eine Zuweisung)\n", "- `!=` Ungleichheit" ] }, { "cell_type": "code", "execution_count": 44, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "2 > 1" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "2 < 1" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "1.9999 <= 1 + 1" ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "5 == 4" ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "5 != 4" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Variablen und Typen" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Symbolnamen" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Variablenamen dürfen `a-z`, `A-Z`, `0-9` und einige Sonderzeichen (`_`) enthalten. Variablennamen dürfen nicht mit einer Zahl beginnen.\n", "\n", "In Python gibt es reservierte Schlüsselwörter. Diese können nicht als Variablennamen verwendet werden. Dazu gehören u.a. \n", "\n", " and, as, assert, break, class, continue, def, del, elif, else, except,\n", " exec, finally, for, from, global, if, import, in, is, lambda, not, or,\n", " pass, print, raise, return, try, while, with, yield\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 63, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1 2 3\n" ] } ], "source": [ "abc = 1\n", "_def = 2\n", "_and = 3\n", "print(abc, _def, _and)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Zuweisungen" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Zuweisungen werden in Python mit dem `=`-Operator gemacht.\n", "\n", "Python ist eine dynamisch typisierte Sprache, d.h. der Typ einer Variablen musst nicht angeben werden.\n", "\n", "Das Zuweisen eines Wertes an eine neue Variable erzeugt die Variable:" ] }, { "cell_type": "code", "execution_count": 65, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "float" ] }, "execution_count": 65, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x = 1.0\n", "type(x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Obwohl nicht angegeben, hat jede Variable einen expliziten Typ. Dieser ergibt sich aus dem Wert, der ihr zugewiesen wurde." ] }, { "cell_type": "code", "execution_count": 66, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "int" ] }, "execution_count": 66, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y = 3\n", "type(y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Mittels Neuzuweisung kann der Typ geändert werden:" ] }, { "cell_type": "code", "execution_count": 68, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3 \n" ] } ], "source": [ "x = y\n", "print(x, type(x))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Der Zugriff auf unbekannte Variablen erzeugteinen `NameError`:" ] }, { "cell_type": "code", "execution_count": 71, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "ename": "NameError", "evalue": "name 'z' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\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[0mx\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mNameError\u001b[0m: name 'z' is not defined" ] } ], "source": [ "print(x + z)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Elementare Datentypen" ] }, { "cell_type": "code", "execution_count": 72, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "# Ganzzahl (Integer)\n", "x = 1" ] }, { "cell_type": "code", "execution_count": 74, "metadata": {}, "outputs": [], "source": [ "x = 1.0 # Float" ] }, { "cell_type": "code", "execution_count": 75, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "bool" ] }, "execution_count": 75, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b1 = True\n", "b2 = False\n", "type(b1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Typumwandlungen" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Mit einem Cast kann der Typ von Variablen geändert werden." ] }, { "cell_type": "code", "execution_count": 79, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "float" ] }, "execution_count": 79, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x = 1.9\n", "type(x)" ] }, { "cell_type": "code", "execution_count": 82, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1 \n" ] } ], "source": [ "y = int(x)\n", "print(y, type(y))" ] }, { "cell_type": "code", "execution_count": 84, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 84, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bool(0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Compound types: Strings, Listen und Dictionaries (Wörterbücher)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Strings" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In Strings werden Texte abgespeichert. " ] }, { "cell_type": "code", "execution_count": 91, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hallo Welt \n", "Hallo Welt\n" ] } ], "source": [ "s = \"Hallo Welt\"\n", "print(s, type(s))\n", "print(s)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Die Länge von Strings (Zeichenanzahl) kann mit der integrierten Funktion `len` bestimmt werden." ] }, { "cell_type": "code", "execution_count": 93, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "10" ] }, "execution_count": 93, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(s)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Mit `[]` kann ein einzelnes Zeichen extrahiert werden (das 1. Zeichen ist bei Index 0):" ] }, { "cell_type": "code", "execution_count": 96, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'H'" ] }, "execution_count": 96, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s[0]" ] }, { "cell_type": "code", "execution_count": 97, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'W'" ] }, "execution_count": 97, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s[6]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Beim extrahieren können auch Bereiche (Slices) angegeben werden.\n", "Die Syntax ist `[start:stop]`. Dabei bekommt man alle Zeichen ab `start` bis ein Zeichen vor `stop`." ] }, { "cell_type": "code", "execution_count": 98, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "'allo'" ] }, "execution_count": 98, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s[1:5]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Wenn der Start oder das Ende weggelassen werden, wird immer das erste bzw. letzte Zeichen als Position angenommen." ] }, { "cell_type": "code", "execution_count": 102, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "'Hallo'" ] }, "execution_count": 102, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s[:5]\n", "s[0:5]" ] }, { "cell_type": "code", "execution_count": 103, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'Welt'" ] }, "execution_count": 103, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s[6:]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Typumwandlungen funktionieren auch zwischen Zahlen und Strings" ] }, { "cell_type": "code", "execution_count": 87, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'123'" ] }, "execution_count": 87, "metadata": {}, "output_type": "execute_result" } ], "source": [ "str(123)" ] }, { "cell_type": "code", "execution_count": 89, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "123" ] }, "execution_count": 89, "metadata": {}, "output_type": "execute_result" } ], "source": [ "int(\"123\")" ] }, { "cell_type": "code", "execution_count": 104, "metadata": {}, "outputs": [ { "ename": "ValueError", "evalue": "invalid literal for int() with base 10: 'abc'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\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[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"abc\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'abc'" ] } ], "source": [ "int(\"abc\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Textausgabe" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Text kann mit der `print` Funktion ausgegeben werden." ] }, { "cell_type": "code", "execution_count": 107, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hallo 1\n", "Hallo 1 Welt\n" ] } ], "source": [ "s = \"Hallo\"\n", "i = 1\n", "print(s, i)\n", "print(s, i, \"Welt\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Strings können mit plus kombiniert werden:" ] }, { "cell_type": "code", "execution_count": 113, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "ename": "TypeError", "evalue": "can only concatenate str (not \"int\") to 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[0;32m----> 1\u001b[0;31m \u001b[0;34m\"Hallo \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mi\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" Welt\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str" ] } ], "source": [ "\"Hallo \" + i + \" Welt\"" ] }, { "cell_type": "code", "execution_count": 115, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'Hallo 1 Welt'" ] }, "execution_count": 115, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"Hallo \" + str(i) + \" Welt\"" ] }, { "cell_type": "code", "execution_count": 117, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'Hallo 1 Welt'" ] }, "execution_count": 117, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"Hallo \" + \"1\" + \" Welt\"" ] }, { "cell_type": "code", "execution_count": 118, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'Hallo i'" ] }, "execution_count": 118, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"Hallo \" + \"i\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "f-Strings sind aber schöner. Nicht-Strings werden sogar automatisch umgewandelt:" ] }, { "cell_type": "code", "execution_count": 120, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "'Hallo 1 Welt'" ] }, "execution_count": 120, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f\"Hallo {i} Welt\"" ] }, { "cell_type": "code", "execution_count": 123, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'Hallo 101 Welt'" ] }, "execution_count": 123, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f\"{s} {i+100} Welt\"" ] }, { "cell_type": "code", "execution_count": 131, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'s 101 Welt'" ] }, "execution_count": 131, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f\"s {i+100} Welt\"" ] }, { "cell_type": "code", "execution_count": 133, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'abc'" ] }, "execution_count": 133, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"ABc\".lower()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Listen" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Listen unterstüzen die Selben Funktionen wie Strings (`len` und Slicing), können aber beliebige Datentypen enthalten, nicht nur Zeichen." ] }, { "cell_type": "code", "execution_count": 126, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 4]" ] }, "execution_count": 126, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l = [1,2,3,4]\n", "l" ] }, { "cell_type": "code", "execution_count": 127, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 127, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(l)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Das slicen funktioniert exakt wie bei Strings:" ] }, { "cell_type": "code", "execution_count": 130, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2\n", "[3, 4]\n", "[1, 2]\n" ] } ], "source": [ "print(l[1])\n", "print(l[2:])\n", "print(l[0:2])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Listenelemente können verschiedene Datentypen enthalten:" ] }, { "cell_type": "code", "execution_count": 135, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "[1, 'a', 3.0]" ] }, "execution_count": 135, "metadata": {}, "output_type": "execute_result" } ], "source": [ "m = [1, \"a\", 3.0]\n", "m" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Mit der eingebauten `range`-Funktion können Listen aus Zahlenreihen generiert werden:" ] }, { "cell_type": "code", "execution_count": 141, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n" ] } ], "source": [ "n = list(range(0, 20, 1))\n", "print(n)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Durch eine Zuweisung können einzelnes Listenelemente ersetzt werden:" ] }, { "cell_type": "code", "execution_count": 142, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0, 'A', 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n" ] } ], "source": [ "n[1] = \"A\"\n", "print(n)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Mit der eingebauten `del`-Funktion können einzelne Listenelemente gelöscht werden:" ] }, { "cell_type": "code", "execution_count": 146, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n" ] } ], "source": [ "del n[0]\n", "print(n)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Tupel" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Tupel sind quasi wie Listen, können aber nach der Erstellung nicht mehr modifiziert werden." ] }, { "cell_type": "code", "execution_count": 149, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "punkt = (10, 20) # Tupel\n", "punkt2 = [10, 20] # Liste" ] }, { "cell_type": "code", "execution_count": 150, "metadata": {}, "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[0;32m----> 1\u001b[0;31m \u001b[0mpunkt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\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": [ "punkt[0] = 0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Tupel können entpackt werden:" ] }, { "cell_type": "code", "execution_count": 154, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10 20\n" ] } ], "source": [ "x, y = punkt\n", "print(x, y)" ] }, { "cell_type": "code", "execution_count": 156, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10 20\n" ] } ], "source": [ "x, y = punkt2\n", "print(x, y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Dictionaries (Wörterbücher)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Dictionaries bilden einen eindeutige Schlüssel auf einen Wert ab `{key1 : value1, ...}`:" ] }, { "cell_type": "code", "execution_count": 158, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "{'name': 'Hans', 'alter': 20, 'ort': 'Mittweida'}" ] }, "execution_count": 158, "metadata": {}, "output_type": "execute_result" } ], "source": [ "params = {\"name\": \"Hans\", \"alter\": 20, \"ort\": \"Mittweida\"}\n", "params" ] }, { "cell_type": "code", "execution_count": 159, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[{'name': 'Hans', 'alter': 20, 'ort': 'Mittweida'},\n", " {'name': 'Hans', 'alter': 20, 'ort': 'Mittweida'}]" ] }, "execution_count": 159, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[params, params]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Zugriff funktioniert mit eckigen Klammern. In diese muss der Schlüssel geschrieben werden:" ] }, { "cell_type": "code", "execution_count": 161, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "'Hans'" ] }, "execution_count": 161, "metadata": {}, "output_type": "execute_result" } ], "source": [ "params[\"name\"]" ] }, { "cell_type": "code", "execution_count": 163, "metadata": {}, "outputs": [ { "ename": "KeyError", "evalue": "'xxx'", "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[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"xxx\"\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: 'xxx'" ] } ], "source": [ "params[\"xxx\"]" ] }, { "cell_type": "code", "execution_count": 165, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'name': 'Paul', 'alter': 20, 'ort': 'Mittweida'}" ] }, "execution_count": 165, "metadata": {}, "output_type": "execute_result" } ], "source": [ "params[\"name\"] = \"Paul\"\n", "params" ] }, { "cell_type": "code", "execution_count": 166, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'alter': 20, 'ort': 'Mittweida'}" ] }, "execution_count": 166, "metadata": {}, "output_type": "execute_result" } ], "source": [ "del params[\"name\"]\n", "params" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Programmablauf" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### if, elif, else" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Die Keywords für bedinge Ausführung lauten in Python `if`, `elif` (else if), `else`:" ] }, { "cell_type": "code", "execution_count": 169, "metadata": {}, "outputs": [], "source": [ "x = False\n", "y = True" ] }, { "cell_type": "code", "execution_count": 175, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "y ist wahr\n", "bla\n", "immer ausgeben\n" ] } ], "source": [ "if x:\n", " print(\"x ist wahr\")\n", "elif y:\n", " print(\"y ist wahr\")\n", " print(\"bla\")\n", "else:\n", " print(\"nix is wahr\")\n", "print(\"immer ausgeben\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In Python wird ein Codeblocks durch die Einrückungsebene definiert (normalerweise ein Tabulator oder vier Leerzeichen). Das bedeutet, dass der Code korrekt eingerückt sein muss, da es sonst Syntaxfehler gibt. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Beispiele:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Weiterführende Literatur" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* http://www.python.org - Offizielle Python Website\n", "* http://www.greenteapress.com/thinkpython/ - Kostenfreies Python-Lehrbuch" ] } ], "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.9.1" } }, "nbformat": 4, "nbformat_minor": 4 }