Day1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Erste Schritte in Python\n",
    "## Python als Sprache\n",
    "Python ist eine interpretierte Programmiersprache.\n",
    "Das bedeutet, dass zwischen euren Skripten und der Ausführung im Rechner\n",
    "eine Übersetzung von Python erfolgt.\n",
    "Um genau zu sein ruft ein Programm, \n",
    "welches meist als Interpreter bezeichnet wird,\n",
    "in eurem Rechner bestimmte Befehle in Maschinensprache auf.\n",
    "Um euren Skript auszuführen muss also ein solcher Interpreter vorhanden sein.\n",
    "\n",
    "Dieser Interpreter erhält euer Skript in Form von Textzeilen,\n",
    "welche zum Beispiel in einer Datei mit der Endung „.py“ gespeichert sein können.\n",
    "Im Falle eines „Jupyter“-notebooks,\n",
    "werden die Anweisungen bei Ausführung eines Code-Blocks an den Interpreter übermittelt.\n",
    "Die Ausführung erfolgt mittels „Shift + Return“.\n",
    "Es wird der ausgewählte/eingerahmte Block ausgeführt.\n",
    "Die Ausgaben des Interpreters werden dann unterhalb des Code-Blocks angegeben. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unser Beispiel\n",
    "Um die Verwendung etwas anschaulicher zu gestalten wollen wir ein Skript erstellen,\n",
    "welcher die Lösungen für quadratische Gleichungen errechnet und zurück gibt.\n",
    "\n",
    "Für diese gilt:\n",
    "\\begin{equation}\n",
    "    a x^{2} + b x+c = 0=> x = \\frac{-b \\pm \\sqrt{b^2-4ac}}{2a}\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variablen\n",
    "Als erstes sollten wir die Variablen „a“, „b“ und „c“ definieren.\n",
    "Damit wir sie in der Berechnung der Lösung verwenden können.\n",
    "Wir beginnen damit, im folgenden Code-Block,\n",
    "eine Variable „a“ zu erzeugen und ihr den Wert „3“ zu zuweisen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Natürlich können wir nun auch weitere Variablen erzeugen,\n",
    "welche sich nach Ausführung der Code-Blöcke ebenfalls gespeichert werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 6\n",
    "c = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ausgabe\n",
    "Um zu überprüfen, ob unsere Variablen nach ausführen der Blöcke korrekt eingelesen wurden,\n",
    "können wir sie mit der „print()“-Funktion ausgeben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die „print()“-Funktion kann auch mehrere Variablen ausgeben,\n",
    "wenn diese durch ein „,“ getrennt werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(b,c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple Operatoren\n",
    "Als nächstes wollen wir nun mit dem Berechnen der Werte beginnen.\n",
    "Hierfür werden wir einige simple Operatoren verwenden.\n",
    "Ein klassisches Beispiel ist der Zuweisungsoperator „=“, welchen wir bereits verwendet haben. Dieser erfüllt nicht die Funktion des mathematischen =, sondern des mathematischen Zuweisungsoperators „<-“, welcher der Variablen links den Wert des Ausdruckes rechts zuweist. \n",
    "Der Zuweisungsoperator darf nur einmal pro Ausdruck vorkommen.\n",
    "\n",
    "Diesen wollen wir nun verwenden um eine neue Variable „Produkt“ zu erzeugen \n",
    "und ihr mittels des Multiplikationsoperators „*“ das Produkt einer Variable „Faktor“ und dem Wert „5“ zuzuweisen.\n",
    "Am Ende geben wir Produkt zur Überprüfung mit „print()“aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Faktor = 3\n",
    "Produkt = Faktor * 5\n",
    "print(Produkt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nun könnt ihr dieses Wissen verwenden,\n",
    "um den Nenner der abc-Formel \n",
    "$ \\left( 2 \\cdot a \\right) $ \n",
    "zu berechnen und in eine Variable mit dem Namen „Nenner“ zu speichern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fügt eure Lösung bitte hier ein"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Als nächstes können wir den Ausdruck unter der Wurzel $\\left( b \\cdot b - 4 \\cdot a \\cdot c \\right)$ berechnen.\n",
    "Hierfür werden wir den Substraktionsoperator „-“ verwenden.\n",
    "Zuerst ein kurzes Beispiel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Diff = 3 - 4\n",
    "print(Diff)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wenn ihr möchtet, dass ein bestimmter Ausdruck vor einem anderen ausgeführt wird könnt ihr dies durch Klammern erreichen.\n",
    "Auch hierzu ein kurzes Beispiel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Alpha = 3 - 4 * 2\n",
    "Beta  = 3 -(4 * 2)\n",
    "Gamma =(3 - 4)*2\n",
    "print(Alpha, Beta, Gamma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dieses Wissen könnt ihr nun nutzen um den Wert unter der Wurzel zu errechnen \n",
    "und in eine Variable mit Namen „Differenz“ zu speichern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fügt eure Lösung bitte hier ein"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nun wollen wir aus dieser Differenz die Wurzel ziehen.\n",
    "Hierfür können wir den Potenzoperator „\\*\\*“ verwenden.\n",
    "Als Beispiel errechnen wir hier das Quadrat von 4 und geben es anschließend aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Quadrat = 4 ** 2\n",
    "print(Quadrat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verwendet nun den Potenzoperator um die Wurzel aus der Variable „Differenz“ zu ziehen und in die Variable\n",
    "„Wurzel“ speichern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fügt eure Lösung bitte hier ein"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unter Verwendung der bisher erzeugten Variablen stellt sich die abc-Formel nun dar als:\n",
    "\\begin{equation}\n",
    "  x_{1/2} = \\frac{-b \\pm \\ \\mathrm{Wurzel}}{\\mathrm{Nenner}}\n",
    "\\end{equation}\n",
    "Hieraus können wir nun $x_1$ und $x_2$ berechnen. Dafür benötigen wir noch den Additionsoperator „+“, \n",
    "sowie den Divisionsoperator „/“.\n",
    "Diese funktionieren wie der Subtraktions- bzw. Multiplikationsoperator.\n",
    "Verwendet nun diese Operatoren und die Variablen „Wurzel“, „Nenner“ und „b“ um $x_1$ und $x_2$ zu speichern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fügt eure Lösung bitte hier ein"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Natürlich können wir diese Schritte auch in einem einzigen Block ausführen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3\n",
    "b = 6\n",
    "c = 2\n",
    "x_1 = (-b+(b**2-4*a*c)**(1/2))/(2*a)\n",
    "x_2 = (-b-(b**2-4*a*c)**(1/2))/(2*a)\n",
    "print(x_1, x_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dies ist jedoch nicht unbedingt übersichtlich,\n",
    "weshalb sich Zwischenschritte empfehlen. \n",
    "Diese reduzieren auch wenn Zwischenergebnisse wieder verwendet werden den Rechenaufwand für den Computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3\n",
    "b = 6\n",
    "c = 2\n",
    "Wurzel=( (b**2) - (4*a*c) ) ** (1/2)\n",
    "x_1 = (-b + Wurzel)/(2*a)\n",
    "x_2 = (-b - Wurzel)/(2*a)\n",
    "print(x_1, x_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Datentypen & Eingabe\n",
    "Jetzt wäre es natürlich noch schön,\n",
    "wenn wir „a“,„b“ und „c“ dynamisch einlesen könnten.\n",
    "Hierfür verwenden wir die Funktion „input()“."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Eingabe = input(\"Eine Zahl?\")\n",
    "print(Eingabe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Versucht nun den Code für die Quadratische Gleichung so zu ändern, dass ihr die Variablen „a“, „b“ und „c“ dynamisch einlest und lest nach einem Versuch den nächsten Abschnitt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fügt eure Lösung bitte hier ein"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wie ihr seht sind leider nicht alle Variablen gleich, da unterschiedliche Informationen unterschiedlich abgelegt werden. So besteht ein Unterschied zwischen der von „input“ zurückgegebenen Zeichenkette (String) und einer Zahl, \n",
    "weshalb ihr einen Fehler erhalten habt, um diesen zu beheben müssen wir den String in eine Zahl umwandeln.\n",
    "Jedoch sind auch nicht alle Zahlen gleich.\n",
    "So unterscheidet man innerhalb eines Rechners zwischen Ganzen Zahlen (integer) und Fließkommazahlen (float).\n",
    "Möchten wir Daten ineinander umwandeln so können wir dafür eine entsprechende Funktionen verwenden.\n",
    "Hier ein kurzes Beispiel für das Umwandeln eines floats in einen integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Eingabe = 3.8\n",
    "Ganze_Zahl = int(Eingabe)\n",
    "print(Ganze_Zahl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Möchten wir den Datentyp einer Variable erfahren so können wir die Funktion „type()“ verwenden.\n",
    "Auch hierzu einige Beispiele."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Typ = type(3)\n",
    "print(Typ)\n",
    "print(type(3.2))\n",
    "print(type(input(\"Ein paar Zeichen?\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mit diesem Wissen gerüstet könnt ihr nun, den Code für die quadratische Gleichung anpassen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fügt eure Lösung bitte hier ein"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operatoren & Datentypen\n",
    "Nun möchten wir vielleicht $x_1$ und $x_2$ etwas schöner ausgeben. \n",
    "Zum Beispiel in einem hübschen Satz.\n",
    "Hierfür können wir Strings nutzen und den Fakt, dass einige Operatoren datentypabhängig sind, \n",
    "der gleiche Operator also bei verschiedenen Datentypen zu verschiedenen Ergebnissen führt.\n",
    "\n",
    "Beginnen wir also damit eine Nachricht in Form eines Strings zu erstellen und auszugeben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "Nachricht = \"Dies ist eine Nachricht.\"\n",
    "print(Nachricht)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nun können wir Zahlen mittels „str()“ in Strings umwandeld \n",
    "und mittels des Additionsoperators zusammenfügen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Zahl = 3\n",
    "Nachricht = \"Die Zahl ist: \"\n",
    "Zusammengesetzte_Nachricht = Nachricht + str(Zahl)\n",
    "print(Zusammengesetzte_Nachricht)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dieses Wissen könnt ihr nun erweitern um den Code für die quadratische Gleichung weiter anzupassen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fügt eure Lösung bitte hier ein"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Leider kann nicht jeder Operator auf jeden Datentyp angewendet werden. \n",
    "Hierzu ein kurzes Beispiel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Text = \"Klaus\"\n",
    "Neuer_Text = Text/2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Für den Umgang mit Python solltet ihr folgende Variablen/Datentypen kennen.\n",
    "* Fließkommazahlen (*float*)\n",
    "* Ganze Zahlen (*integer* )\n",
    "* Boolesche Variablen (*bool*)\n",
    "* Zeichenketten (*string*)\n",
    "* Komplexe Datentypen (z.B. list)\n",
    "\n",
    "Boolesche Variablen sind Wahrheitswerte. Sie sind entweder wahr oder falsch. Komplexe Datentypen sind ein Sammelbegriff für eine Vielzahl teilweise auch selbst definierter Datentypen, welche ihr erst deutlich später verstehen müsst.\n",
    "\n",
    "**Merke: Variablen haben Datentypen. Um zwei Variablen unterschiedlichen Typs miteinander zu verrechnen müssen diese in denselben Datentyp umgewandelt werden, dies geschieht bei Pyhton meist automatisch. Hierbei können Probleme, wie zum Beispiel Rundungsfehler auftreten.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listen & Referenzen\n",
    "Natürlich benötigt man nur selten ein Skript, \n",
    "welches eine quadratische Gleichung löst und diese ausgibt.\n",
    "Meistens müssen diese Lösungen weitergeleitet werden.\n",
    "Hierfür gibt es verschiedene Möglichkeiten.\n",
    "Eine der einfachsten ist eine Liste, \n",
    "in welcher beliebig viele Variablen abgelegt werden können,\n",
    "es handelt sich um einen komplexen Datentyp.\n",
    "\n",
    "Hierzu ein kurzes Beispiel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Variable = 4\n",
    "Liste = [3, 2.1, \"Zahl\", Variable]\n",
    "print(Liste)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nutzt dieses Wissen nun um den folgenden Code so zu erweitern,\n",
    "dass er $x_1$ und $x_2$ als Liste mit Namen „X“ ausgibt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = float(input(\"Was ist a?\"))\n",
    "b = float(input(\"Was ist b?\"))\n",
    "c = float(input(\"Was ist c?\"))\n",
    "Wurzel=( (b**2) - (4*a*c) ) ** (1/2)\n",
    "x_1 = (-b + Wurzel)/(2*a)\n",
    "x_2 = (-b - Wurzel)/(2*a)\n",
    "\n",
    "# Fügt eure Lösung bitte hier ein"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listen sind vor allem in der Datenverarbeitung wichtig,\n",
    "da sie es ermöglichen viele Daten parallel zu verarbeiten.\n",
    "Deshalb hier noch einige Informationen zum Umgang mit Listen.\n",
    "\n",
    "Auf Daten in einer Liste kann man mit eckigen Klammern zugreifen.\n",
    "(Auch diese Klammern sind strenggenommen Operatoren).\n",
    "Es gilt zu beachten, dass das erste Element über 0 indiziert wird."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Liste[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es ist auch möglich Einträge zu verändern,\n",
    "indem man mittels des Index einen Eintrag der Liste angibt. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Liste[1] = \"Test\"\n",
    "print(Liste)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es sollte beachtet werden, dass Listen und Variablen nicht die tatsächlichen Daten speichern,\n",
    "sondern Verweise auf diese.\n",
    "Diesen Verweis, auch Referenz, genannt kann man sich vorstellen wie eine Postadresse, eine URL oder einen Literaturverweis,\n",
    "welche auf einen Ort verweisen, an welchem sich die Daten befinden. Hierzu ein kleines Beispiel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [2, 3, 4]\n",
    "b = a\n",
    "b[2] = \"Suprise\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um dieses Ergebnis besser zu verstehen sollten wir es Zeile für Zeile analysieren.\n",
    "Hierzu sind Kommentare hilfreich, also Textbemerkungen im Programmcode.\n",
    "Diese treten in Python in 2 Formen auf als Strings,\n",
    "welche dann nicht weiter verwendet werden\n",
    "oder als klassische Kommentarzeilen,\n",
    "welche vom Interpreter ignoriert werden und mit „#“ eingeleitet werden.\n",
    "\n",
    "**Merke: Alles hinter # wird ignoriert.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hier erstellen wir eine Variable a welche auf eine Liste mit 3 Einträgen verweist\n",
    "a = [2, 3, 4]\n",
    "# Nun erzeugen wir eine Variable b, welche auf jenes Objekt verweist auf welches a verweist\n",
    "b = a # Damit zeigen nun a und b auf diese Liste\n",
    "b[2] = \"Suprise\" # Nun ändern wir den Eintrag in der Liste auf welche b verweist\n",
    "# Da dies die selbe Liste ist, auf welche a verweist erhalten wir auch eine veränderte Ausgabe\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dieses Verhalten kann vermieden werden, indem man eine neue Liste erzeugt. \n",
    "Hierfür kann man den Konstruktor „list()“ verwenden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [2, 3, 4]\n",
    "b = list(a)\n",
    "b[2] = \"Suprise\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es gilt zu beachten, dass „list()“ nur die Liste mit ihren Verweisen kopiert.\n",
    "Enthält diese eine andere Liste so wird diese nicht erneut erzeugt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Innen = [\"Hello\", 2, 3]\n",
    "a = [2, 3, Innen]\n",
    "b = list(a)\n",
    "b[2][1] = \"Suprise\"\n",
    "print(a)"
   ]
  }
 ],
 "metadata": {
  "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}