SE_BMMF/01kapitel/014 Datentypen.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Software Entwicklung \n",
    "\n",
    "## Kapitel 1: Einführung \n",
    "\n",
    "### 1.4 Datentypen \n",
    "\n",
    "Wie bereits erwähnt setzt sich ein Wert in Python zusammen aus\n",
    "\n",
    "- dem Datentyp (z.B. <code>int</code> für eine ganze Zahl)\n",
    "- der Ausprägung (z.B. die Zahl 17)\n",
    "\n",
    "des Werts. Beide Informationen werden im Speicher abgelegt und sind\n",
    "abrufbar.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### 1.4.1 Operationen mit Datentypen\n",
    "\n",
    "Je nach Datentyp können mit einem Wert unterschiedliche Operationen ausgeführt werden. \n",
    "Für den Befehl zur Ausführung einer Operation gibt es unterschiedliche Notationen:\n",
    "\n",
    "- Infix-Notation zwischen zwei Werten, z.B. bei <code>3 + 4</code>, um eine Addition auszuführen\n",
    "- Funktionsaufruf mit dem Wert als Parameter, z.B. bei Built-In Funktionen wie <code>len(\"Hello World\")</code>\n",
    "- Dot-Notation, d.h. der Operationsaufruf wird mit einem Punkt getrennt direkt an den Wert angängt, z.B. bei \n",
    "  <code>\"pYthon\".capitalize()</code>\n",
    "  \n",
    "In jedem Fall wird etwas mit dem Wert \"gemacht\" und ein Ergebniswert zurückgegeben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "3 + 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "len(\"Test\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "\"pYthon\".capitalize()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Im Folgenden werden die elementaren Datentypen von Python mit ihren Infix-Operationen betrachtet.\n",
    "\n",
    "#### 1.4.2 Ganze Zahlen\n",
    "\n",
    "Ganze Zahlen werden in Python als Integer-Werte <code>int</code> bezeichnet. Anders als in anderen Programmiersprachen \n",
    "gibt es keine genaue Vorgabe, wie viele Bytes für einen Integer-Wert verwendet werden. Python nimmt einfach so viele, \n",
    "wie für die Darstellung des Werts notwendig sind. In der Konsequenz ist der Wertebereich von Integers nur durch den\n",
    "Arbeitsspeicher begrenzt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "big_number = 100 * 100 * 100 * 100 * 100 * 1000000\n",
    "print(big_number)\n",
    "print(type(big_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Für den Datentyp <code>int</code> gibt es die üblichen Infix-Rechenoperationen\n",
    "\n",
    "| *Operation*    | *Schreibweise*       | *Ergebnis*     |\n",
    "|----------------|----------------------|----------------|\n",
    "| Addition       | <code>1 + 2</code>   | <code>3</code> |\n",
    "| Subtraktion    | <code>3 - 2</code>   | <code>1</code> |\n",
    "| Multiplikation | <code>2 * 3</code>   | <code>6</code> |\n",
    "| Division       | <code>7 // 3</code>  | <code>2</code> |\n",
    "| Modulo         | <code>7 % 3</code>   | <code>1</code> |\n",
    "| Potenzierung   | <code>2 ** 3</code>  | <code>8</code> |\n",
    "| bitweises AND  | <code>2 & 3</code>   | <code>2</code> |\n",
    "| bitweises OR   | <code>2 \\| 3</code>  | <code>3</code> |\n",
    "| bitweises XOR  | <code>2 ^ 3</code>   | <code>1</code> |\n",
    "| bitweiser Shift links   | <code>3 << 1</code>  | <code>6</code> |\n",
    "| bitweiser Shift rechts  | <code>8 >> 2</code>  | <code>2</code> |\n",
    "\n",
    "\n",
    "Bei der Divison <code>//</code> handelt es sich um die ganzzahlige Division, bei der das\n",
    "Ergebnis auf den nächstgelegenen Integer-Wert abgerundet wird. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "1 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "3 - 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "2 * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "7 // 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "7 % 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "2 ** 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "2 & 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "2 | 3\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "2 ^ 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "3 << 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "8 >> 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Neben der Dezimalschreibweise können ganze Zahlen auch binär mit dem Präfix <code>0b</code>,\n",
    "oktal mir dem Präfix <code>0o</code> und hexadezimal mit dem Präfix <code>0x</code> angegeben werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "0b111"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "0o15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "0xAB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### 1.4.3 Gleitkommazahlen\n",
    "\n",
    "Gleitkommazahlen werden in Python <code>float</code> genannt. Im Gegensatz zu den ganzen Zahlen ist\n",
    "die Speicherrepräsentation auf 64 Bit begrenzt und durch IEEE 754 vorgegeben.\n",
    "\n",
    "![Speicherrepräsentation IEEE754](../img/IEEE754.png \"IEEE754\") \n",
    "\n",
    "Somit ergibt sich ein Wertebereich von ca. $-10^{308}$ bis $+10^{308}$. \n",
    "\n",
    "Gleitkommazahlen werden mit einem Dezimalpunkt geschrieben. Die bei den ganzen Zahlen aufgeführten \n",
    "Operationen auch bei Gleitkommazahlen möglich - auch in Kombination mit ganzen Zahlen. Der Rückgabewert ergibt sich \n",
    "aber immer als eine Gleitkommazahl, sobald einer der Operanden eine Gleitkommazahl ist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "1.0 + 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "3.0 - 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "2 * 3.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "7.0 / 3.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "7.1 % 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "2.5 ** 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Ist bei der Divison <code>//</code> einer der Operanden eine Gleitkommazahl, so wird das Ergebnis ebenfalls \n",
    "abgerundet, jedoch als Gleitkommazahl zurückgegeben.\n",
    "\n",
    "Die Divison ohne Rundung wird mit einem einfachen Schrägstrich <code>/</code> ausgedrückt. Sie liefert immer\n",
    "eine Gleitkommazahl.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "6 / 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "7 / 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "7.0 / 3.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Wird der Wertebereich der Gleitkommazahlen verlassen, so ergibt sich entweder der Rückgabewert <code>inf</code> \n",
    "(Infinity) oder eine Fehlermeldung."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "1e308 * 1000\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "2 ** 1e308 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### 1.4.4 Zeichenketten\n",
    "\n",
    "Zeichenketten oder *Strings* (abgekürzt <code>str</code>) sind ein weiterer Datentyp in Python. String-Literale \n",
    "können mit einfachen oder doppelten Hochkommas begrenzt werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "name = 'Paulus'\n",
    "type(name)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python behandelt Strings als Sequenz von einzelnen Unicode-Zeichen, auf die mit einem Index zugegriffen werden kann."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "name[3]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Auch String-Werte besitzen Infix-Operationen.\n",
    "\n",
    "| *Operation*    | *Schreibweise*           | *Ergebnis*     |\n",
    "|----------------|--------------------------|----------------|\n",
    "| Konkatenation  | <code>'A' + 'B'</code>   | <code>'AB'</code> |\n",
    "| Wiederholung   | <code>3 * 'AB'</code>    | <code>'ABABAB'</code> |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "'A' + 'B'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "'AB' * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Für die Ermittlung der *Länge* eines Strings kann die Build-In Funktion <code>len</code> verwendet werden. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "len('ABC')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Sonderzeichen, die nicht über die Tastatur eingebbar sind, können trotzdem mit Hilfe von *Escape-Sequenzen* in \n",
    "einen String eingefügt werden. Sie haben ihren Ursprung aus der Zeit der zeilenorientierten Drucker mit einem\n",
    "Druckkopf, den es zu steuern gilt.\n",
    "\n",
    "| *Escape-Sequenz*   | *Bedeutung*           | \n",
    "|--------------------|-----------------------|\n",
    "| <code>\\n</code>    | Neue Zeile            |\n",
    "| <code>\\r</code>    | Wagenrücklauf         | \n",
    "| <code>\\t</code>    | Tabulatorsprung       | \n",
    "| <code>\\\\\\\\</code>  | Das Zeichen \\         | \n",
    "| <code>\\\\\"</code>   | Das Zeichen \"         | \n",
    "| <code>\\\\'</code>   | Das Zeichen '         | \n",
    "| <code>\\\\'</code>   | Das Zeichen '         | \n",
    "| <code>\\uXXXX'</code>   | Das Unicode-Zeichen XXXX     | "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"Zeile 1 \\n Zeile 2 \\r Text1 \\t Text2\")\n",
    "print('Los geht\\'s!')\n",
    "print('\\u263A')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Unicode-Zeichen können aus mehreren Bytes bestehen; die aus Programmiersprachen wie *C* bekannte Regel\n",
    "\n",
    "1 Zeichen im String = 1 Byte\n",
    "\n",
    "gilt damit **NICHT**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### 1.4.5 Bytes\n",
    "\n",
    "Für die Verwaltung einer Folge von Bytes existiert in Python ein eigner Datentyp <code>bytes</code>. Ein \n",
    "Bytes-Literal ähnelt einem String-Literal, besitzt aber ein Präfix <code>b</code>\n",
    "als Kennzeichen. Es sind dann aber nur\n",
    "ASCII-Zeichen als Inhalt erlaubt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "raw_text = b'Hello World'\n",
    "type(raw_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Infix-Operationen des Bytes-Datentyps entsprechen denen des String-Datentyps. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### 1.4.6 Boolean\n",
    "\n",
    "In Python gibt es einen weiteren Datentyp *Boolean* (<code>bool</code>), der nur die Werte <code>True</code> \n",
    "und <code>False</code> annehmen kann."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "ja = True\n",
    "nein = False\n",
    "type(ja)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Die Infix-Operationen des Datentyps *Boolean* entsprechen den bekannten Operationen der booleanschen Algebra.\n",
    "\n",
    "| *Operation*            | *Schreibweise*           | *Ergebnis*     |\n",
    "|------------------------|--------------------------|----------------|\n",
    "| Konjunktion            | <code>True and False</code>  | <code>False</code> |\n",
    "| Disjunktion            | <code>True or False</code>   | <code>True</code>  |\n",
    "| Negation (Präfix)      | <code>not True </code>       | <code>False</code> |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "(1==1) and (3<2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Boolean-Werte sind häufig das Ergebnis eines Vergleichs zweier Werte eines anderen Datentyps.\n",
    "\n",
    "| *Operation*            | *Schreibweise*           | *Ergebnis*     |\n",
    "|------------------------|--------------------------|----------------|\n",
    "| Gleichheit             | <code>1 == 2</code>      | <code>False</code> |\n",
    "| Ungleichheit           | <code>1 != 2</code>      | <code>True</code>  |\n",
    "| Ordnung                | <code>1 > 2</code>       | <code>False</code> |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "1 == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "1 != 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "1 > 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### 1.4.7 None\n",
    "\n",
    "Python stellt die Konstante <code>None</code> bereit, mit der der Wert *Nichts* ausgedrückt werden kann. \n",
    "Die Konstante <code>None</code> besitzt einen eigenen Datentyp <code>NoneType</code>.\n",
    "\n",
    "Die Überprüfung auf <code>None</code> erfolgt mit dem Vergleichsoperator <code>is</code>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "nichts = None\n",
    "type(nichts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "nichts is None\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### 1.4.8 Operatorpriorität\n",
    "\n",
    "Enthält ein Python-Ausdruck mehrere Infix-Operationen, so muss geregelt sein, in welcher \n",
    "Reihenfolge die Operationen ausgeführt werden (vergleichbar zur *Punkt-vor-Strich*-Regel).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Die Priorität der Operatoren ist wie folgt festgelegt:\n",
    "\n",
    "| *Priorität*    | *Operator*               | *Erläuterung*     |\n",
    "|----------------|--------------------------|-------------------|\n",
    "| _Höchste_      | <code>( ) </code>        | Durch Klammerung kann immer eine abweichende Priorität festgelegt werden |\n",
    "| &nbsp;         | <code> ** </code>        | Exponent  |\n",
    "| &nbsp;         | <code> *, /, //, % </code>  | Multiplikation und Division |\n",
    "| &nbsp;         | <code> +, - </code>         | Addition und Subtraktion    |\n",
    "| &nbsp;         | <code> <<, >> </code>       | Shift-Operatoren            |\n",
    "| &nbsp;         | <code> & </code>            | bitweises AND               |\n",
    "| &nbsp;         | <code> ^ </code>            | bitweises XOR               |\n",
    "| &nbsp;         | <code> \\| </code>           | bitweises OR                |\n",
    "| &nbsp;         | <code> <, >, ==, !=, is </code>  | Vergleiche             |\n",
    "| &nbsp;         | <code> not </code>            | logisches NOT               |\n",
    "| &nbsp;         | <code> and </code>            | logisches AND               |\n",
    "| _Niedrigste_   | <code> or </code>             | logisches OR                |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "\"b\" > \"c\" or not 3 < 2  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Im Zweifelsfall aber am Besten lieber klammern, alleine schon für eine bessere Lesbarkeit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### 1.4.9 Typumwandlung\n",
    "\n",
    "Operationen erwarten, dass die Operanden einen bestimmten Datentyp besitzen. So ist z.B. der Modulo-Operator \n",
    "<code>%</code> nur sinnvoll, wenn die Operanden Zahlen sind. Manchmal besitzen Operatoren auch eine unterschiedliche\n",
    "Semantik in Abhängigkeit vom Datentyp der Operanden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "3 + 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "\"3\" + \"4\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Daher ist es gelegentlich notwendig, den Datentyp eines Wertes umzuwandeln. Python stellt hierfür eine ganze Reihe \n",
    "von Built-In Functions bereit. Eine *implizite Typumwandlung*, bei der der Typ eines Wertes \"en passant\" passend gemacht \n",
    "wird, findet in Python - anders als in anderen Sprachen - kaum statt (mit Ausnahme der Umwandlung von ganzen Zahlen in \n",
    "Gleitkommawerte).\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "int(\"5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "int(4.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "int(\"Hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "int(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "float(\"5.1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "float(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "float(10**310)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "str(10**310)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "str(3.1415)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "str(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "ord('A')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "chr(66)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Eine Sonderform der Typumwandlung ist die Formatierung beliebiger Werte als lesbarer String.\n",
    "Eine einfache Möglichkeit ist die Angabe eines Formatstrings mit dem Präfix <code>f</code>\n",
    "und Platzhaltern für die einzusetzenden Werte."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "article = \"Eis\"\n",
    "price = 2.50\n",
    "\n",
    "f\"{article} kostet {price} Euro\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bei den Platzhaltern kann zusätzlich eine Information zur Mindestbreite etc. hinterlegt werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "f\"{article:10} kostet {price:2.2f} Euro\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Es ist nicht notwendig, die Werte in benannten Variablen vorzuhalten, wenn\n",
    "anstelle des Präfix <code>f</code> die Funktion <code>format</code> verwendet wird,\n",
    "die bei jedem String mit Hilfe der Dot-Notation aufgerufen werden kann."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "\"{:10} kostet {:2.2f} Euro\".format(\"Eis\", 2.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In diesem Fall kann die Reihenfolge der Parameter und ihr Auftauchen im Ergebnis auch abweichen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "\"{1:10} kostet {0:2.2f} Euro\".format(2.5, \"Eis\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Hinweis: man findet gelegentlich noch die inzwischen veraltete Form der String-Formatierung, die aber nicht \n",
    "mehr verwendet werden sollte."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "\"%-10s  kostet %2.2f Euro\" % (\"Eis\", 2.5)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}