{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "883f329a",
   "metadata": {},
   "source": [
    "# Vorkurs Tag 2\n",
    "\n",
    "Author: Janina Nehring"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb23a141",
   "metadata": {},
   "source": [
    "Übersicht heutiges Programm: \n",
    "1. Vergleichsoperatoren\n",
    "2. Logische Operatoren\n",
    "3. `if-else`-Abfragen\n",
    "    * Klassische If-Abfrage\n",
    "    * Fallunterscheidung mit If-Else\n",
    "    * Mehrere Bedingungen mit If-Elif-Else\n",
    "    * Switch-Case-Konstrukt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62b378b2",
   "metadata": {},
   "source": [
    "# 1. Vergleichsoperatoren\n",
    "Oft möchte man beim Programmieren zwei Werte miteinander vergleichen. Hierbei helfen _Vergleichsoperatoren_. Viele davon kommen aus der Mathematik, und sollten euch deswegen schon bekannt vorkommen. \n",
    "\n",
    "Python kennt sechs Operatoren, die Vergleiche ermöglichen: \n",
    "* `<`/`>`: Kleiner/ größer\n",
    "* `<=`/`>=`: Kleiner gleich/ größer gleich\n",
    "* `==`: Gleich\n",
    "* `!=`: Ungleich\n",
    "\n",
    "Diese Operatoren vergleichen zwei Werte (sowohl Zahlen als auch Strings) und geben ein boolean (`True` oder `False`) zurück. \n",
    "\n",
    "Beispiele: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "68bc3a6b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "25 < 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "64209612",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Hello\" != \"Hey\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "91038e61",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "32 != 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3b27129e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Da A vor B im Alphabet kommt, ist A kleiner als B \n",
    "\"A\" < \"B\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cc3eb23",
   "metadata": {},
   "source": [
    "Mit Variablen sieht das dann so aus: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f21cb2a7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 5\n",
    "y = 10\n",
    "\n",
    "x > y "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ed237d9",
   "metadata": {},
   "source": [
    "# 2. Logische Operatoren\n",
    "\n",
    "Um komplexere Abfragen zu konstruieren, braucht man ein Werkzeug um Bedingungen zu verknüpfen. Hier kommen logische Operatoren ins Spiel. \n",
    "Python kennt drei verschiedene logische Operatoren: \n",
    "  * `and`/`&`:  `and` prüft ob beide Bedingungen gleichzeitig `True` sind. Wenn ja, dann gibt es `True` zurück, sonst `False`.\n",
    "\n",
    "Folgende Tabelle hilft dabei, zu wissen welches das Ergebnis ist, abhängig von den Werten von `a` und `b`: \n",
    "\n",
    "| `a` | `b` | `a and b`| \n",
    "|-----|-----|----------| \n",
    "| True| True| True| \n",
    "| True| False| False| \n",
    "| False| True| False| \n",
    "| False| False| False| "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d93f0a44",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Preis = 5.99\n",
    "Preis > 5 and Preis < 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "706f8c31",
   "metadata": {},
   "source": [
    "* `or`/`|`: `or` prüft ob eine der beiden Bedingungen  `True` ist. Wenn ja, dann gibt es `True` zurück, sonst `False`.\n",
    "\n",
    "| `a` | `b` | `a or b`| \n",
    "|-----|-----|----------| \n",
    "| True| True| True| \n",
    "| True| False| True| \n",
    "| False| True| True| \n",
    "| False| False| False| "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f5a07505",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Preis = 5.99\n",
    "Preis > 10 or Preis < 20"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b024090",
   "metadata": {},
   "source": [
    "* `not`: `not` invertiert den booleschen Wert einer Bedingung\n",
    "\n",
    "| `a` |`not a`| \n",
    "|-----|-------| \n",
    "|True | False | \n",
    "|False| True  | "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2b906c97",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Preis = 5.99\n",
    "not Preis < 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca3793f7",
   "metadata": {},
   "source": [
    "### Präzedenz von logischen Operatoren: \n",
    "\n",
    "Man kann auch mehrere logische Operatoren hintereinander verketten. Die Operatoren haben aber eine unterschiedlich hohe Bindung (oder Präzedenz): \n",
    "Die höchste Präzedenz hat `not`, danach kommt `and` und zuletzt `or`. \n",
    "\n",
    "Python wertet die Operatoren mit der höchsten Präzedenz zuerst aus und geht dann weiter. \n",
    "\n",
    "Sprich, folgender Ausdruck wird so ausgewertet: \n",
    "```python\n",
    "not a and b or c \n",
    "```\n",
    "---> \n",
    "```python\n",
    "(not a) and b or c \n",
    "```\n",
    "--> \n",
    "```python\n",
    "((not a) and b) or c \n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f6c3095a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Preis = 5.99\n",
    "not (Preis < 5 and Preis > 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "1a47b19b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not Preis < 5 and Preis > 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4acc5e30",
   "metadata": {},
   "source": [
    "In diesem Sinne: \n",
    "\n",
    "❗ **Klammern sind wichtig** ❗"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0aa3605d",
   "metadata": {},
   "source": [
    "# 3. If-Abfrage\n",
    "\n",
    "### Klassische If-Abfrage \n",
    "Die `if`-Abfrage erlaubt es, einen Code-Block nur auszuführen, wenn eine bestimmte Bedingung erfüllt ist.\n",
    "\n",
    "Die Syntax ist: \n",
    "```python\n",
    "  if Bedingung: \n",
    "    anweisung_1()\n",
    "    ...\n",
    "```\n",
    "Achtet immer auf die Einrückung! Sonst verhält sich der Code eventuell nicht so wie ihr möchtet. \n",
    "\n",
    "Beispiel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "86ffe1cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "age = 12\n",
    "if age >= 18: \n",
    "  print(\"Du bist volljährig!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0fc0e1c",
   "metadata": {},
   "source": [
    "### If-Else\n",
    "\n",
    "`if-else` wird benutzt um eine Fallunterscheidung zu machen, also einen Teil des Codes ausführen wenn die Bedingung wahr ist, und ein anderer Teil wenn sie falsch ist. \n",
    "\n",
    "Die Syntax ist: \n",
    "```python\n",
    "if Bedingung: \n",
    "  if_block\n",
    "else: \n",
    "  else_block\n",
    "```\n",
    "\n",
    "Wenn die Bedingung `True` ist, dann wird der `if`-Block ausgeführt. Wenn die Bedingung `False` ist, dann wird der `else`-Block ausgeführt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "179956ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Du bist volljährig!\n"
     ]
    }
   ],
   "source": [
    "age = 21\n",
    "if age >= 18: \n",
    "    print(\"Du bist volljährig!\")\n",
    "else: \n",
    "    print(\"Du bist minderjährig!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a807aab",
   "metadata": {},
   "source": [
    "### If-Elif-Else\n",
    "Wenn man mehrere verschiedene Bedingungen abfragen möchte und für jede Bedingung eine bestimmten Code-Block ausführen möchte, kann man das `if...elif...else`-Konstrukt verwenden. \n",
    "`elif` steht dabei für `else if`. \n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "if Bedingung_1: \n",
    "  if_block\n",
    "elif Bedingung_2: \n",
    "  elif_block_1\n",
    "elif Bedingung_3: \n",
    "  elif_block_2\n",
    "...\n",
    "else: \n",
    "  else_block\n",
    "```\n",
    "\n",
    "Die Bedingungen werden in der Reihenfolge in der sie geschrieben sind abgefragt. Sobald eines `True` ist, wird der zugehörige Code-Block ausgeführt und der Rest wird übersprungen. \n",
    "Wenn keine Bedingung `True` ist, dann wird der `else`-Block ausgeführt. \n",
    "\n",
    "`else` ist optional und kann auch weggelassen werden. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "55e66e33",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Du darfst Bier trinken.\n"
     ]
    }
   ],
   "source": [
    "age = 15\n",
    "if age >= 18: \n",
    "  print(\"Du bist volljährig!\")\n",
    "elif age >= 16: \n",
    "  print(\"Du darfst Bier kaufen.\")\n",
    "elif age >= 14:\n",
    "  print(\"Du darfst Bier trinken.\")\n",
    "else: \n",
    "  print(\"Du darfst kein Alkohol trinken.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28f22e04",
   "metadata": {},
   "source": [
    "### Switch-Case\n",
    "\n",
    "Das Switch-Case-Konstrukt ist ein Spezialfall von einem If-Elif-Else. \n",
    "\n",
    "Es besteht aus einer Bedingung und mehreren Fällen, die überprüft werden, ob sie die Bedingung erfüllen. Jeder Fall entspricht einem bestimmten Wert. \n",
    "Das Input wird gegen diese Werte geprüft und der Fall, dem es entspricht, wird ausgeführt.\n",
    "\n",
    "Beispiel: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "086393b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Heute ist der zweite Tag der Woche.\n",
      "Not found\n"
     ]
    }
   ],
   "source": [
    "wochentag = \"Dienstag\"\n",
    "\n",
    "if wochentag == \"Montag\": \n",
    "  print(\"Heute ist der erste Tag der Woche.\")\n",
    "elif wochentag == \"Dienstag\": \n",
    "  print(\"Heute ist der zweite Tag der Woche.\")\n",
    "elif wochentag == \"Mittwoch\": \n",
    "  print(\"Heute ist der dritte Tag der Woche.\")\n",
    "elif wochentag == \"Donnerstag\": \n",
    "  print(\"Heute ist der vierte Tag der Woche.\")\n",
    "elif wochentag == \"Freitag\": \n",
    "  print(\"Heute ist der fünfte Tag der Woche.\")\n",
    "elif wochentag == \"Samstag\": \n",
    "  print(\"Heute ist der sechste Tag der Woche.\")\n",
    "elif wochentag == \"Sonntag\": \n",
    "  print(\"Heute ist der siebte Tag der Woche.\")\n",
    "\n",
    "status = 404\n",
    "\n",
    "match status:\n",
    "    case 400:\n",
    "        print(\"Bad request\")\n",
    "    case 404:\n",
    "        print(\"Not found\")\n",
    "    case 418:\n",
    "        print(\"I'm a teapot\")\n",
    "    case _:\n",
    "        print(\"Something's wrong with the internet\")"
   ]
  }
 ],
 "metadata": {
  "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.12.2"
  },
  "vscode": {
   "interpreter": {
    "hash": "3963bea6a32c9683406c652f7fd75d13763af4255782a29d8ebfa7eb1e80fbd3"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}