PythonEinfuehrung.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SOagkPSYeI_i"
   },
   "source": [
    "# Python - Erste Schritte\n",
    "\n",
    "Dieses Python-Notebook gibt eine kurze Einführung in Python und IPython Notebooks. Du kannst es verwenden, um dir Inspiration zu holen, was mit Python alles möglich ist oder um wichtige Funktionen bzw. den Syntax nachzuschauen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MZjIpsrpeI_o"
   },
   "source": [
    "## Python und IPython Notebooks\n",
    "Python ist eine weit verbreitete high-level Allzweckprogrammiersprache. Sie wurde 1991 von Guido van Rossum geschaffen und von der Python Software Foundation weiterentwickelt. \n",
    "\n",
    "Ein IPython-Notebook besteht aus einer Anzahl von Zellen. Jede Zelle kann Python-Code enthalten. Du kannst eine Zelle ausführen, indem du darauf klickst und [Shift-Enter] drückst. Dann wird der Code in der Zelle ausgeführt, und die Ausgabe der Zelle wird unterhalb der Zelle angezeigt. Nach dem Ausführen der ersten Zelle sieht das Notebook zum Beispiel so aus:\n",
    "\n",
    "'Hello World'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "mhJ4iC2heI_q",
    "outputId": "80af4112-e0f4-4372-f2ce-8a01ec289d21"
   },
   "outputs": [],
   "source": [
    "print('Hello World!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8P0KyAxMeI_r"
   },
   "source": [
    "## Variablen und Datenstrukturen in Python\n",
    "\n",
    "In Python musst du den Typ der Variablen nicht deklarieren, d.h. du musst nicht angeben ob du einen integer (Ganze Zahl), einen float (Kommazahl) etc. erstellen möchtest. Gib den Namen der Variable einfach ein und wenn ihr Werte gegeben werden, dann weiß sie automatisch, ob der gegebene Wert ein integer, float oder char (einzelnes Zeichen), ein Boolean (Wahrheitswert) oder sogar ein string (zusammenhängender Text) ist.\n",
    "\n",
    "Die wichtigsten Datenstrukturen in Python sind Listen und Wörterbücher (dictionaries). Sie sind in gewisser Weise aus den Grundtypen wie integer, float, string zusammen gesetzt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "gU5veafWeI_r"
   },
   "outputs": [],
   "source": [
    "# Pythonprogramm um Variablen und Datenstrukturen zu deklarieren (# beginnt eine Kommentarzeile in Python)\n",
    "print('Erst, deklarieren wir Variablen:')\n",
    "myNumber = 3 # int\n",
    "print(myNumber) \n",
    "\n",
    "myNumber2 = 4.5 # float\n",
    "print(myNumber2) \n",
    "\n",
    "myBool = True # boolean - hier ist er wahr (True), für falsch nutze \"False\"\n",
    "print(myBool)\n",
    "\n",
    "myNumber =\"helloworld\" # string\n",
    "print(myNumber) \n",
    "\n",
    "print('Dann, Datenstrukturen:')\n",
    "myList = [1,2,3,4] # Liste\n",
    "print(myList)\n",
    "\n",
    "myDict = {'dog name': 'Bello', 'dog age':3} # Wörterbuch\n",
    "print(myDict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oepT_lNKeI_r"
   },
   "source": [
    "## Bedingungen\n",
    "In jeder Programmiersprache gibt es Bedingungsschlüsselwörter, die dazu genutzt werden ob etwas der Fall ist oder nicht. In Python gibt es die beiden Schlüsselwörtern 'if' und 'elif' (elseif) und 'else'. \n",
    "\n",
    "\n",
    "Dazu ein Beispiel. Der Bedingungs- bzw. Auswahlcode vergleicht zwei Werte und ermittelt den größeren. Achte besonders auf die Einrückung, die für Python und den Aufbau des Codes sehr wichtig ist, denn sie zeigt an worauf sich die Bedingung bzw. was in ihr enthalten ist. Wenn du die richtige Einrückung vergisst, wird der Code nicht durchlaufen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pythonprogramm um darzustellen wie Bedingungen funktionieren\n",
    "\n",
    "num1 = 34\n",
    "num2 = 12\n",
    "if(num1>num2): \n",
    "    print(\"num1 ist größer\") \n",
    "elif(num1<num2): \n",
    "    print(\"num1 ist kleiner\") \n",
    "else: \n",
    "    print(\"num1 und num2 sind gleich groß\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Schleifen\n",
    "\n",
    "Schleifen sind hilfreich, wenn du einen Code eine gewisse Zeit lang bis eine Bedingung erfüllt ist (while) oder für eine feste Anzahl von Schritten (for) ausführen möchtest. Die Schlüsselwörter in Python sind 'for' und 'while'.\n",
    "\n",
    "Auch hier ein kurzes Beispiel. Erst zählen wir mit einer for-Schleife bis 9 und dann mit einer while-Schleife von 1 bis 14. Achte auch hier auf die Einrückungen. Wenn du mit range() die Anzahl der Schritte definierst fängt Python immer bei 0 an zu zählen. Dies gilt auch für Listen. Wenn du z.B. den ersten Eintrag von myList benutzen möchtest müsstest du myList[0] nutzen (schreibe eine neue Zeile - print(myList[0]) - um dies auszuprobieren)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pythonprogramm, um darzustellen wie Schleifen funktionieren\n",
    "\n",
    "print('Dieses Programm zählt von 0 bis 9:')\n",
    "for i in range(10): # range ist auch ein Schlüsselwort in Python und kann genutzt werden, um die Anzahl der Schritte zu definieren\n",
    "    print(i)\n",
    "\n",
    "print('Dieses Programm zählt von 1 bis 14:')\n",
    "j = 1\n",
    "while j < 15:\n",
    "    print(j)\n",
    "    j += 1 # += ist eine besondere Abkürzung und bedeutet soviel wie nehme die Variable und addiere die rechte Zahl hinzu, also j = j+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funktionen\n",
    "Um komplexeren Code übersichtlicher zu machen sind Funktionen hilfereich. Funktionen kannst du dir wie ein Bündel von Code vorstellen, das eine bestimmte Aufgabe im gesamten Python-Skript erledigen soll. Python verwendet das Schlüsselwort 'def', um eine Funktion zu definieren.\n",
    "\n",
    "Dazu ein Beispiel: Die implementierte Funktion addiert einfach zwei Argumente zueinander. Auch hier ist die Einrückung wichtig. Diese gibt an welcher Teil/ welche Codezeilen in der Funktion ausgeführt wird. Hast du gemerkt dass Schleifen, Bedingungen und Funktionen immer einen : brauchen. Dieser ist auch wichtig und darf nicht vergessen werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "r7g22_OkeI_t"
   },
   "outputs": [],
   "source": [
    "# Pythonprogramm um Funktionen an einem einfachen Addierer zu illustrieren\n",
    "\n",
    "def adder(arg1, arg2): # hier wird der Name der Funktion (adder) und die Argumente (arg1 und arg2) die sie annimmt definiert\n",
    "    result = arg1 + arg2 # das ist der Körper der Funktion. Hier eine einfache Addition\n",
    "    return result # \"return\" ist das Schlüsselwort welches den Output der Funktion definiert. Die variablen die danach folgen (hier result) werden zurückgegeben\n",
    "\n",
    "print('Testen von adder mit 2 und 5 macht:')\n",
    "result = adder(2,5) # Hier wenden wir die Funktion mit den beiden Argumenten 2 und 5 an und speichern das Ergebnis in der Variable result\n",
    "print(result) # Nun müssen wir das Ergebnis noch ausgeben (ausdrucken/print) um es wirklich sehen zu können\n",
    "\n",
    "print('Testen von adder mit 1 and -3.5 macht:')\n",
    "print(adder(1,-3.5)) # Hier ist ein weiterer Test. Wir speichern das Ergebnis nicht in einer neuen Variable sondern geben es direkt aus.    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p1vQCabseI_u"
   },
   "source": [
    "**Miniaufgabe**: Schreibe eine Funktion, die den größeren Wert vom kleineren abzieht. Nenne deine Funktion *substract_positive*. Sie nimmt zwei Argumente an und gibt das Ergebnis der Subtraktion zurück."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Z7xt3fWveI_u"
   },
   "outputs": [],
   "source": [
    "# Tipp: Operatoren um Variablen zu vergleichen sind in Python: < (kleiner), > (größer), =< (kleiner gleich), >= (größer gleich), != (ungleich)\n",
    "# CODE HIER:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hyuiIHX2eI_u"
   },
   "source": [
    "Nun teste deinen Code, indem du die nächste Zelle ausführst. Stimmt das Ergebnis?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Jco9nvWGeI_v"
   },
   "outputs": [],
   "source": [
    "print(substract_positive(5,10))\n",
    "print(substract_positive(-3,4.3))\n",
    "print(substract_positive(2,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wT1OMBOMm0e7"
   },
   "source": [
    "Falls es nicht stimmt. Gibt dir die Fehlermeldung einen Hinweis was das Problem ist? Hast du die Einrückungen beachtet? Du kannst auch versuchen den Fehler zu Googlen, das führt bei Programmierproblemen oft sehr schnell zur Lösung. Auf Englisch hast du eine bessere Chance auf ein schnelles Ergebnis als auf Deutsch."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kbtSNNCgeI_v"
   },
   "source": [
    "## Python packages - NumPy und Matplotlib\n",
    "Für Python gibt es viele Pakete (packages), die bereits fertige Funktionen, Datenstrukturen oder Operationen enthalten. Du kannst diese Pakete in dein Notebook einbinden, um sie zu nutzen. \n",
    "\n",
    "Eines der wichtigsten Pakete ist NumPy. Es ist das grundlegende Paket für das wissenschaftliche Rechnen mit Python. Es enthält unter anderem: ein vielseitiges N-dimensionales Array-Objekt, mathematische Funktionen wie Sinus und Cosinus, nützliche Funktionen für lineare Algebra, Konstanten wie $\\pi$ und Zufallszahlen.\n",
    "\n",
    "Matplotlib ist eine umfangreiche Bibliothek zum Erstellen von statischen, animierten und interaktiven Visualisierungen in Python. Daher ist dieses Paket oft sehr nützlich, um deine Ergebnisse zu visualisieren."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AjyhKdmWeI_w"
   },
   "outputs": [],
   "source": [
    "# importieren von packages\n",
    "import numpy as np # Das übersetzt sich zu: importiere das Paket numpy und speichere es für die Nutzung als np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xr9EufXGeI_w"
   },
   "source": [
    "Aber wie diese importierten Pakete nutzen?  Hier ist ein kleines Beispiel welches den relativen Fehler von zwei Zahlen auf Basis einer der Zahlen berechnet. Die Definition lautet:\n",
    "$$\\frac{x-y}{x}$$ wobei $x$ die Basis (wahrer Wert ist) und $y$ die Vorhersage bzw. der gemessene Wert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PhyMU9zDeI_x"
   },
   "outputs": [],
   "source": [
    "def rel_error(x, y):\n",
    "    \"\"\" errechnet den relativen Fehler \"\"\" # Hast du gemerkt, dass man auch mit \"\"\" in Kommentare einfügen kann? Das ist für mehrzeilige Kommentare.\n",
    "    absolute_difference = np.abs(x - y) # np.abs() gibt den absoluten Wert / Betrag zurück z.B. für -2 gibt die Funktion 2 zurück\n",
    "    real_value = np.maximum(1e-8, np.abs(x)) # np.maximum(arg1,arg2) gibt den größeren Wert der beiden zurück\n",
    "    \n",
    "    return absolute_difference / real_value\n",
    "\n",
    "print(rel_error(2,2.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZxLpiIDTeI_6"
   },
   "source": [
    "## Referenzen\n",
    "1. https://cheatography.com/t7l/cheat-sheets/projektseminare-python-3/ - Spickzettel mit wichtigen Definitionen etc.\n",
    "2. https://www.geeksforgeeks.org/python-3-basics/ - An einfachen Beispielen wird Python erklärt. Kann auch gut zum Nachschlagen genutzt werden.\n",
    "3. https://numpy.org/ - Website zum NumPy package - hier findest du die Definitionen aller Funktionen die das Paket beinhaltet.\n",
    "4. https://matplotlib.org/ - Website zum Matplotlib package - hier findest du die Definitionen aller Funktionen die das Paket beinhaltet."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "PythonEinführung.ipynb",
   "provenance": []
  },
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}