Add files via upload

Python-Syntax.ipynb

@@ -4,9 +4,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Python Syntax\n",
-    "Hinweise zum Lesen:\n",
-    "    - Nach dem Code-Block ist jeweils die Konsolen-Ausgabe sichtbar"
+    "# Python Syntax"
    ]
   },
   {
@@ -214,6 +212,311 @@
     "print(\"Hallo Welt\"[6]) # das 7. Zeichen wird ausgegeben"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Groß- und Kleinschreibung\n",
+    "Mit der `.upper()`- bzw. `.lower()`-Methode können alle Zeichen in Groß- bzw. Kleinbuchstaben angezeigt werden."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "HALLO\n",
+      "HALLO\n",
+      "hallo\n",
+      "hallo\n"
+     ]
+    }
+   ],
+   "source": [
+    "w = \"Hallo\"\n",
+    "print(w.upper())\n",
+    "print(\"Hallo\".upper())\n",
+    "print(w.lower())\n",
+    "print(\"Hallo\".lower())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### String Anfang und Ende\n",
+    "Mit der `.startswith()`- bzw. `.endswith()`-Methode kann man prüfen, ob ein String mit einem anderen String beginnt/\n",
+    "aufhört."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Der Satz endet mit drei Fragezeichen\n",
+      "Der Satz beginnt mit einem 'ist'\n"
+     ]
+    }
+   ],
+   "source": [
+    "sentence = \"Ist das Wetter heute gut???\"\n",
+    "\n",
+    "if sentence.endswith(\"???\"):\n",
+    "    print(\"Der Satz endet mit drei Fragezeichen\")\n",
+    "    \n",
+    "if sentence.startswith(\"Ist\"):\n",
+    "    print(\"Der Satz beginnt mit einem 'ist'\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### `.strip()`-Methode\n",
+    "Standardmäßig entfernt die `.strip()`-Methode Leerzeichen vom Anfang und vom Ende des Strings:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Hallo Welt.'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"   Hallo Welt.    \".strip() "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Der `strip()`-Methode können Parameter übergeben werden, welche Zeichen entfernt werden sollen.<br>\n",
+    "Die `.lstrip()`- bzw. `.rstrip()`-Methode funktioniert analog der `.strip()`-Methode, wobei aber `.lstrip()` nur die linke Seite und `.rstrip()` nur die rechte Seite betrachtet:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hallo\n",
+      "Hallo.__\n",
+      "____Hallo.\n"
+     ]
+    }
+   ],
+   "source": [
+    "word = \"____Hallo.__\"\n",
+    "print(word.strip(\"_.\"))\n",
+    "print(word.lstrip(\"_\"))\n",
+    "print(word.rstrip(\"_\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### `.find()`- Methode\n",
+    "Mit der `.find()`-Methode kann man herausfinden, an welcher Stelle ein Zeichen in einem String vorkommt.<br>\n",
+    "Wenn die `.find()`-Methode die Zahl `-1` zurückgibt, bedeutet dass, dass das Zeichen im String nicht vorkommt:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sentence = \"Ist das Wetter heute, und morgen gut???\"\n",
+    "print(sentence.find(\",\"))\n",
+    "print(sentence.find(\"!\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Zeichen ersetzen (`.replace()`)\n",
+    "Mit der `.replace()`-Methode können Ersetzungen durchgeführt werden."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sentence = \"Ist das Wetter heute, und morgen gut???\"\n",
+    "\n",
+    "print(sentence.replace(\",\", \";\"))\n",
+    "print(sentence.replace(\"u\", \"ü\"))\n",
+    "print(sentence.replace(\"und\", \"oder\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Strings formatieren\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ich habe 5 Hunde\n"
+     ]
+    }
+   ],
+   "source": [
+    "n = 5\n",
+    "print(\"Ich habe \" + str(n) + \" Hunde\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Wie bekommst du es jetzt hin, dass der Sprachbaustein austauschbar ist und nicht mit dem `+ str(n) +`Befehl \"verwoben\" ist?\n",
+    "\n",
+    "**Idee:** Du könntest die Sprachbausteine in einem Dictionary definieren und einen Platzhalter per `.replace()` einsetzen:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "translations = {\n",
+    "    \"number_of_dogs\": \"Ich habe XXX Hunde\"\n",
+    "}\n",
+    "print(translations[\"number_of_dogs\"].replace(\"XXX\", str(n)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Problem:** Das wird aber schnell unübersichtlich. \n",
+    "\n",
+    "**Lösung:** Glücklicherweise stellt uns Python hier eine `.format()`-Methode zur Verfügung, die das ganze sehr viel einfacher macht. Hierbei verwenden wir `{0}` für die Position, wo wir den Parameter `n` des `.format(n)`-Aufrufs einsetzen möchten:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"Ich habe {0} Hunde\".format(n))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Diese `.format()`-Methode funktioniert auch mit mehreren Parametern. Hierbei definiert dann `{0}` die Position für den ersten Parameter, `{1}` die Position, wo der 2. Parameter hin gesetzt werden soll. \n",
+    "\n",
+    "Hier in folgendem Fall wird also die `{1}` durch `\"Katzen\"` ersetzt, und `{0}` durch die Zahl 5:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"Ich habe {1} {0}x\".format(5, \"Katzen\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Kommazahlen und runden\n",
+    "\n",
+    "Der `format()`-Befehl erlaubt es, Kommazahlen komfortabel zu runden. Hierbei wird an einen Formatierungs-Befehl (das war z. B. `{0}` oder `{1}`) noch innerhalb der geschweiften Klammern ein `f` drangehängt.\n",
+    "\n",
+    "Dadurch sagen wir Python, dass diese Zahl als Kommazahl betrachtet werden soll. Entsprechend wird hier jetzt die Zahl 5 eingesetzt, die `.000000` werden aber ergänzt, weil es als Kommazahl ausgegeben wird:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"So viele Katzen habe ich: {0:f}\".format(5))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Wenn wir die Anzahl der Stellen beschränken möchten, können wir das tun, indem wir nach dem Doppelpunkt .2 schreiben, um z. B. die Kommazahl auf 2 Nachkommastellen zu limitieren:\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"So viele Katzen habe ich: {0:.2f}\".format(5))\n",
+    "print(\"Pi hat den Wert: {0:.3f}\".format(3.141529))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Parameter bennennen\n",
+    "\n",
+    "Wenn du einen String hast, in dem viele Platzhalter eingesetzt werden, wird die Schreibweise `{0}`, `{1}`, `{2}`, `{3}`, `{4}`, `{5}`, ... irgendwann unübersichtlich.\n",
+    "\n",
+    "Glücklicherweise können wir die Parameter auch benennen. Hierbei ist wichtig, dass, wenn auf der linken Seiten ein Parameter z. B. `{animal}` heißt, der Parameter `animal` dann entsprechend auch der `.format()`-Funktion übergeben wird. \n",
+    "\n",
+    "Hier in dem Fall ist es also so, dass an die Stelle, an der `{animal}` steht, der Wert vom `.format()`-Aufruf `animal = \"Hunde\"` (konkret das Wort \"Hunde\") eingesetzt wird: "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"Ich habe {number:.3f} {animal}\".format(number = 5, animal = \"Hunde\"))"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -343,22 +646,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Wie ist dein Name?\n",
-      "Alex\n",
+      "Wie ist dein Name? Alex\n",
       "Hallo Alex\n"
      ]
     }
    ],
    "source": [
-    "print('Wie ist dein Name?')   # ask for their name\n",
-    "myName = input() # eine Zeile mit Eingabe wird geöffnet\n",
+    "myName = input(\"Wie ist dein Name? \") # eine Zeile mit Eingabe wird geöffnet, der String wird davor ausgegeben\n",
     "print('Hallo {}'.format(myName))"
    ]
   },
@@ -1689,8 +1990,8 @@
    "metadata": {},
    "source": [
     "# 6. Funktionen\n",
-    "Funktionen sind t´zusammengefasste Codeblöcke. Mittels Funktionen vermeidet man mehrmals verwendete Codeblöcke. Eine Funktion kann merhmals im Programm aufgerufen werden, nachdem sie definiert wurde.<br>\n",
-    "Beachte, der Funktion oder ihren Variablen keine Dopplungen aus deinem Code zu geben!\n",
+    "Funktionen sind zusammengefasste Codeblöcke. Mittels Funktionen vermeidet man mehrmals verwendete Codeblöcke. Eine Funktion kann merhmals im Programm aufgerufen werden, nachdem sie definiert wurde.<br>\n",
+    "Beachte, der Funktion oder ihren Variablen keine Namens-Dopplungen aus deinem Code zu geben!\n",
     "\n",
     "### Funktionen definieren und Aufrufen\n",
     "\n",
@@ -1725,8 +2026,9 @@
    "metadata": {},
    "source": [
     "### Funktionen können auch mit einem oder mehreren Argumenten arbeiten\n",
-    "def Funktionname(Argument):<br>\n",
-    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Code"
+    "Argumente und Variablen können an Funktionen übergeben werden. Zu beachten ist hierbei, dass die Funktion mit einer \"Kopie\" der Variable arbeitet und nur mit einem 'return' diese Variable im restlichen Code ändert. Sonst wird die Variable nur innerhalb der Funktion geändert. Ausnahmen sind Listen (oä) die innerhalb einer Funktion erweiter/gekürtzt werden.<br>\n",
+    "**def** Funktionname(Argument):<br>\n",
+    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;**Code**"
    ]
   },
   {
@@ -1772,6 +2074,40 @@
     "print_more(\"Hallo!\", 3)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Variable Funktionsparameter\n",
+    "Einer Funktion können auch unterschiedlich viele Parameter übergeben werden"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3\n",
+      "12\n"
+     ]
+    }
+   ],
+   "source": [
+    "def calculate_max(*parameter):\n",
+    "    current_max = parameter[0]\n",
+    "    for item in parameter:\n",
+    "        if item > current_max:\n",
+    "            current_max = item\n",
+    "    return current_max\n",
+    "\n",
+    "print( calculate_max(1,2,3) )\n",
+    "print( calculate_max(2,4,6,8,10,12) )"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -2685,12 +3021,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# 12. Datenstrukturen\n",
-    "\n",
-    "- Listen: Geordnete Auflistung von Elementen. Bsp: `liste = [\"Hallo\", \"Welt\"]`\n",
-    "- Dictionaries: Zuordnung von Schlüssel zu Wert. Bsp: `d = {\"Hallo\": 5, \"Welt\": 4}`\n",
-    "- Set: Ungeordnete Sammlung von Elementen, deren Elemente innerhalb nur einmal vorkommen dürfen\n",
-    "- PriorityQueue (Prioritätswarteschlange): Automatische Sortierung der Elemente"
+    "# 12. Expertenwissen\n"
    ]
   },
   {