seminar06.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Seminar Problemorientierte Programmierung\n",
    "\n",
    "## Exkurs: Was mir an Python gefällt\n",
    "\n",
    "In dieser Rubrik, die immer am Anfang eines Kapitels steht, möchte ich Ihnen zeigen, wofür ich Python nutze und warum ich es mag. Sie werden vielleicht noch nicht verstehen, was ich genau mache, aber Sie sehen damit schon einmal die Möglichkeiten von Python und können später darauf zurückgreifen. Da dies auch ein Exkurs ist, können Sie diese Rubrik gerne auch erst einmal überspringen.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" \n",
    "Quelle: https://teampython.wordpress.com/2015/12/12/print-a-christmas-tree/\n",
    "Python 3 version by antiloquax (2015), based on code from datamungeblog.com.\n",
    "\"\"\"\n",
    " \n",
    "from random import choice\n",
    "from random import random\n",
    " \n",
    "# If you change this, use an odd number.\n",
    "size = 21\n",
    "\n",
    "# Probability that a character will be green.\n",
    "prob_gr = 0.6\n",
    "# Colour codes.\n",
    "colours = [31, 33, 34, 35, 36, 37]\n",
    "# Characters to use for decorations. Experiment with these.\n",
    "# The chr(169) and chr(174) characters may not work in all terminals\n",
    "# (extended ASCII, c and r in a circle).\n",
    "decs = ['@', '&', '*', chr(169), chr(174)]\n",
    "\n",
    "# Format string for printing blinking characters.\n",
    "blink_col = \"\\033[5;{0}m{1}\\033[0m\"\n",
    "# String to print a green octothorpe ('#').\n",
    "leaf = \"\\033[32m#\\033[0m\"\n",
    "\n",
    "# Width of the tree, will grow by 2 each time.\n",
    "width = 1\n",
    "# Initialise the tree string, with a star at the top.\n",
    "tree = \"\\n{}*\\n\".format(' ' * (size))\n",
    "\n",
    "\"\"\" Main Loop starts now.\"\"\"\n",
    " \n",
    "\"\"\" We can't use the normal \"format\" centering approach:\n",
    "    (\"{:^nn}\".format(string) where \"nn\" is the width of the line), \n",
    "    with these ansi codes. This is because Python sees the strings as being\n",
    "    more than one character long (15 & 10 for baubles and leaves).\"\"\"\n",
    "\n",
    "# Loop from (size - 1) down to 0, using the counter as the padding size.\n",
    "for pad in range(size - 1, -1, -1):\n",
    "    # Increase the width of the tree by 2.\n",
    "    width += 2\n",
    "     \n",
    "    # Put the characters for the line in \"temp\".\n",
    "    temp = \"\"\n",
    "    for j in range(width):\n",
    "        # Make some leaves.\n",
    "        if random() < prob_gr:\n",
    "            temp += leaf\n",
    "        # And also some baubles.\n",
    "        else:\n",
    "            temp += blink_col.format(choice(colours), choice(decs))\n",
    "\n",
    "    # Add that string to the line, with padding.\n",
    "    tree += \"{0}{1}\\n\".format(' ' * pad, temp)\n",
    "\n",
    "# Add a \"trunk\" of 2 lines and return.\n",
    "print(tree + \"{0}{1}\\n\".format(' ' * (size - 1), \"000\") * 2)\n",
    "print(\"\\x46\\x72\\x6f\\x68\\x65\\x20\\x46\\x65\\x73\\x74\\x74\\x61\\x67\\x65\\x21\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Und noch viele weitere schöne Beispiele: https://codegolf.stackexchange.com/questions/15860/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6 Ertragreiche Funktionen\n",
    "\n",
    "Viele Python-Funktionen die wir bis jetzt genutzt haben, wie z.B. die Mathematik-Funktionen aus dem `math`-Modul, erzeugen Rückgabewerte (*return values*). Aber die meisten Funktionen die wir bisher selber geschrieben haben sind \"leer\": sie bewirken etwas, beispielsweise die Ausgabe eines Wertes (mit Hilfe der `print`-Funktion) oder die Bewegung einer Schildkröte, aber sie haben keinen Rückgabewert. In diesem Kapitel werden wir lernen, wie wir \"ertragreiche Funktionen\", also solche mit Rückgabewert, schreiben können.\n",
    "\n",
    "![RFC 1149.5 specifies 4 as the standard IEEE-vetted random number.](https://imgs.xkcd.com/comics/random_number.png)\n",
    "\n",
    "([Random Number](https://xkcd.com/221/), Randall Munroe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.1 Rückgabewerte\n",
    "\n",
    "Der Aufruf einer Funktion erzeugt einen Rückgabewert, den wir üblicherweise einer Variable zuweisen oder als Teil eines Ausdrucks verwenden:\n",
    "\n",
    "```python\n",
    "e = math.exp(1.0)\n",
    "height = radius * math.sin(radians)\n",
    "```\n",
    "\n",
    "Die (meisten) Funktionen, die wir bisher geschrieben haben sind \"leer\" - sie haben keinen Rückgabewert. Präziser ausgedrückt ist ihr Rückgabewert `None` (also nichts).\n",
    "\n",
    "In diesem Kapitel schreiben wir (endlich) ertragreiche Funktionen. Das erste Beispiel ist die Funktion `kreisflaeche`, die die Fläche eines Kreises für einen gegebenen Radius berechnet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def kreisflaeche(radius):\n",
    "    a = math.pi * radius**2\n",
    "    return a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wir haben die `return`-Anweisung vorher schon einmal gesehen, aber in ertragreichen Funktionen folgt hinter der `return`-Anweisung ein Ausdruck (im Beispiel oben `a`). Die Anweisung bedeutet: \"Beende sofort diese Funktion und verwende den folgenden Ausdruck als Rückgabewert.\" Der Ausdruck kann beliebig kompliziert sein, wir könnten diese Funktion also auch kürzer schreiben: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def kreisflaeche(radius):\n",
    "    return math.pi * radius**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Auf der anderen Seite können uns **temporäre Variablen** wie `a` beim Debugging helfen.\n",
    "\n",
    "Manchmal ist es nützlich, mehrere `return`-Anweisungen zu haben - eine in jedem Zweig einer Verzweigung:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def betrag(x):\n",
    "    if x < 0:\n",
    "        return -x\n",
    "    else:\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Da solche `return`-Anweisungen in alternativen (sich gegenseitig ausschließenden) Zweigen liegen, wird nur eine davon ausgeführt.\n",
    "\n",
    "Sobald eine `return`-Anweisung ausgeführt wird, wird die Funktion beendet, ohne die folgenden Anweisungen auszuführen. Code der nach einer `return`-Anweisung folgt oder an einer anderen Stelle, die während der Ausführung niemals erreicht werden kann, wird **toter Code** (*dead code*) genannt.\n",
    "\n",
    "![dead code](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/deadcode.svg)\n",
    "\n",
    "In einer eintragreichen Funktion sollten wir sicherstellen, dass jeder mögliche Pfad durch den Code eine `return`-Anweisung erreicht. Zum Beispiel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def betrag(x):\n",
    "    if x < 0:\n",
    "        return -x\n",
    "    if x > 0:\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diese Funktion ist falsch, denn wenn `x` gleich 0 ist, ist keine der beiden Bedingungen erfüllt und die Funktion wird beendet, ohne dass eine `return`-Anweisung erreicht wird. Wenn die Ausführung das Ende einer Funktion erreicht, ist der Rückgabewert `None`, was nicht der Betrag von 0 ist:"
   ]
  },