2_Python_Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Python**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "In diesem Notebook findest du:\n",
    "\n",
    "- Installationshinweise zu Python und Anaconda (enthält die Installation von Jupyter-Notebooks)\n",
    "- Umgang mit den Basisdatentypen von Python\n",
    "    \n",
    "Falls du neugierig bist und schon einmal sehen möchtest, welche weiteren Möglichkeiten es in Python gibt, kannst du die folgenden Links nutzen:\n",
    "   \n",
    "- [Fallunterscheidungen](3_Fallunterscheidungen.ipynb)    \n",
    "- [Wiederholungen](4_Wiederholungen.ipynb)    \n",
    "- [Funktionen](5_Funktionen.ipynb)\n",
    "- [rekursive Funktionen](6_Rekursion.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## Installation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Die ersten Schritte kann man in den beiden vorangehenden Notebooks nachlesen:\n",
    "\n",
    "- [Das Start-Notebook](0_Start.ipynb)\n",
    "- [Erste Schritte in einem Notebook](1_Erste_Schritte.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: lightgreen; padding: 5px 20px 20px\">\n",
    "\n",
    "* Offizielle Python-Seite: [https://www.python.org](https://www.python.org)\n",
    "* Anaconda-Umgebung: [https://www.anaconda.com](https://www.anaconda.com)\n",
    "  * enthält auch die Python-Installation sowie die Jupyter- und Spyder-Umgebungen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Um Jupyter-Notebooks auch auf dem eigenen Computer benutzen zu können, solltest du die oben angegebene ***Anaconda-Installation*** benutzen.\n",
    "    \n",
    "Nach der Installation kannst du eigene Notebooks erstellen oder auch externe Notebooks auf deinen Computer laden und öffnen.\n",
    "    \n",
    "Dazu musst du in dem Anaconda-Navigator den Jupyter-Notebook-Button benutzen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gliederung; Hinweise zum Benutzen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [erste Schritte](#Erste-Schritte)\n",
    "- [Verschiedene Sorten von Zahlen](#Zahlentypen)\n",
    "- [Das Python-System sagt uns etwas](#Ausgabe)\n",
    "- [Aufbewahren von Werten](#Variablen)\n",
    "- [Mehrzeilige Eingaben](#Mehrzeilige-Eingaben)\n",
    "- [Texte](#Strings)\n",
    "- [Wahrheitswerte](#Wahrheitswerte)\n",
    "- [Einlesen von der Tastatur](#Benutzereingabe)\n",
    "- [Typen konvertieren](#Typen-konvertieren)\n",
    "- [Runden von Zahlen](#Runden)\n",
    "- [Zufall](#Zufall)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Du findest hier neben Erläuterungstexten viele Eingabezellen, die du an `In [ ]` links am Rand erkennen kannst.\n",
    "\n",
    "**Bewege den Cursor in eine solche Eingabezelle und**\n",
    "\n",
    "- clicke auf den `▶︎ Run`-Button (oben) \n",
    "    \n",
    "**oder**\n",
    "    \n",
    "- benutze die `↩︎ Eingabe`-Taste mit gedrückter `⇧ Shift`-Taste\n",
    "    \n",
    "Also gehe alle Eingabezellen durch (in der Regel in der angegebenen Reihenfolge), und aktiviere sie wie hier beschrieben.\n",
    "    \n",
    "Du kannst den Inhalt der Zellen auch abändern und sogar neue Zellen an beliebigen Stellen einfügen (mit dem `+`-Zeichen aus der Menuleiste oben)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_input": false
   },
   "source": [
    "## Erste Schritte"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_input": false
   },
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Natürlich kann man das Python-System dazu nutzen, um Berechnungen auszuführen.\n",
    "    \n",
    "Die dir sicher bekannten sogenannten 4 Grundrechenarten *Addieren* `+`, \n",
    "    *Subtrahieren* `-` und *Multiplizieren* `*` funktionieren so, wie wir es erwarten!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ***Aufgabe***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: DarkSeaGreen; padding: 5px 20px 20px\">\n",
    "\n",
    "**Was liefern die folgenden Eingaben?**\n",
    "\n",
    "**Denke erst nach und teste dann.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "12+8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "12-8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "12*8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Und dann gibt es ja auch noch die Division. Doch da stellen wir eine Besonderheit fest, an die wir uns gewöhnen müssen. denn es gibt gleich zwei *Rechenzeichen* dafür: `/` und `//`.\n",
    "    \n",
    "Teste das doch einfach einmal!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "12//8 ## Die ganzzahlige Division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "12/8 ## Division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Die Division mit dem Rechenzeichen `/` liefert immer eine Dezimalzahl. Auch wenn die Division (im mathematischen Sinn) ohne Rest *aufgeht*, ist das Ergebnis keine ganze Zahl! \n",
    "    \n",
    "Also ist das Ergebnis von z.B. `16 / 8` die Dezimalzahl `2.0` und nicht die ganze Zahl `2`\n",
    "    \n",
    "Die ***Ganzzahlige Division*** `//`, die du hier entdeckt hast, liefert eine ganze Zahl als Ergebnis. Dabei wird der Divisionsrest ignoriert.\n",
    "\n",
    "Den Rest bei dieser ganzzahligen Division ist jedoch oft von Bedeutung und kann ebenfalls ermittelt werden. Dazu gibt es den sogenannten ***Modulo-Operator*** mit dem Rechenzeichen `%`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "12%8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Schließlich kann man natürlich auch Potenzieren. Dazu gibt es den Potenzoperator `**`. \n",
    "    \n",
    "Wenn du also z.B. $3^5$ (also $3 \\cdot 3 \\cdot 3 \\cdot 3 \\cdot 3$) berechnen möchtest, musst du in Python \n",
    "`3**5`\n",
    "schreiben.    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ***Aufgabe***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: DarkSeaGreen; padding: 5px 20px 20px\">\n",
    "\n",
    "**Was liefern die folgenden Eingaben?**\n",
    "\n",
    "**Denke erst nach und teste dann.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2*3**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(2*3)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2**3**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(2**3)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2**(3**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ***Aufgabe***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: DarkSeaGreen; padding: 5px 20px 20px\">\n",
    "\n",
    "Probiere andere arithmetische Ausdrücke aus.\n",
    "\n",
    "> ***Benutze die folgende Zeilen zum Testen***\n",
    "\n",
    "> ***Du kannst auch weitere Zeilen einfügen*** (Menu-Leiste oben; Insert)\n",
    "\n",
    " 1. Verwende die Operatoren zur\n",
    "* Addition und Subtraktion\n",
    "* Multiplikation, (ganzzahligen) Division, Restbildung\n",
    "* Potenzieren\n",
    " 2. Teste insbesondere die sogenannten Vorrangregeln:\n",
    "* *Potenzieren vor Punktrechnung vor Strichrechnung*\n",
    "* *Klammern haben Vorrang*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ***Aufgabe***:  Zaubertrick"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ein Zaubertrick mit Zahlen**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. ***Denk dir eine Zahl aus!***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = # hier eine Zahl hinschreiben"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. ***Mit 5 multiplizieren***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a1 = ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. ***Verdoppeln!***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a2 = ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. ***Teile a2 jetzt durch die Zahl, die du Dir am Anfang ausgedacht hast.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a3 = ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. ***Subtrahiere davon 7***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a4 = ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. ***Ich weiss, was herauskommt!***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a4 ### ???"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: DarkSeaGreen; padding: 5px 20px 20px\">\n",
    "\n",
    "Und jetzt zur eigentlichen Aufgabe:\n",
    " \n",
    "**Wieso ist das Ergebnis vorhersehbar?**\n",
    "- Damit kannst du auf einer Party einen Zaubertrick vorführen!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ***Aufgabe: Magisches Quadrat***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <b> Magisches Quadrat</b>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "\n",
    "Ein <font color=blue>**Magisches Quadrat**</font> ist eine quadratische Anordnung von Zahlen, so daß die Summe der Zahlen in jeder Zeile, in jeder Spalte und in jeder der beiden Diagonalen jeweils denselben Wert besitzt.\n",
    "        \n",
    "Ein bekanntes Beispiel eines magischen Quadrats mit 3 Zeilen/Spalten:\n",
    "     \n",
    "|  |  |  |\n",
    "|:-:|:-:|:-:|\n",
    "| 8 | 1 | 6 |\n",
    "| 3 | 5 | 7 |\n",
    "| 4 | 9 | 2 |\n",
    "        \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: DarkSeaGreen; padding: 5px 20px 20px\">\n",
    "\n",
    "Magisches Quadrat mit 4 Zeilen und 4 Spalten\n",
    "> **Wieso wird hier ein magisches Quadrat erzeugt?**\n",
    "1. *Begründe den Sachverhalt!*\n",
    "2. *Ergänze das Python-Programm so, dass alle 10 Summen berechnet werden.*    \n",
    "2. *Was muss man für a und b eingeben, damit in dem Quadrat alle Zahlen 1, 2, ..., 16 auftauchen?*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "at = input(\"Gib einen Wert für a ein:\")\n",
    "bt = input(\"Gib einen Wert für b ein:\")\n",
    "a = int(at)\n",
    "b=int(bt)\n",
    "print (\"Die Summe aller Reihen, Spalten und Quadrate ist:\",a*21+b)\n",
    "# Magisches Quadrat ausgeben:\n",
    "print (\"------------------------------------------------------------\")\n",
    "print (a+b,a,12*a,7*a)\n",
    "print (11*a,8*a,b,2*a)\n",
    "print (5*a,10*a,3*a,3*a+b)\n",
    "print (4*a,2*a+b,6*a,9*a)\n",
    "print (\"------------------------------------------------------------\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zahlentypen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <b> int </b>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "\n",
    "In Python werden die aus der Mathematik bekannten ganzen Zahlen mit <font color=blue>**int**</font> bezeichnet. \n",
    "        \n",
    "Eine Zahl vom Typ ***int*** besteht aus einer Folge von Ziffern, ggf. versehen mit einem Vorzeichen `+` bzw. `-`.\n",
    "        \n",
    "Der Wertebereich ist unbegrenzt, d.h. man kann in Python beliebig große positive oder auch beliebig kleine negative ganze Zahlen verwalten."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <b> float </b>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "\n",
    "In Python werden die aus der Mathematik bekannten Dezimalzahlen mit <font color=blue>**float**</font> bezeichnet.\n",
    "        \n",
    "Eine Zahl vom Typ ***float*** besteht aus einer Folge von Ziffern (den Vorkommastellen), gefolgt von dem Dezimal**punkt** `.` und den Nachkommastellen. Vor der Zahl kann ggf. ein Vorzeichen `+` bzw. `-` stehen.\n",
    "        \n",
    "Eine andere Möglichkeit ist die wissenschaftliche Schreibweise.\n",
    "        \n",
    "Die kleinste positive Dezimalzahl in wissenschaftlicher Schreibweise ist `2.2250738585072014e-308`, die größte ist `1.7976931348623157e+308`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "In den bisherigen Abschnitten waren die benutzen Zahlen immer ganze Zahlen. Sie bestehen (nur) aus Ziffern, ggf. findet man ein Minus-Vorzeichen vor den Ziffern. Das kennst du bestimmt schon lange. In der Mathematik heißen diese Zahlen **ganze Zahlen**, die Menge aller ganzen Zahlen wird dort mit ℤ bezeichnet.\n",
    "    \n",
    "Daneben gibt es jedoch auch Zahlen wie 3,14 oder -123,456 oder auch 42,0\n",
    "    \n",
    "Das sind die Dezimalzahlen, in der Informatik nennt man sie **floatingPointNumbers**, in Python haben sie die Typbezeichnung **float** und werden (wie in allen angelsächsischen Ländern üblich) statt mit einem Dezimalkomma mit einem Dezimalpunkt geschrieben.\n",
    "    \n",
    "Also sind 3.14 und -123.45 und auch 42.0 korrekte floats in Python.\n",
    "    \n",
    "***Beachte dabei, dass 42 und 42.0 in Python zwei verschiedene Zahlen sind. Sie haben unterschiedliche Typen.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(42.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Man kann den Typ einer Zahl ändern. Dazu gibt es die Befehle `float()` und `int()`.\n",
    "    \n",
    "Das ist in einer Richtung einfach zu verstehen:    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Die Umwandlung von float in int schneidet Nachkommastellen ab. Beachte dabei, dass **nicht** gerundet wird. Dazu später noch weitere Bemerkungen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int(42.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int (42.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ausgabe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Steht ein (korrekter) arithmetischer Term in einer Zelle, passiert zunächst einmal garnichts. \n",
    "Verlässt man die Eingabe durch `SHIFT` + `RETURN`, wird der Term \n",
    "ausgewertet und das Ergebnis in dem Feld unterhalb der Zelle angezeigt. Das ist in den obigen Zellen bereits passiert. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7*8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Ausgaben können auch mit der sog. print()-Anweisung erfolgen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (7*8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Das werden wir noch oft benutzen, da man so die Ausgaben zusätzlich *schöner* gestalten kann."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variablen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "*Programmieren* besteht aus der Aneinanderreihung von *Befehlen*, die (in diesem Fall) der **Python-Interpreter** ausführt. \n",
    "\n",
    "Ein einfacher Befehl ist die Zuweisung eines Wertes zu einer ***Variablen***\n",
    "\n",
    "Eine Variable ist eine Art Speicherzelle, in der ein Wert aufbewahrt werden kann.\n",
    "\n",
    "Eine Variable wird erzeugt, indem man sich einen Namen für sie ausdenkt, um später mit Hilfe dieses Namens (lesend und/oder schreibend) auf den Inhalt zugegriffen werden kann. Dann kann man den Wert mit dem *Operator* `=` in der zugehörigen Speicherzelle ablegen.\n",
    "\n",
    "So kann man mit `meineZahl = 42` eine Variable anlegen, in der die Zahl 42 gespeichert ist.\n",
    "\n",
    "Hat man eine Variable angelegt und mit einem Wert belegt, kann man den Wert jederzeit sehen, indem man den Namen der Variablen hinschreibt oder mit `print` ausgeben lässt.\n",
    "\n",
    "Den Wert, der in einer Variablen gespeichert ist, kann man auch (für andere Zwecke) benutzen. Die Zeile `deineZahl = meineZahl + 100` erzeugt eine Variable, in der jetzt der Wert 142 gespeichert ist.\n",
    "\n",
    "Den Wert, der in einer Variablen gespeichert ist, kann man auch jederzeit verändern. Nach der Anweisung `meineZahl = 0` befindet sich in der Variablen jetzt der Wert 0; der vorige Wert 42 ist damit verschwunden!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ***Aufgabe***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: DarkSeaGreen; padding: 5px 20px 20px\">\n",
    "\n",
    "**Was liefern die folgenden Eingaben?**\n",
    "\n",
    "**Denke erst nach und teste dann.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "b = 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a*b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a*b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = -5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = 3.1415"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "radius = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "flaeche = radius**2 * p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (flaeche)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Variablen, also eigentlich die zugehörigen Werte, haben immer einen **Typ** wie\n",
    "\n",
    "- `int` für ganze Zahlen, z.B. `1`, `42`, `-10`,\n",
    "- `float` für Fließkommazahlen, z.B. `0.5`, `3.14`, `1e10`,\n",
    "- `str` für Zeichenketten (*Strings*), z.B. `\"Hello World!\"`, (*dazu später mehr*)\n",
    "- `bool` für Wahrheitswerte (*Booleans*, benannt nach einem englischen Mathematiker mit Namen George Boole (1815–1864)), also `True` und `False` (*dazu ebenfalls später mehr*)\n",
    "\n",
    "Der Typ der Variablen wird automatisch durch die äußere Form der rechten Seite gesetzt.\n",
    "\n",
    "Da Variablen in Python nicht typisiert sind, also keinen für alle Zeiten festgelegten Typ haben, können der gleichen Variable nacheinander Werte verschiedener Typen zugewiesen werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ***Beispiel:*** BodyMassIndex (BMI)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Der BMI bestimmt man, indem das Gewicht `gew` (in kg) sowie die Körpergröße `gro` (in m) in die Formel\n",
    "\n",
    "> $bmi = \\frac{gew}{gro^2}$\n",
    "\n",
    "eingesetzt wird."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*(Diese Formel ist sehr einfach aufgebaut; tatsächlich wird noch das Alter \n",
    "der Person und das Geschlecht berücksichtigt. Das könnte vielleicht eine Aufgabe für später sein!)*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gewicht = 72"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "groesse = 1.82"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bmi=gewicht / (groesse**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bmi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Ausgabe kann dann schöner erfolgen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (\"Sie haben einen BMI von \" + str(bmi) + \"!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "oder auch:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (\"Sie haben einen BMI von\", bmi, \"!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "oder noch anders mit Hilfe einer Formatanweisung:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (f\"Sie haben einen BMI von {bmi}!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... und viele andere Möglichkeiten, die den Rahmen hier sprengen könnten."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ***Aufgabe: Flächeninhalt***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: DarkSeaGreen; padding: 5px 20px 20px\">\n",
    "\n",
    "Jemand möchte die Fläche (den Umfang) eines Kreises (eines Rechtecks) bestimmen.\n",
    "    \n",
    "Schreibe ein Python-Programm dafür."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mehrzeilige Eingaben\n",
    "> ***Eingabe einer Zeile mit RETURN abschliessen***\n",
    "\n",
    "> ***Letzte Zeile dann ggf. mit SHIFT RETURN beenden, um den gesamten Code auszuführen***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 7\n",
    "y = 9\n",
    "z = y % x\n",
    "print (z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahlText = input (\"Gib eine Zahl ein:\")\n",
    "zahl = int (zahlText)\n",
    "print (zahl % 2 == 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <b> str </b>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "\n",
    "In Python gibt es Zeichenketten, mit <font color=blue>**str**</font> bezeichnet. \n",
    "        \n",
    "Eine Zeichenkette ist eine Folge von beliebigen Zeichen, eingeschlossen in zwei `\"`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Neben Zahlen (ganze Zahlen und Dezimalzahlen) kann man in Python auch sogenannte ***Strings*** benutzen.\n",
    "    \n",
    "Einen String musst du dir als eine Folge von Zeichen vorstellen. Ein Zeichen ist dabei \n",
    "- ein Buchstabe (Großbuchstabe oder Kleinbuchstabe) wie z.B. `d` `X` `p`\n",
    "- eine Ziffer wie z.B. `3` `7`\n",
    "- ein Sonderzeichen wie Satzzeichen `.` `!` oder andere Sonderzeichen wie `#` `$`\n",
    "- weitere Spezialzeichen, die später noch zu thematisieren sind.\n",
    "\n",
    "Ein String wird immer umschlosen von  zwei `\"` oder zwei `'`. \n",
    "\n",
    "Beispiele:\n",
    "- `\"Hallo Python!\"`\n",
    "  - Dieser String besteht aus 13 Zeichen. Beachte dabei, dass auch das Leerzeichen nach dem `o` ein zulässiges Zeichen ist!\n",
    "- `'12345'`\n",
    "  - Das sieht zwar aus wie eine ganze Zahl, doch da die 5 Zeichen umrahmt sind von `#`, ist es ein String. Also kann man mit diesem String nicht so rechnen, als ob es eine Zahl wäre!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hallo Python\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Strings können in Variablen aufbewahrt werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "meinName = \"Hans Wurst\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Den Inhalt einer solchen Variablen kann man ausgeben oder an anderer Stelle benutzen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(meinName)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Länge und Indizierung"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Jeder String hat eine **Länge**, die Anzahl der in dem String enthaltenen Zeichen. Man kann die Länge mit der Funktion `len()` bestimmen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(meinName)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Jedes Zeichen in einem String befindet sich an einer festen Stelle in der Zeichenkette. Die Stelle, an der sich ein Zeichen befindet, wird als Index bezeichnet.\n",
    "    \n",
    "Beachte jedoch: ***Die Indizierung beginnt mit dem Index 0***\n",
    "- Also befindet sich das erste Zeichen an der Stelle 0.\n",
    "- Besteht der String z.B. aus 4 Zeichen, dann befindet sich das letzte Zeichen an der Stelle 3.\n",
    "    \n",
    "Am Beispiel des Strings `Hallo`\n",
    "    \n",
    "Zeichen | Index\n",
    ":------:|:------:\n",
    "  H | 0\n",
    "  a | 1\n",
    "  l | 2\n",
    "  l | 3\n",
    "  o | 4\n",
    "    \n",
    "Man kann auf ein bestimmtes Zeichen des Strings mit Hilfe der Indizierung zugreifen. Das geschieht, indem man an den String bzw. die Stringvariable den Index, eingeschlossen in `[` und `]` anhängt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hallo Python!\" [6] # also das 7-Zeichen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "meinName[2] ## Also das 3-te Zeichen der Zeichenkette!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Manchmal ist es sinnvoll, die Zeichenkette von rechts nach links zu indizieren. Das geschieht mit negativen Indizes. Man kann so ebenfalls auf alle Zeichen zugreifen:\n",
    "\n",
    "Zeichen | Index\n",
    ":------:|:------:\n",
    "  H | -5\n",
    "  a | -4\n",
    "  l | -3\n",
    "  l | -2\n",
    "  o | -1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hallo\" [-5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "meinName [-1] # das letzte Zeichen im String"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Teil eines Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Die Indizierung erlaubt es, auch auf mehr als ein Zeichen des Strings zuzugreifen. Dazu gibt man zwei Werte, getrennt durch `:` an. Dann liefert der Aufruf `meinText[a:b]` denjenigen Teiltext, der bei dem Zeichen am Index `a`beginnt und **vor** dem Zeichen mit dem Index `b ` endet. Der Teiltext besteht also immer `b-a` Zeichen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "meinName[5:9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Lässt man vor oder nach dem trennenden Doppelpunkt `:` den Zahlenwert weg, dann wird der Teilstring ab dem ersten bzw. bis zum letzten Zeichen erzeugt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "meinName [:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "meinName [3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ändern von Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Mit Hilfe der Indizierung kann man einzelne Zeichen oder auch Teile des **nicht** Strings ändern!\n",
    "    \n",
    "Probiere dazu einmal die folgende Eingabe aus, mit der man versuchen möchte, den Buchstaben mit Index 9 (das war ein `t`) abzuändern:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## meinName[9] = \"m\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Jedoch kann man aus einem String mit der Funktion `replace`neue Strings herstellen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "neuerName = meinName.replace (\"st\",\"m\")\n",
    "print (neuerName)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Achtung: Der bisherige Name `meinName` ist dadurch nicht verändert worden, sondern eine neue String-Variable wurde erzeugt***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rechnen mit Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Natürlich kann man mit Strings nicht rechnen wie mit Zahlen; dennoch kann man Strings addieren und vervielfachen:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "1. Addieren mittels `+`\n",
    "\n",
    "Die **Textaddition** verkettet die beiden Bestandteile zu einem neuen Text:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vorname = \"Klein\"\n",
    "nachname = \"Erna\"\n",
    "ihrName = vorname + \" \" + nachname\n",
    "print(ihrName)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "2. Vervielfachen mittels `*`\n",
    "\n",
    "Hier geschieht das Erwartete:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "labern = \"bla\"\n",
    "vielLabern = 10*labern\n",
    "print (vielLabern)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wahrheitswerte"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Wie in allen Programmiersprachen gibt es auch in Python sogenannte ***Wahrheitswerte***. Sie können genau zwei Werte annehmen:\n",
    "- True\n",
    "- False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Einen Wahrheitswert kann man ebenfalls in einer Variablen speichern und auch ausgeben:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wert = True\n",
    "print (wert)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Den Typ eines Wahrheitswertes bezeichnet man in Python mit `bool`, benannt nach dem englischen Mathematiker **George Boole (1815-1864)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type (True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Zwei Zahlenwerte oder zwei Strings können gleich oder verschieden sein. \n",
    "    \n",
    "Um das zu testen, bietet Python den sogenannten ***Vergleichsoperator*** `==` an. Bei dessen Anwendung wird ein Wahrheitswert erzeugt, den man ausgeben oder in einer Variablen speichern kann:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 == 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wert = (3==4)\n",
    "print (wert)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "An zwei kleinen Beispielen wird der Sinn verdeutlicht:\n",
    "> - Es soll untersucht werden, ob der Name einer Person mit einem \"P\" beginnt.\n",
    "> - Will man herausfinden, ob eine Zahl z eine Primzahl ist, muss man testen ob z Teiler hat. Also teilt man z durch vermeintliche Teiler t und beobachtet die dabei entstehenden Teilerreste. Diese Reste kann man mit dem oben beschriebenen Modulo-Operator `%` berechnen lassen. Hat der Rest den Wert 0, ist z durch t teilbar.\n",
    "    \n",
    "\n",
    "Schau dir die beiden folgenden Python-Programme dazu an. Ändere dazu auch die Werte der Variablen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Hans Meier\"\n",
    "## name = \"Pauline Krause\"\n",
    "beginntMitP = (name [0] == \"P\")\n",
    "print (beginntMitP)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahl = 43\n",
    "## zahl = 42\n",
    "testTeiler = 3\n",
    "istTeilbar = (zahl % testTeiler == 0)\n",
    "print (istTeilbar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rechnen mit Wahrheitswerten"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Natürlich (siehe auch den entsprechenden Abschnitt über Strings) kann man auch mit Wahrheitswerten nicht rechnen wie mit Zahlen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Betrachten wir dazu einmal die Regel, nach der ein Jahr ein sogenanntes ***Schaltjahr*** ist:\n",
    "    \n",
    "> Wenn die Jahreszahl durch 400 teilbar ist, oder wenn sie durch 4 teilbar und nicht durch 100 teilbar ist, dann ist das Jahr ein Schaltjahr.\n",
    "    \n",
    "Also\n",
    "- 2021 ist kein Schaltjahr, da 2021 nicht durch 4 teilbar ist.\n",
    "- 2020 war ein Schaltjahr, da 2020 durch 4 und nicht durch 100 teilbar ist.\n",
    "- 2100 wird kein Schaltjahr sein, da 2100 zwar durch 4, aber auch durch 100 teilbar ist.\n",
    "- 2000 war ein Schaltjahr, da 2000 durch 400 teilbar ist.\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Betrachten wir dazu einmal die Regel, nach der ein Jahr ein sogenanntes ***Schaltjahr*** ist. Dazu führen wir für eine Jahreszahl j die folgenden Abkürzungen ein:\n",
    "\n",
    "- A: j ist durch 4 teilbar\n",
    "- B: j ist durch 100 teilbar\n",
    "- C: j ist durch 400 teilbar\n",
    "    \n",
    "Dabei sind A, B und C drei Wahrheitswerte, denn sie können - je nach Wert für j - wahr oder falsch sein.\n",
    "    \n",
    "j ist dann also ein Schaltjahr, wenn `C oder (A und nicht B)` gilt.\n",
    "    \n",
    "In dieser Formel werden die drei Wahrheitswerte miteinander verknüpft. Dazu gibt es drei Sorten von Verknüpfungen, man kann auch Rechenarten dazu sagen: \n",
    "    \n",
    "1. `oder`\n",
    "2. `und`\n",
    "3. `nicht`\n",
    "    \n",
    "Es gelten dafür folgende Regeln:\n",
    "1. A oder B ist genau dann falsch, wenn sowohl A als auch B falsch ist.\n",
    "1. A und B ist genau dann wahr, wenn sowohl A als auch B wahr ist.\n",
    "1. nicht A ist genau dann wahr, wenn A falsch ist.\n",
    "    \n",
    "Damit ergibt sich das folgende Python-Programm: (teste andere Werte für j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "j = 2000\n",
    "\n",
    "A = (j%4 == 0)\n",
    "B = (j%100 == 0)\n",
    "C = (j%400 == 0)\n",
    "\n",
    "C or (A and not B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ***Aufgaben***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: DarkSeaGreen; padding: 5px 20px 20px\">\n",
    "\n",
    "1. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Besonderheiten im Umgang mit Variablen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "***Achtung*** \n",
    "> ***Wenn Variablen einander zugewiesen werden, kann es zu vielleicht für dich unerwarteten Effekten kommen:***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gültigkeit (*scoping*)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Wenn in einer Eingabe-Zelle der Wert einer Variablen durch eine Zuweisung belegt wird, existiert diese Variable (mit dieser Wertbelegung) in dem gesamten Jupyter-Notebook. Insbesondere auch in allen Zellen, die oberhalb dieser Zelle liegen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Aktiviert man also z.B. die folgende Zelle, dann wird man eine Fehlermeldung erhalten (zunächst das Kommentarzeichen entfernen!), da die Variable`asdfg` noch nicht belegt wurde:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print (asdfg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Belegt man jetzt die Variable mit einem Wert, wird (natürlich) kein Fehler auftraten:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "asdfg = 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (asdfg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Aber auch in der Eingabezelle, die zuvor einen Fehler produzierte, ist die Variable jetzt sichtbar und hat genau den zugewiesenen Wert!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alias"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Betrachte die beiden folgenden Variablenzuweisungen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=5\n",
    "y=x "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "> **Ist jetzt y dasselbe wie x, oder hat y nur denselben Wert wie x?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (x)\n",
    "print (y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "> **Natürlich haben sie identische Werte!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "    \n",
    "> **Und was passiert mit y, wenn man x verändert?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=7\n",
    "print (x)\n",
    "print (y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "> **Offenbar wurde der Wert von `y` nicht verändert, obwohl doch `y` daselbe wie `x` sein sollte.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Aber was passiert denn hier so genau?\n",
    "    \n",
    "Betrachten wir erneut die vorigen Zeilen:\n",
    "    \n",
    "    x = 5\n",
    "    y = x\n",
    "    \n",
    "- Jetzt gibt es eine Speicherzelle, die mit dem Namen `x` zu erreichen ist und in der der Wert `5` gespeichert ist. \n",
    "- Daneben gibt es den Namen `y`. Unter diesem Namen wird genau dieselbe Speicherzelle erreicht.\n",
    "    \n",
    "Hier hat man es mit einem sogenannten ***Alias-Phänomen*** zu tun:\n",
    "\n",
    "> Eine Speicherzelle kann untzer zwei verschiedenen Namen (*Alias-Namen*) angesprochen werden.\n",
    "    \n",
    "In Python hat jede Speicherzelle eine Nummer (Adresse), die man auch mit der Python-Funktion `id()` ermitteln kann."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = x\n",
    "print (id (x))\n",
    "print (id (y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Wie man sieht, haben beide Speicherzellen dieselbe Adresse.\n",
    "    \n",
    "Wenn man jetzt auf `y` zugreift, wird der Inhalt der Speicherzelle geliefert, die auch unter dem Namen `x` zu finden ist."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Jetzt wollen wir eine andere Zahl in `x` ablegen, z.B. die Zahl 7 mit\n",
    "    \n",
    "    x = 7\n",
    "    \n",
    "Dann können wir uns die Werte und Adressen der Speicherzellen erneut ansehen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 7\n",
    "print (id (x))\n",
    "print (id (y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Die Adresse für `y` ist unverändert, jedoch ist eine neue Adresse für `x` angelegt, in der jetzt dei `7` liegt. Und natürlich ist der Wert in der zu `y` gehörigen Zelle unverändert!\n",
    "    \n",
    "Jetzt gibt es kein Alias mehr."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "**Bemerkung:** In manchen anderen Programmiersprachen ist das Alias-Verhalten anders.\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gleichheit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Es gibt zwei Arten von ***Gleichheit***:\n",
    "- Die Variablen haben identische Speicherplätze.\n",
    "- Die Variablen haben identische Werte."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Normalerweise haben verschiedene Variablen auch verschiedene Speicherplätze. \n",
    "\n",
    "Jedoch gibt es Ausnahmen:\n",
    "1. Die Zuweisung `var2 = var1` erzwingt, dass die Variable `var2` ein Alias (s.o.) von `ver1` ist.\n",
    "2. Die Zahlen von -5 bis 256 werden intern immer in identischen Speichern aufbewahrt.\n",
    "    \n",
    "Der `is`-Operator zeigt uns, ob zwei Variablen auf identischen Speicher weisen. Probier das einmal mit verschiedenen Werten aus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 257\n",
    "y = 257\n",
    "x is y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = \"Hallo\"\n",
    "s2 = \"Hallo\"\n",
    "s1 is s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = \"Hallö\"\n",
    "s2 = \"Hallö\"\n",
    "s1 is s2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Offenbar stört der Umlaut!?!?!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Wenn man herausfinden möchte, ob die **Werte** zweier Variablen identisch sind, sollte man den `==`-Opertaor nutzen!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 12345\n",
    "y = 12345\n",
    "x == y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Doch bei Dezimalzahlen (float) ist Vorsicht angesagt! Denn obwohl die Werte offenbar identisch sind, erkennt Python das wegen der endlichen Genauigkeit ggf. nicht:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0.1 + 0.1 + 0.1\n",
    "y = 0.3\n",
    "x == y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Benutzereingabe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Die Kommunikation mit dem Python-System war bisher sehr einseitig. Mit der `print`-Anweisung konnte uns das System Ergebnisse von z.B. Berechnungen mitteilen.\n",
    "    \n",
    "Doch Computer benötigen oftmals auch Eingaben, z.B. von der Tastatur. das erfolgt mit dem Python-Kommando `input`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = input(\"Wie heisst du? \")\n",
    "gruss = \"Hallo \" + name\n",
    "print(gruss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Typen konvertieren"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Alle Werte haben in Python einen Typ. In den folgenden Kapitel lernen wir noch weitere Datentypen kennen. Bisher haben wir die folgenden Typen kennengelernt:\n",
    "    \n",
    "- Zahlen haben in Python den Typ `int` oder `float`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type (5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type (5.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "- Strings (auch mit *Zeichenkette* oder *Text* zu benennen) haben in Python den Typ `str`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type (\"Hallo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "- Wahrheitswerte haben in Python den Typ `bool`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "print (type (True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Hat man einer Variablen einen Wert zugewisen, hat diese Variable den Typ des in der Variablen gespeicherten Wertes: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = 5\n",
    "f = 5.0\n",
    "s = \"Hallo\"\n",
    "w = True\n",
    "\n",
    "print (type (z))\n",
    "print (type (f))\n",
    "print (type (s))\n",
    "print (type (w))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Jedoch ist der Typ einer Variablen nicht ddauerhaft festgelegt, wie das folgende Beispiel zeigt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = 5\n",
    "print (type (z))\n",
    "z = 5.0\n",
    "print (type (z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "In einigen Fällen ist es notwendig, den Typ einer Variablen zu ändern bzw. den Wert der Variablen anders zu interpretieren. \n",
    "    \n",
    "Ist beispielsweise die Ziffernfolge einer Zahl in einer Variablen gespeichert, kann man mit dieser Zahl im mathematischen Sinn nicht rechnen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahl = \"123\"\n",
    "## print (zahl + 1)  ergibt eine Fehlermeldung\n",
    "## print (zahl * 2) liefert nicht das gewünschte Ergebnis 246"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Um mit der Zahl mathematisch zu rechnen, muss man sie als `int` (oder `float`) interpretieren:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wert = int (zahl)\n",
    "## jetzt kann man damit rechnen:\n",
    "print (wert + 1)\n",
    "print (wert * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ***Aufgabe***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: DarkSeaGreen; padding: 5px 20px 20px\">\n",
    "\n",
    "Probiere andere andere Typumwandlungen aus.\n",
    "\n",
    "1. `str` $\\longleftrightarrow$ `float`\n",
    "1. `int` $\\longrightarrow$ `str`\n",
    "1. `bool` $\\longleftrightarrow$ `str`\n",
    "    \n",
    "Beobachte, was passiert, wenn man versucht, einen String, der nicht nur Ziffern enthält, als `int` zu interpretieren?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Wichtig ist diese Typumwandlung z.B. bei der Benutzereingabe von Zahlen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahl1 = input (\"erster Faktor: \")\n",
    "zahl2 = input (\"zweiter Faktor: \")\n",
    "wert1 = float (zahl1)\n",
    "wert2 = float (zahl2)\n",
    "print (zahl1, \"mal\", zahl2, \"=\", wert1 * wert2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Runden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Das Python-System stellt mehrere Möglichkeiten bereit, um Dezimalzahlen zu runden. \n",
    "    \n",
    "1. Eine erste Möglichkeit haben wir bereits weiter oben kennen gelernt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int (42.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Dabei wurde eine Dezimalzahl in eine ganze Zahl umgewandelt, indem die Nachkommastellen abgeschnitten wurden.\n",
    "    \n",
    "2. Es gibt die Funktionen `ciel()(` und `floor()`.    \n",
    "    \n",
    "Jedoch müssen wir dazu erst einmal diese Funktionen bereitstellen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Der Funktionsaufruf `ceil(n)` liefert die kleinste ganze Zahl, die größer oder gleich n ist:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.ceil (42.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Der Funktionsaufruf `floor(n)` liefert dagegen die größte ganze Zahl, die kleiner oder gleich n ist:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.floor(42.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\n",
    "Daneben gibt es die Funktion `round(zahl, n)`, die die (Fließkomma-)zahl auf n Stellen rundet. Dab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ***Aufgabe: ceil iund floor***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: DarkSeaGreen; padding: 5px 20px 20px\">\n",
    "\n",
    "- Probiere diese Funktionen aus:\n",
    "  - Wende sie auch auf negative Zahlen und auch auf ganze Zahlen an.\n",
    "  - Welchen Typ hat das Ergebnis der Funktionen?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Daneben gibt es die Funktion `round`:\n",
    "    \n",
    "round(z,n) rundet die (Dezimal-)zahl z auf n Stellen. dabei wird die Zahl abgerundet oder aufgerundet, abhängig von der Ziffer in z, die an der (n+1)-ten Stelle zu finden ist.\n",
    "    \n",
    "Benutzt man die Funktion ohne zweiten Parameter, so wird gerundet auf eine ganze Zahl."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ***Aufgabe: round***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: DarkSeaGreen; padding: 5px 20px 20px\">\n",
    "\n",
    "- Probiere auch diese Funktion aus:\n",
    "  - Wende sie auch auf negative Zahlen an.\n",
    "  - Rufe die Funktion mit einem und mit zwei Parametern auf.\n",
    "  - Nimm auch negative Zahlen als zweiten Parameter. \n",
    "  - Welchen Typ hat das Ergebnis der Funktion?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "round(123453.14159265, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "round(123453.14159265)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "round(123453.14159265, -3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Wenn du mehr erfahren möchtest, kannst du dir ein anderes (lokales) Jupyter-Notebook ansehen:\n",
    "- [Runden](2_1_Runden.ipynb)\n",
    "\n",
    "oder auf einer Internet-Seite weitere sehr lohnenswerte Informationen bekommen:\n",
    "- [Real Python](https://realpython.com/python-rounding/#pythons-built-in-round-function)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zufall\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Obwohl ein Computer ganz bestimmt nichts zufällig tun sollte, kann man Zufallszahlen erzeugen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "Wir benutzen drei verschedene Anweisungen, die sich in dem Modul `random` befinden. Dieses Modul muss zunächst importiert werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: Cornsilk; padding: 5px 20px 20px\">\n",
    "\n",
    "1. Die Anweisung `random.random()`erzeugt eine zufällige Dezimalzahl zwischen 0 und 1 (0 eingeschlossen, 1 ausgeschlossen)\n",
    "2. Die Anweisung `random.uniform(unten, oben)`erzeugt eine zufällige Dezimalzahl zwischen `unten` und `oben` (unten eingeschlossen, oben ausgeschlossen\n",
    "3. Die Anweisung `random.randint(unten, oben)`erzeugt eine zufällige ganze Zahl zwischen `unten` und `oben` (unten  und oben eingeschlossen\n",
    "    \n",
    "Du wirst sehen, dass jedesmal, wenn du ein der folgenden Zellen ausführst, ein anderes Ergebnis - für uns nicht vorhersagbar - erzeugt wird!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(random.random())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(random.uniform(1,100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(random.randint(1,100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ***Aufgabe***: Würfeln mit zwei Würfeln"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: DarkSeaGreen; padding: 5px 20px 20px\">\n",
    "\n",
    "Ein (fairer) Würfel zeigt gleich-wahrscheinlich eine Zahl zwischen 1 und 6 (jeweils einschliesslich). \n",
    "    \n",
    "Jetzt soll man mit zwei Würfeln werfen; die Summe soll dann ausgegeben werden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: DarkSeaGreen; padding: 5px 20px 20px\">\n",
    "\n",
    "Beim Werfen mit zwei Würfeln kann ein sogenannter *Pasch* (beide Würfel zeigen dieselbe Augenzahl) auftauchen. Die Augabe soll True oder False zeigen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hier geht es weiter:\n",
    "- [Fallunterscheidungen](3_Fallunterscheidungen.ipynb)    "
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "564.717px",
    "left": "1003px",
    "top": "150.133px",
    "width": "242.333px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}