{ "metadata": { "name": "", "signature": "sha256:83985722ed05f1d04a98af03c60be869ebc54f0f262e00657e3f2d72366f1441" }, "nbformat": 3, "nbformat_minor": 0, "worksheets": [ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Python-Einf\u00fchrung (f\u00fcr ganz Eilige)\n", "\n", "* wir verwenden Python 2.7 (aktuell ist 3.3, aber das _Natural Language Toolkit_ (http://www.nltk.org/install.html) unterst\u00fctzt diese Version noch nicht)\n", "\n", "## Was brauchen wir?\n", "\n", "* Minimalanforderung: Python-Interpreter und einen Text-Editor\n", "- wird bei Linux schon mitgeliefert, ansonsten: https://www.python.org/downloads/\n", "\n", "* f\u00fcr gehobenen Anspr\u00fcche: IPython (farbenfroher Interpreter mit Befehlsvervollst\u00e4ndigung per Tabulator-Taste), versteht sogar Bash-Befehle\n", "* f\u00fcr Experimentierfreudige: IPython-Notebook (l\u00e4uft im Browser, verbindet Code und Dokumentation, Bilder und Statistik visuell in einem Dokument)\n", "* unter Linux (Ubuntu/Debian): `sudo apt-get install ipython-notebook`, ansonsten: http://ipython.org/install.html\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "# Datentypen\n", "\n", "## Zahlen\n", "\n", "* Ganzzahlen (`int`): 0, -23, 987654321\n", "* Gleitkommazahlen (`float`): 0.1, 3.14159\n", "* _immutable_\n" ] }, { "cell_type": "code", "collapsed": false, "input": [ "2 + 3" ], "language": "python", "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 1, "text": [ "5" ] } ], "prompt_number": 1 }, { "cell_type": "code", "collapsed": false, "input": [ "2 * 3" ], "language": "python", "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 2, "text": [ "6" ] } ], "prompt_number": 2 }, { "cell_type": "code", "collapsed": false, "input": [ "2 ** 3" ], "language": "python", "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 3, "text": [ "8" ] } ], "prompt_number": 3 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Division\n", "\n", "* unterschiedliche Ergebnisse: ``int`` vs. ``float``!" ] }, { "cell_type": "code", "collapsed": false, "input": [ "2 / 3" ], "language": "python", "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 4, "text": [ "0" ] } ], "prompt_number": 4 }, { "cell_type": "code", "collapsed": false, "input": [ "2.0 / 3" ], "language": "python", "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 5, "text": [ "0.6666666666666666" ] } ], "prompt_number": 5 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Verwende die Funktion `float()`, wenn eine Ganzzahl (oder einen String, der eine Ganzzahl repr\u00e4sentiert) in eine Gleitkommazahl umgewandelt werden soll:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "float(3)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 6, "text": [ "3.0" ] } ], "prompt_number": 6 }, { "cell_type": "code", "collapsed": false, "input": [ "float(\"3\")" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 7, "text": [ "3.0" ] } ], "prompt_number": 7 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Zeichenketten (Strings)\n", "\n", "* Sequenz von einzelnen Zeichen\n", "* eingeschlossen in 'einfachen' _oder_ \"doppelten\" Anf\u00fchrungszeichen\n", "* mehrzeilige Strings in ''' oder \"\"\" eingeschlossen\n", "* _immutable_" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Beispiele\n", "\n", "* 'a', \"\u00dcbermorgen\"\n", "* \"\u041c\u0430\u0439\u0434\u0430\u043d \u041d\u0435\u0437\u0430\u043b\u0435\u0436\u043d\u043e\u0441\u0442\u0456\", '\ud53c\ubbf8\uc998 \uc120\uad50 \uad50\ud68c''\n", "\n", "Einen mehrzeiligen String k\u00f6nnen wir so allerdings nicht eingeben. Nach Eingabe der Enter/Return-Taste erscheint eine Fehlermeldung:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "\"Hallo Siggi," ], "language": "python", "metadata": {}, "outputs": [ { "ename": "SyntaxError", "evalue": "EOL while scanning string literal (, line 1)", "output_type": "pyerr", "traceback": [ "\u001b[1;36m File \u001b[1;32m\"\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m \"Hallo Siggi,\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m EOL while scanning string literal\n" ] } ], "prompt_number": 8 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Mehrzeilige Strings (k\u00f6nnen beliebig viele Zeilenumbr\u00fcche und Leerzeichen enthalten) werden in dreifache Anf\u00fchrungszeichen (' oder \") gesetzt:" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "```\n", "\"\"\"Hallo Siggi,\n", "ich hab mein Passwort vergessen.\n", "Kannst du meins bitte zur\u00fccksetzen?\"\"\"\n", "```" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Escaping: Anf\u00fchrungszeichen in Zeichenketten\n", "\n", "* '-Anf\u00fchrungszeichen in einem '-String m\u00fcssen _escaped_ werden: \\'\n", "* \"-Anf\u00fchrungszeichen in einem \"-String m\u00fcssen _escaped_ werden: \\\"" ] }, { "cell_type": "code", "collapsed": false, "input": [ "'Er sagte, 'So geht es nicht'.'" ], "language": "python", "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "ename": "SyntaxError", "evalue": "invalid syntax (, line 1)", "output_type": "pyerr", "traceback": [ "\u001b[1;36m File \u001b[1;32m\"\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m 'Er sagte, 'So geht es nicht'.'\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n" ] } ], "prompt_number": 9 }, { "cell_type": "code", "collapsed": false, "input": [ "'Er sagte, \\'So geht es nicht\\'.'" ], "language": "python", "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 10, "text": [ "\"Er sagte, 'So geht es nicht'.\"" ] } ], "prompt_number": 10 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Escaping f\u00fcr Faule\n", "\n", "* Trick: '-Anf\u00fchrungszeichen in \"-String escapen\n", "* Trick: \"-Anf\u00fchrungszeichen in '-String escapen" ] }, { "cell_type": "code", "collapsed": false, "input": [ "\"Er sagte, 'So geht es nicht'.\"" ], "language": "python", "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 11, "text": [ "\"Er sagte, 'So geht es nicht'.\"" ] } ], "prompt_number": 11 }, { "cell_type": "code", "collapsed": false, "input": [ "'Er sagte, \"So geht es nicht\".'" ], "language": "python", "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 12, "text": [ "'Er sagte, \"So geht es nicht\".'" ] } ], "prompt_number": 12 }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Tupel\n", "\n", "* _immutable_\n", "* kann Elemente verschiedenen Typs enthalten\n", "* indizierbar; Z\u00e4hlung beginnt bei 0" ] }, { "cell_type": "code", "collapsed": false, "input": [ "lotto = (6, 9, 12, 24, 36, 41)\n", "print lotto[1] # gibt das 2. Element des lotto-Tupels auf dem Bildschirm aus" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "9\n" ] } ], "prompt_number": 13 }, { "cell_type": "code", "collapsed": false, "input": [ "lotto[1] = 42 # Wir k\u00f6nnen einem Element des Tupels nicht nachtr\u00e4glich einen neuen Wert zuweisen (_immutable_)" ], "language": "python", "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "'tuple' object does not support item assignment", "output_type": "pyerr", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mlotto\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m42\u001b[0m \u001b[1;31m# Wir k\u00f6nnen einem Element des Tupels nicht nachtr\u00e4glich einen neuen Wert zuweisen (_immutable_)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" ] } ], "prompt_number": 14 }, { "cell_type": "code", "collapsed": false, "input": [ "print lotto # unver\u00e4ndert" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "gemischte_liste = ([1,2,3], 3.14, 'Chomsky')\n", "print gemischte_liste[0]" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Listen\n", "\n", "* geordnete Sammlung von Elementen (verschiedenen Typs)\n", "* indizierbar; Z\u00e4hlung beginnt bei 0\n", "* _mutable_: Elemente k\u00f6nnen nachtr\u00e4glich ver\u00e4ndert werden (anh\u00e4ngen, l\u00f6schen)" ] }, { "cell_type": "code", "collapsed": false, "input": [ "einkauf = ['brot', 'butter']\n", "einkauf.append('milch')\n", "print len(einkauf), einkauf" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "einkauf[2] = 'k\u00e4se' # Wert des 3. Elements der einkauf-Liste wird ver\u00e4ndert\n", "print len(einkauf), einkauf" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print einkauf[2]" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "einkauf.pop(0) # nulltes Element entfernen\n", "print len(einkauf), einkauf" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "einkauf[2] = 'kwas' # mit der Index-Notation k\u00f6nnen wir nur bestehende Elemente ver\u00e4ndern, aber keine Neuen hinzuf\u00fcgen" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "einkauf.append('kwas')\n", "print einkauf" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Dictionaries\n", "\n", "* Menge von Attribut-Wert-Paaren / _hash map_ / \"key-value store\"\n", "* schneller Zugriff auf Keys (konstant)\n", "* \"Datenbank f\u00fcr Arme\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Wir basteln uns eine kleine Datenbank der aktuellen Bundesregierung. Die T\u00e4tigkeitsbeschreibung speichern wir als Attribute (_Keys_) und die zugeh\u00f6rigen Personen als Werte (_Values_):" ] }, { "cell_type": "code", "collapsed": false, "input": [ "jobs = {'chef': 'angie',\n", " 'aussen': 'frank-walter',\n", " 'innen': 'thomas',\n", " 'krieg': 'zensursula',\n", " 'ged\u00f6ns': 'manuela'}" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Wir k\u00f6nnen unsere Datenbank (das _jobs_ Dictionary) jetzt abfragen:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "print jobs['krieg'] # einen Key abfragen" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print jobs['entwicklung'] # Key existiert nicht" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Wir haben vergessen, den \"Entwicklungshilfe\"-Minister einzutragen (das _jobs_ Dictionary enth\u00e4lt kein Attribut _\"entwicklung\"_) und bekommen daher eine Fehlermeldung. Alternativ k\u00f6nnen wir das Dictionary auch so abfragen, dass kein Fehler entsteht:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "'entwicklung' in jobs" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Statt eines Wahrheitswerts k\u00f6nnen wir auch einen selbstgew\u00e4hlten Wert (_default value_) zur\u00fcckgeben, wenn ein Key nicht im Dictionary vorhanden ist:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "print jobs.get('aussen', 'Stelle frei!1!!') # Attribut vorhanden, Wert wird zur\u00fcckgegeben" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print jobs.get('entwicklung', 'Stelle frei!1!!') # Attribut nicht vorhanden, Default-Wert wird zur\u00fcckgegeben" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "jobs['entwicklung'] = 'gerd' # Attribut-Wert-Paar hinzuf\u00fcgen\n", "print jobs # gibt das komplette Dictionary aus" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print jobs.items() # Ausgabe als Liste von (Attribut, Wert)-Tupeln" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Mengen (Sets)\n", "\n", "* ungeordnete Sammlung von Elementen (auch unterschiedlichen Typs)\n", "* jedes Element kommt nur einmal vor" ] }, { "cell_type": "code", "collapsed": false, "input": [ "leere_menge = set()\n", "print leere_menge" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "foo = set([0.2,7,2,1,1,1,3,3,6])\n", "print foo # Mengen sind unsortiert!" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Mithilfe der Funktion `sorted()` k\u00f6nnen Mengen, Listen, Tupel usw. sortiert werden (numerisch, lexikographisch)" ] }, { "cell_type": "code", "collapsed": false, "input": [ "sorted(foo)" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "zahlen = set([1,2,3])\n", "mehr_zahlen = {3,4,5} # Alternativschreibweise, nicht mit Dictionary verwechseln!\n", "print zahlen, mehr_zahlen" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "3 in zahlen # Mitgliedschaft testen" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "zahlen.intersection(mehr_zahlen) # Schnittmenge beider Mengen" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "zahlen.add(\"Buchstaben sind auch ok.\")\n", "print zahlen" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "a = {1,2,3}\n", "b = {3,4,5}\n", "c = {3,7,9}\n", "\n", "a.intersection(b,c) # Schnittmenge der Mengen A, B und C" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Variablen\n", "\n", "* Platzhalter f\u00fcr bestimmte Werte\n", "* k\u00f6nnen nachtr\u00e4glich ver\u00e4ndert werden" ] }, { "cell_type": "code", "collapsed": false, "input": [ "heute = \"Donnerstag\"" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print heute" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "ename": "NameError", "evalue": "name 'heute' is not defined", "output_type": "pyerr", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mprint\u001b[0m \u001b[0mheute\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mNameError\u001b[0m: name 'heute' is not defined" ] } ], "prompt_number": 15 }, { "cell_type": "code", "collapsed": false, "input": [ "heute = \"Freitag\"\n", "print heute" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Freitag\n" ] } ], "prompt_number": 16 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Variablennamen\n", "\n", "* m\u00fcssen mit einem Buchstaben oder `_` beginnen\n", "* d\u00fcrfen keine Leerzeichen oder Sonderzeichen (ausser `_`) enthalten\n", "\n", "## erlaubt\n", "\n", "* i, _i, cookies, xml2txt, Cookies_and_Jam" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "# nicht erlaubte Variablennamen" ] }, { "cell_type": "code", "collapsed": false, "input": [ "3erlei = 123" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "ename": "SyntaxError", "evalue": "invalid token (, line 1)", "output_type": "pyerr", "traceback": [ "\u001b[1;36m File \u001b[1;32m\"\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m 3erlei = 123\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid token\n" ] } ], "prompt_number": 17 }, { "cell_type": "code", "collapsed": false, "input": [ "leer zeichen = 'Angela Merkel'" ], "language": "python", "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "ename": "SyntaxError", "evalue": "invalid syntax (, line 1)", "output_type": "pyerr", "traceback": [ "\u001b[1;36m File \u001b[1;32m\"\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m leer zeichen = 'Angela Merkel'\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n" ] } ], "prompt_number": 18 }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Ver\u00e4nderbarkeit von Datentypen\n", "\n", "* Strings, Zahlen und Tupel sind _immutable_ (k\u00f6nnen nachtr\u00e4glich nicht ver\u00e4ndert werden, nur vollst\u00e4ndig ersetzt)\n", "* Listen und Dictionaries sind _mutable_" ] }, { "cell_type": "code", "collapsed": false, "input": [ "name = \"Ronny\" # immutable\n", "print \"Mein Name beginnt mit\", name[0]\n", "name[0] = \"C\"" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Mein Name beginnt mit R\n" ] }, { "ename": "TypeError", "evalue": "'str' object does not support item assignment", "output_type": "pyerr", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0mname\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"Ronny\"\u001b[0m \u001b[1;31m# immutable\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;32mprint\u001b[0m \u001b[1;34m\"Mein Name beginnt mit\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mname\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"C\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment" ] } ], "prompt_number": 19 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Wir k\u00f6nnen das erste Element des Strings _name_ zwar abfragen, aber nicht nachtr\u00e4glich \u00e4ndern. Tupel verhalten sich genauso:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "name = ('R', 'o', 'n', 'n', 'y') # immutable\n", "print \"Mein Name beginnt mit\", name[0]\n", "name[0] = \"C\"" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Mein Name beginnt mit R\n" ] }, { "ename": "TypeError", "evalue": "'tuple' object does not support item assignment", "output_type": "pyerr", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0mname\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'R'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'o'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'n'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'n'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'y'\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# immutable\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;32mprint\u001b[0m \u001b[1;34m\"Mein Name beginnt mit\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mname\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"C\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" ] } ], "prompt_number": 20 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Im Gegensatz zu Strings und Tuoeln sind Listen _mutable_,\n", "wir k\u00f6nnen daher nicht nur das erste Element abfragen, sondern es auch nachtr\u00e4glich ver\u00e4ndern:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "name = ['R', 'o', 'n', 'n', 'y'] # mutable\n", "name[0] = \"C\"\n", "print name" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "['C', 'o', 'n', 'n', 'y']\n" ] } ], "prompt_number": 21 }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Variablenzuweisung und (un)ver\u00e4nderliche Datentypen\n", "\n", "## Beispiel 1: Strings (unver\u00e4nderlich)" ] }, { "cell_type": "code", "collapsed": false, "input": [ "bradley_manning = \"89289\"\n", "chelsea_manning = bradley_manning # beide Variablen referenzieren jetzt den gleichen String\n", "print \"Werte: \", bradley_manning, chelsea_manning\n", "print \"Speicheradresse: \", id(bradley_manning), id(chelsea_manning)" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Werte: 89289 89289\n", "Speicheradresse: 46327008 46327008\n" ] } ], "prompt_number": 22 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Die Variable _bradley_manning_ bekommt einen neuen Wert zugewiesen (mit neuer Speicheradresse), _chelsea_manning_ beh\u00e4lt hingegen den alten Wert:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "bradley_manning = \"007\" # Der Variable wird ein neuer Wert zugewiesen.\n", "print \"Werte: \", bradley_manning, chelsea_manning\n", "print \"Speicheradresse: \", id(bradley_manning), id(chelsea_manning)" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Werte: 007 89289\n", "Speicheradresse: 46360616 46327008\n" ] } ], "prompt_number": 23 }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Beispiel 2: Listen (ver\u00e4nderlich)" ] }, { "cell_type": "code", "collapsed": false, "input": [ "einkauf = ['brot', 'butter']\n", "zweikauf = einkauf\n", "print einkauf, zweikauf\n", "print id(einkauf), id(zweikauf)" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "['brot', 'butter'] ['brot', 'butter']\n", "44845536 44845536\n" ] } ], "prompt_number": 24 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Die Liste, die der Variable _einkauf_ zugewiesen wurde, wird durch Anh\u00e4ngung eines Elements ver\u00e4ndert.\n", "Die Variablen _einkauf_ und _zweikauf_ referenzieren immernoch das gleiche (aber ver\u00e4nderte) Objekt:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "einkauf.append('wasser')\n", "print einkauf, zweikauf\n", "print id(einkauf), id(zweikauf)" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "['brot', 'butter', 'wasser'] ['brot', 'butter', 'wasser']\n", "44845536 44845536\n" ] } ], "prompt_number": 25 }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Slices\n", "\n", "* Auswahl von Teilen einer Liste / eines Tupels / eines Strings ...\n", "* Z\u00e4hler beginnt bei 0" ] }, { "cell_type": "code", "collapsed": false, "input": [ "zehner = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 26 }, { "cell_type": "code", "collapsed": false, "input": [ "zehner[3:] # vom vierten Element bis einschliesslich des letzten Elements" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 27, "text": [ "[30, 40, 50, 60, 70, 80, 90, 100]" ] } ], "prompt_number": 27 }, { "cell_type": "code", "collapsed": false, "input": [ "print zehner [0:5] # vom ersten Element bis einschliesslich des f\u00fcnften Elements\n", "print zehner[:5] # Kurzschreibweise" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[0, 10, 20, 30, 40]\n", "[0, 10, 20, 30, 40]\n" ] } ], "prompt_number": 28 }, { "cell_type": "code", "collapsed": false, "input": [ "zehner[2:5] # vom 3. bis einschliesslich des 5. Elements" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 29, "text": [ "[20, 30, 40]" ] } ], "prompt_number": 29 }, { "cell_type": "code", "collapsed": false, "input": [ "zehner[4:-1] # vom 5. Element bis einschliesslich des vorletzten Elements" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 30, "text": [ "[40, 50, 60, 70, 80, 90]" ] } ], "prompt_number": 30 }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Intervalle (Ranges)\n", "\n", "Die Funktion `range(n)` gibt eine Liste der Ganzzahlen 0 bis n-1 zur\u00fcck:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "range(10)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 31, "text": [ "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]" ] } ], "prompt_number": 31 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Die Funktion `range(i, n)` gibt eine Liste der Ganzzahlen i bis n-1 zur\u00fcck:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "range(1,10)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 32, "text": [ "[1, 2, 3, 4, 5, 6, 7, 8, 9]" ] } ], "prompt_number": 32 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Die Funktion `range(i, n, increment)` gibt eine Liste aller Ganzzahlen i, i+increment, i+increment*2 ... < n" ] }, { "cell_type": "code", "collapsed": false, "input": [ "print range(0, 101, 10) # von 1 bis einschliesslich 100 mit Schrittweite 10" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]\n" ] } ], "prompt_number": 33 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Operatoren\n", "\n", "* werden verwendet, um Ausdr\u00fccke zu verkn\u00fcpfen\n", "* viele Operatoren sind _\u00fcberladen_, d.h. sie sind auf verschiedene Typen anwendbar" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "# +: Addition vs. Konkatenation" ] }, { "cell_type": "code", "collapsed": false, "input": [ "2 + 3" ], "language": "python", "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 34, "text": [ "5" ] } ], "prompt_number": 34 }, { "cell_type": "code", "collapsed": false, "input": [ "'2' + '3'" ], "language": "python", "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 35, "text": [ "'23'" ] } ], "prompt_number": 35 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "# *: Multiplikation" ] }, { "cell_type": "code", "collapsed": false, "input": [ "2 * 6" ], "language": "python", "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 36, "text": [ "12" ] } ], "prompt_number": 36 }, { "cell_type": "code", "collapsed": false, "input": [ "'2' * 6" ], "language": "python", "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 37, "text": [ "'222222'" ] } ], "prompt_number": 37 }, { "cell_type": "code", "collapsed": false, "input": [ "'2' * '6' # Der Operator * kann nicht auf zwei Strings angewendet werden" ], "language": "python", "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "ename": "TypeError", "evalue": "can't multiply sequence by non-int of type 'str'", "output_type": "pyerr", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;34m'2'\u001b[0m \u001b[1;33m*\u001b[0m \u001b[1;34m'6'\u001b[0m \u001b[1;31m# Der Operator * kann nicht auf zwei Strings angewendet werden\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mTypeError\u001b[0m: can't multiply sequence by non-int of type 'str'" ] } ], "prompt_number": 38 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "# <, <=, >, >=: kleiner(gleich), gr\u00f6sser(gleich)" ] }, { "cell_type": "code", "collapsed": false, "input": [ "4 < 2" ], "language": "python", "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 39, "text": [ "False" ] } ], "prompt_number": 39 }, { "cell_type": "code", "collapsed": false, "input": [ "'elefant' < 'mouse' # lexikographischer Vergleich" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 40, "text": [ "True" ] } ], "prompt_number": 40 }, { "cell_type": "code", "collapsed": false, "input": [ "2<=2" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 41, "text": [ "True" ] } ], "prompt_number": 41 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "# ==, !=: Gleichheit, Ungleichheit\n", "\n", "* Gleichheitsoperator ==: **Gleichheit** bezieht sich hier auf die **Werte** (Bsp.: die Variablen _a_ und _b_ haben den gleichen Wert)\n", "* nicht verwechseln mit dem Identit\u00e4tsoperator _is_: \u00fcberpr\u00fcft, ob die beiden Variablen das gleiche Objekt referenzieren" ] }, { "cell_type": "code", "collapsed": false, "input": [ "a = 23\n", "b = 42\n", "a == b" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 42, "text": [ "False" ] } ], "prompt_number": 42 }, { "cell_type": "code", "collapsed": false, "input": [ "a != b" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 43, "text": [ "True" ] } ], "prompt_number": 43 }, { "cell_type": "code", "collapsed": false, "input": [ "'aaa' == 'aaa'" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 44, "text": [ "True" ] } ], "prompt_number": 44 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "# X and Y\n", "\n", "* wahr, wenn beide Bedingungen erf\u00fcllt sind" ] }, { "cell_type": "code", "collapsed": false, "input": [ "1 < 2 and 'b' > 'a'" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 45, "text": [ "True" ] } ], "prompt_number": 45 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "# X or Y: inklusives oder\n", "\n", "* wahr, wenn X oder Y oder beide wahr sind" ] }, { "cell_type": "code", "collapsed": false, "input": [ "1 < 2 or 1 > 2" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 46, "text": [ "True" ] } ], "prompt_number": 46 }, { "cell_type": "markdown", "metadata": {}, "source": [ "# X in Y\n", "\n", "* wahr, wenn X in Y enthalten ist\n", "* Y ist ein Container/Iterable (z.B. Menge, Liste oder Tupel)" ] }, { "cell_type": "code", "collapsed": false, "input": [ "'apple' in ['apple', 'banana', 'cherry']" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 47, "text": [ "True" ] } ], "prompt_number": 47 }, { "cell_type": "markdown", "metadata": {}, "source": [ "# not X\n", "\n", "* wahr, wenn X nicht wahr ist" ] }, { "cell_type": "code", "collapsed": false, "input": [ "'pizza' not in ['apple', 'banana', 'cherry']" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 48, "text": [ "True" ] } ], "prompt_number": 48 }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "skip" } }, "source": [ "# Typisierung\n", "\n", "* C++: statisch typisiert (Typ einer Variable muss bei Instanziierung bekannt sein)\n", "* Python: dynamisch typisiert (Typ der Variable wird erst w\u00e4hrend des Programmablaufs bestimmt)" ] }, { "cell_type": "code", "collapsed": false, "input": [ "print type(1), type(1.0), type(\"1\"), type([1])" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ " \n" ] } ], "prompt_number": 49 }, { "cell_type": "code", "collapsed": false, "input": [ "print isinstance(1, str) # gibt Wahrheitswert zur\u00fcck" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "False\n" ] } ], "prompt_number": 50 }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Vorsicht**: Interpretation kann auch \"schiefgehen\"!\n", "\n", "Python interpretiert Ganzzahlen mit f\u00fchrender Null als Zahlen im Oktalsystem und rechnet diese automatisch in das Dezimalsystem um:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "print 033" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "27\n" ] } ], "prompt_number": 51 }, { "cell_type": "code", "collapsed": false, "input": [ "type(033)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 52, "text": [ "int" ] } ], "prompt_number": 52 }, { "cell_type": "code", "collapsed": false, "input": [ "oct(27) # Umrechnung der Ganzzahl 27 (Dezimalsystem) in das Oktalsystem" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 53, "text": [ "'033'" ] } ], "prompt_number": 53 }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Datentypen konvertieren (type cast)" ] }, { "cell_type": "code", "collapsed": false, "input": [ "print int(3.14) ## Umwandlung float --> int\n", "print type(int(\"2\")), type(str(2)) ## Umwandlung str --> int sowie int --> str" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "3\n", " \n" ] } ], "prompt_number": 54 }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Kontrollstrukturen\n", "\n", "## if-then-else" ] }, { "cell_type": "code", "collapsed": false, "input": [ "kontostand = -100\n", "\n", "if kontostand > 0:\n", " print \"Auszahlung l\u00e4uft\"\n", "else:\n", " print \"Geht nicht, weil iss nicht!\"" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Geht nicht, weil iss nicht!\n" ] } ], "prompt_number": 55 }, { "cell_type": "markdown", "metadata": {}, "source": [ "## if then, else-if then, else" ] }, { "cell_type": "code", "collapsed": false, "input": [ "fruits = ['apple', 'banana', 'cherry']\n", "veggies = ['avocado', 'tomato', 'beetroot']\n", "\n", "food_item = 'pizza'\n", "\n", "if food_item in fruits:\n", " print \"It's sweet!\"\n", "elif food_item in veggies:\n", " print \"It's healty!\"\n", "else:\n", " print \"Oh noes!\"" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Oh noes!\n" ] } ], "prompt_number": 56 }, { "cell_type": "markdown", "metadata": {}, "source": [ "## for (ohne Z\u00e4hlervariable)" ] }, { "cell_type": "code", "collapsed": false, "input": [ "for dingsbums in fruits:\n", " print dingsbums" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "apple\n", "banana\n", "cherry\n" ] } ], "prompt_number": 57 }, { "cell_type": "markdown", "metadata": {}, "source": [ "# for (mit Z\u00e4hler)" ] }, { "cell_type": "code", "collapsed": false, "input": [ "for zaehler, gemuese in enumerate(veggies):\n", " print \"veggie number\", zaehler, \"is a\", gemuese" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "veggie number 0 is a avocado\n", "veggie number 1 is a tomato\n", "veggie number 2 is a beetroot\n" ] } ], "prompt_number": 58 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Wie funktioniert dieser Z\u00e4hler?\n", "\n", "Wir wenden die Funktion `enumerate()` auf ein iterierbares (\"durchz\u00e4hlbares\") Objekt an, also z.B. Listen, Tupel, Strings oder Dictionaries. Als Ergebnis bekommen wir eine Liste von 2-Tupeln (bestehend aus dem Index des Elements und dem Element selbst).\n", "\n", "gemuesezaehler = enumerate(veggies)\n", "\n", "Intern sieht der \"Gem\u00fcsez\u00e4hler\" jetzt so aus:\n", "[(0, 'avocado'), (1, 'tomato'), (2, 'beetroot')]\n", "\n", "**Irrelevantes Detail f\u00fcr Fortgeschrittene**: aus Effizienzgr\u00fcnden liefert enumerate keine Liste zur\u00fcck, sondern ein Objekt mit der Funktion `next()`, welches uns das jeweils n\u00e4chste 2-Tupel der Gem\u00fcsez\u00e4hlerliste zur\u00fcckgibt:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "gemuesezaehler = enumerate(veggies)\n", "print gemuesezaehler.next()\n", "print gemuesezaehler.next()\n", "print gemuesezaehler.next()\n", "print gemuesezaehler.next()" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "(0, 'avocado')\n", "(1, 'tomato')\n", "(2, 'beetroot')\n" ] }, { "ename": "StopIteration", "evalue": "", "output_type": "pyerr", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mStopIteration\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;32mprint\u001b[0m \u001b[0mgemuesezaehler\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[1;32mprint\u001b[0m \u001b[0mgemuesezaehler\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[1;32mprint\u001b[0m \u001b[0mgemuesezaehler\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mStopIteration\u001b[0m: " ] } ], "prompt_number": 59 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Die **for-Schleife** braucht also gar nicht zu wissen, wieviele Elemente unsere Liste enth\u00e4lt. `enumerate` liefert sowohl den Z\u00e4hler des aktuellen Schleifendurchlaufs als auch die Information, wann die Schleife abgebrochen werden kann (`StopIteration`)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# for (nur Z\u00e4hler)" ] }, { "cell_type": "code", "collapsed": false, "input": [ "for i in range(1,10):\n", " print 'a' * i" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "a\n", "aa\n", "aaa\n", "aaaa\n", "aaaaa\n", "aaaaaa\n", "aaaaaaa\n", "aaaaaaaa\n", "aaaaaaaaa\n" ] } ], "prompt_number": 60 }, { "cell_type": "markdown", "metadata": {}, "source": [ "# String-Formatierung\n", "\n", "* Werte (von Variablen) in vorhandene Strings einf\u00fcgen" ] }, { "cell_type": "code", "collapsed": false, "input": [ "name = \"Horst\"\n", "print \"Hallo {}! Wie geht's?\".format(name)" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Hallo Horst! Wie geht's?\n" ] } ], "prompt_number": 61 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Der Wert der Variable `name` wurde in den String an die Stelle `{}` eingef\u00fcgt. \n", "Wenn man mehrere Werte in einen String einf\u00fcgen m\u00f6chte, muss man die `{}` numerieren:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "name1 = \"Horst\"\n", "name2 = \"Ulla\"\n", "print \"Hallo {0}! Kennst du {1} schon?\".format(name1, name2)" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Hallo Horst! Kennst du Ulla schon?\n" ] } ], "prompt_number": 62 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Die `format()`-Methode kann man auch direkt mit Werten f\u00fcttern, \n", "es m\u00fcssen auch keine Strings sein (solange sie sich in einen String umwandeln lassen):" ] }, { "cell_type": "code", "collapsed": false, "input": [ "print \"pi ist {0} und nicht {1} oder gar {2}!\".format(3.141592653589793, 23, 'Kuchen')" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "pi ist 3.14159265359 und nicht 23 oder gar Kuchen!\n" ] } ], "prompt_number": 63 }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Funktionen\n", "\n", "* Bl\u00f6cke von h\u00e4ufig verwendeten Anweisungen zusammenfassen\n", "* k\u00f6nnen beliebig viele Parameter haben\n", "\n", "## Funktion mit einem Parameter" ] }, { "cell_type": "code", "collapsed": false, "input": [ "def greeting(name):\n", " return \"Hallo, {}. Wie geht's?\".format(name)" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 64 }, { "cell_type": "code", "collapsed": false, "input": [ "print greeting('Horst')" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Hallo, Horst. Wie geht's?\n" ] } ], "prompt_number": 65 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Welchen Typ der Parameter `name` hat ist der Funktion prinzipiell egal.\n", "\n", "**Irrelevantes Detail f\u00fcr Fortgeschrittene**: die `format()`-Methode kann jedes Objekt in einen String einf\u00fcgen, das eine `__str__()`-Methode hat." ] }, { "cell_type": "code", "collapsed": false, "input": [ "print greeting(12)" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Hallo, 12. Wie geht's?\n" ] } ], "prompt_number": 66 }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Funktion mit zwei Parametern" ] }, { "cell_type": "code", "collapsed": false, "input": [ "def greeting2(name, formality):\n", " hello = \"Hallo, %s!\" % name\n", " if formality == 'formell':\n", " return hello + \" Wie geht es Ihnen?\"\n", " elif formality == 'informell':\n", " return hello + \" Wie geht es dir?\"\n", " else:\n", " return hello" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 67 }, { "cell_type": "code", "collapsed": false, "input": [ "print greeting2('Ulla', 'formell') # if ..." ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Hallo, Ulla! Wie geht es Ihnen?\n" ] } ], "prompt_number": 68 }, { "cell_type": "code", "collapsed": false, "input": [ "print greeting2('Ulla', 'informell') # else if ..." ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Hallo, Ulla! Wie geht es dir?\n" ] } ], "prompt_number": 69 }, { "cell_type": "code", "collapsed": false, "input": [ "print greeting2('Ulla', 'ksdlfksdlfskdlfsd') # else" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Hallo, Ulla!\n" ] } ], "prompt_number": 70 }, { "cell_type": "code", "collapsed": false, "input": [ "print greeting2('Ulla') # ein Parameter zu wenig \u00fcbergeben" ], "language": "python", "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "greeting2() takes exactly 2 arguments (1 given)", "output_type": "pyerr", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mprint\u001b[0m \u001b[0mgreeting2\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Ulla'\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# ein Parameter zu wenig \u00fcbergeben\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mTypeError\u001b[0m: greeting2() takes exactly 2 arguments (1 given)" ] } ], "prompt_number": 71 }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Funktion mit obligatorischem und optionalem Parameter\n", "\n", "* es m\u00fcssen immer zuerst alle obligatorischen Parameter definiert werden" ] }, { "cell_type": "code", "collapsed": false, "input": [ "def greeting3(name, formality=None):\n", " hello = \"Hallo, %s!\" % name\n", " if formality is None: # geht auch: if formality == None\n", " return hello\n", " elif formality == 'formell':\n", " return hello + \" Wie geht es Ihnen?\"\n", " else:\n", " return hello + \" Wie geht es dir?\"" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 72 }, { "cell_type": "code", "collapsed": false, "input": [ "print greeting3('Maik') # ohne optionalen Parameter" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Hallo, Maik!\n" ] } ], "prompt_number": 73 }, { "cell_type": "code", "collapsed": false, "input": [ "print greeting3('Maik', 'formell') # else if ..." ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Hallo, Maik! Wie geht es Ihnen?\n" ] } ], "prompt_number": 74 }, { "cell_type": "code", "collapsed": false, "input": [ "print greeting3('Maik', 'informell') # else ..." ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Hallo, Maik! Wie geht es dir?\n" ] } ], "prompt_number": 75 }, { "cell_type": "code", "collapsed": false, "input": [ "print greeting3('Maik', 'Kn\u00e4ckebrot') # ebenfalls else ..." ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Hallo, Maik! Wie geht es dir?\n" ] } ], "prompt_number": 76 }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Funktionen ohne R\u00fcckgabewert\n", "\n", "Funktionen ohne `return`-Anweisung haben immer den R\u00fcckgabewert `None`." ] }, { "cell_type": "code", "collapsed": false, "input": [ "def plus2(zahl):\n", " print zahl+2\n", " " ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 77 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Die Funktion `plus2(zahl)` addiert 2 zur gegebene Zahl und gibt das Ergebnis nur auf dem Bildschirm aus." ] }, { "cell_type": "code", "collapsed": false, "input": [ "plus2(10) " ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "12\n" ] } ], "prompt_number": 78 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Beim Versuch das Ergebnis der Funktion `plus2()` in einer Variable zu speichern, kommt es zu unerwarteten Effekten:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "ergebnis = plus2(10)" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "12\n" ] } ], "prompt_number": 79 }, { "cell_type": "code", "collapsed": false, "input": [ "print ergebnis" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "None\n" ] } ], "prompt_number": 80 }, { "cell_type": "code", "collapsed": false, "input": [ "print ergebnis + -100" ], "language": "python", "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "unsupported operand type(s) for +: 'NoneType' and 'int'", "output_type": "pyerr", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mprint\u001b[0m \u001b[0mergebnis\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;33m-\u001b[0m\u001b[1;36m100\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'NoneType' and 'int'" ] } ], "prompt_number": 81 }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Klassen\n", "\n", "* verbinden Daten und die darauf anwendbaren Funktionen zu einem Objekt\n", "* Funktionen, die in Klassen definiert sind hei\u00dfen Methoden\n", "* Methoden haben als ersten Parameter immer **self**\n", "* **self** bezeichnet das Objekt / die Instanz der Klasse, mit dem wir gerade arbeiten" ] }, { "cell_type": "code", "collapsed": false, "input": [ "class Gruessaugust:\n", " \"\"\"\n", " Ein Gr\u00fc\u00dfaugust hat nur eine Aufgabe: Gr\u00fc\u00dfen.\n", " \n", " Jede Instanz der Klasse Gruessaugust hat genau eine Methode:\n", " print_greeting(name).\n", " \"\"\"\n", " def print_greeting(self, name):\n", " print \"Hallo {}\".format(name)" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 82 }, { "cell_type": "code", "collapsed": false, "input": [ "wulff = Gruessaugust() # wulff ist eine Instanz der Klasse Gruessaugust" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 83 }, { "cell_type": "code", "collapsed": false, "input": [ "wulff.print_greeting(\"Angie\") # wulff kann alle Methoden nutzen, die f\u00fcr die Klasse Gruessaugust definiert sind" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Hallo Angie\n" ] } ], "prompt_number": 84 }, { "cell_type": "code", "collapsed": false, "input": [ "print_greeting(\"Angie\") # die Methoden einer Klasse k\u00f6nnen nur auf einer Instanz derselben aufgerufen werden" ], "language": "python", "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'print_greeting' is not defined", "output_type": "pyerr", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint_greeting\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Angie\"\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# die Methoden einer Klasse k\u00f6nnen nur auf einer Instanz derselben aufgerufen werden\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mNameError\u001b[0m: name 'print_greeting' is not defined" ] } ], "prompt_number": 85 }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Instanzvariablen\n", "\n", "* Variablen, die der Instanz (**self**) einer Klasse zugeordet sind (nicht der Klasse selber)" ] }, { "cell_type": "code", "collapsed": false, "input": [ "class Gruesser:\n", " def __init__(self, gruesser_name):\n", " self.name = gruesser_name\n", " def print_greeting(self, gast):\n", " print \"Der Gr\u00fcssaugust {0} begr\u00fc\u00dft den Gast {1}\".format(self.name, gast)" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 86 }, { "cell_type": "code", "collapsed": false, "input": [ "wulff = Gruesser(\"Christian\")" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 87 }, { "cell_type": "code", "collapsed": false, "input": [ "wulff.name" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 88, "text": [ "'Christian'" ] } ], "prompt_number": 88 }, { "cell_type": "code", "collapsed": false, "input": [ "wulff.print_greeting(\"Putin\")" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Der Gr\u00fcssaugust Christian begr\u00fc\u00dft den Gast Putin\n" ] } ], "prompt_number": 89 }, { "cell_type": "code", "collapsed": false, "input": [ "koehler = Gruesser('Horst')" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 90 }, { "cell_type": "code", "collapsed": false, "input": [ "koehler.name" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 91, "text": [ "'Horst'" ] } ], "prompt_number": 91 }, { "cell_type": "code", "collapsed": false, "input": [ "koehler.print_greeting(\"Juncker\")" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Der Gr\u00fcssaugust Horst begr\u00fc\u00dft den Gast Juncker\n" ] } ], "prompt_number": 92 } ], "metadata": {} } ] }