ALICE_RAA_Einleitung.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ein Jupyter Notebook besteht aus mehreren Zellen, die einzeln ausgeführt werden können. \n",
    "\n",
    "Eine Zelle kann mit Strg (Shift) + Enter oder über den Menüpunkt \"Cell->Run Cell\" ausgeführt werden, nachdem sie mit der Maus markiert worden ist.\n",
    "\n",
    "Das komplette Notebook kann über den Menüpunkt \"Cell->Run All\" ausgeführt werden.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Übung:\n",
    "\n",
    "Im Feld ist eine Variable 'b' bereits definiert und hat einen Wert von '5' zugewiesen bekommen. Die Ausgabe erfolgt über print() und gibt den Inhalt der Variable 'b' aus. Über print(type(b)) kann man herausfinden, welchen Datentyp Python der Variable zugwiesen hat.\n",
    "\n",
    "Nachdem ihr den Code ausgeführt habt, sollt ihr folgende Aufgaben bearbeiten und den existierenden Zeilen in der Zelle anhängen:\n",
    "\n",
    "- Definiere eine Varibale 'a' und setze einen Zahlenwert\n",
    "\n",
    "- Definiere eine Variable 'text' und setze eine Zeichenkette\n",
    "\n",
    "- Definiere 'c' als Produkt von 'a' und 'b' und gebe das Ergebnis danach über print(c) aus.\n",
    "\n",
    "- Was passiert bei?\n",
    "    - print(2 * a)\n",
    "    - print(2 * text)\n",
    "\n",
    "- Was passiert bei folgenden Befehlen? (nutzt copy & paste)\n",
    "    - print(a + b)\n",
    "    - print('a+b')\n",
    "    - print(str(a) + '+' + str(b))\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "outputs": [],
   "source": [
    "b = 5\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "b = 5\n",
    "print(b)\n",
    "\n",
    "a = 3.2\n",
    "\n",
    "text = \"Hallo Welt!\"\n",
    "\n",
    "c = a * b\n",
    "\n",
    "print(c)\n",
    "\n",
    "print(2 * a)\n",
    "print(2 * text)\n",
    "\n",
    "print(a+b)\n",
    "print('a+b')\n",
    "print(str(a)+'+'+str(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# if else\n",
    "\n",
    "Über eine if Abfrage können ein oder mehrere Bedingungen geprüft werden, unter denen etwas bestimmtes passieren soll. \n",
    "\n",
    "Wenn die Bedingung erfüllt ist (-> Bedingung ist wahr), wird der Code direkt nach dem 'if' ausgeführt.\n",
    "\n",
    "Wenn die Bedingung nicht erfüllt ist (-> erste Bedingung ist unwahr), kann man über den 'elif' Befehl weitere Bedingungen prüfen.\n",
    "\n",
    "Wenn keine weitere explizite Bedingung geprüft werden soll (-> Bedingung/en ist/sind unwahr), kann über den Befehl 'else' ein alternativer Code ausgeführt werden (genau dann, wenn die geprüfte Bedingung sich als unwahr herausstellt).\n",
    "\n",
    "## Übung:\n",
    "Führe den Code aus der folgenden Zelle aus und variiere anschließend die Variablen a und b, um alle Möglichkeiten durchzuprobieren:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "if a>b:\n",
    "    print('a ist größer als b')\n",
    "elif a==b:\n",
    "    print('a und b sind gleichgroß')\n",
    "else:\n",
    "    print('b ist größer als a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# definiere a und b neu:\n",
    "\n",
    "a = 4\n",
    "b = 4\n",
    "\n",
    "if a>b:\n",
    "    print('a ist größer als b')\n",
    "elif a==b:\n",
    "    print('a und b sind gleichgroß')\n",
    "else:\n",
    "    print('b ist größer als a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Übung:\n",
    "\n",
    "Mit Hilfe von \n",
    "\n",
    "eingabe = input(\"Bitte um Tastatureingabe, mit Enter bestätigen: \")\n",
    "\n",
    "frage nach zwei Tastatureingaben und prüfe mit einer if/else Bedingung, ob die Eingaben gleich sind.\n",
    "\n",
    "Wenn ja, gebe \"Gleiche Eingaben\" aus, sonst \"Ungleich\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "outputs": [],
   "source": [
    "eingabe = input(\"Bitte um Tastatureingabe, mit Enter bestätigen: \")\n",
    "eingabe2 = input(\"Bitte um Tastatureingabe, mit Enter bestätigen: \")\n",
    "\n",
    "print(eingabe, eingabe2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "eingabe = input(\"Bitte um Tastatureingabe, mit Enter bestätigen: \")\n",
    "eingabe2 = input(\"Bitte um Tastatureingabe, mit Enter bestätigen: \")\n",
    "\n",
    "print(eingabe, eingabe2)\n",
    "\n",
    "if( eingabe == eingabe2):\n",
    "    print(\"Gleiche Eingaben\")\n",
    "else:\n",
    "    print(\"Ungleich\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# for loop\n",
    "\n",
    "Mit einer for-loop können Befehle beliebig oft wiederholt werden.\n",
    "\n",
    "## Übung:\n",
    "\n",
    "Probiere den folgenden Code aus\n",
    "\n",
    "    for i in range (0,15):\n",
    "        print(i**2)\n",
    "\n",
    "Was passiert? Was macht 'range(0,15)'?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "for i in range (0,15):\n",
    "       print(i**2)\n",
    "\n",
    "print('range:')\n",
    "x = range(0,15)\n",
    "print(len(x))\n",
    "print(x[0])\n",
    "print(x[1])\n",
    "print(x[14])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Übung:\n",
    "\n",
    "Schreibe eine Verbindung aus einer for Schleife und einem if else Befehl, der die Quadratzahlen von 0 bis 14 auflistet und zusätzlich einen print ausgibt, ob die Zahl größer oder kleiner als 100 ist. Achte dabei auf die richtigen Einrückungen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "for i in range(0,15):\n",
    "    quadrat = i**2\n",
    "    if( quadrat > 100 ):\n",
    "        print(str(quadrat) + \" ist größer als 100!\")\n",
    "    elif ( quadrat < 100):\n",
    "        print(str(quadrat) + \" ist kleiner als 100!\")\n",
    "    else:\n",
    "        print(str(quadrat) + \" ist exakt 100!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listen:\n",
    "\n",
    "Eine Liste ist eine Aneinanderreihung von gleichen Datentypen, die gemeinsam oder auch einzeln aufgerufen werden können. \n",
    "Für die Angabe der Position innerhalb eines Arrays wird immer bei 0 angefangen zu zählen. \n",
    "\n",
    "Die Position wird mit einer eckigen Klammer angegeben. Beispielhaft im unteren Code dargestellt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste = [1, 1, 2, 3, 5, 8, 13, 21]\n",
    "\n",
    "print(liste)\n",
    "\n",
    "print(liste[6])\n",
    "\n",
    "liste[5] = 432\n",
    "\n",
    "print(liste)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listen können auch beliebig oft geschachtelt werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste2 = [ [1, 24, 5, 873, 37, 2] , [23, 6, 77, 84, 100, 22] ]\n",
    "\n",
    "print(liste2)\n",
    "\n",
    "print(liste2[0][2])\n",
    "\n",
    "liste2[0][3]=10\n",
    "\n",
    "print(liste2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Übung:\n",
    "\n",
    "- Definiere eine Liste 'tage' und füge alle Wochentage hinzu\n",
    "- Was passiert bei folgenden Befehlen:\n",
    "    - print(tage[0:3])\n",
    "    - print(tage[-3:])\n",
    "    \n",
    "- Schreibe eine for-loop und gebe alle Wochentage aus\n",
    "    - wenn ein Tag auf 'tag' endet, gib \"...endet auf tag aus!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "tage = [\"Montag\", \"Dienstag\", \"Mittwoch\", \"Donnerstag\", \"Freitag\", \"Samstag\", \"Sonntag\"]\n",
    "\n",
    "print(tage[0:3])\n",
    "print(tage[-3:])\n",
    "\n",
    "for z in tage:\n",
    "    print(z)\n",
    "    if( z[-3:] == \"tag\"):\n",
    "        print(\"...endet auf tag!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotten von Graphen, Histogrammen & Co:\n",
    "\n",
    "Folgende Pakete werden in der Regel benötigt, welche in der nächsten Zelle geladen werden können:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mit diesen Paketen können nun verschiedenste graphische Darstellungen erzeugt und dargestellt werden. \n",
    "\n",
    "In diesem Beispiel werden 6 Werte für die x-Achse gegenüber 6 Werten in der y-Achse aufgetragen. \n",
    "\n",
    "Dabei kann durch den Befehl fmt die Farbe und Art des Punktes verändert werden.<br>\n",
    "r=rot<br>\n",
    "g=grün<br>\n",
    "y=gelb<br>\n",
    "m=magenta<br>\n",
    "k=schwarz<br>\n",
    "c=cyan<br>\n",
    "w=weiß<br>\n",
    "b=blau<br>\n",
    "'.' \tpoint marker<br>\n",
    "',' \tpixel marker<br>\n",
    "'o' \tcircle marker<br>\n",
    "'v' \ttriangle_down marker<br>\n",
    "'^' \ttriangle_up marker<br>\n",
    "'<' \ttriangle_left marker<br>\n",
    "'>' \ttriangle_right marker<br>\n",
    "'1' \ttri_down marker<br>\n",
    "'2' \ttri_up marker<br>\n",
    "'3' \ttri_left marker<br>\n",
    "'4' \ttri_right marker<br>\n",
    "'s' \tsquare marker<br>\n",
    "'p' \tpentagon marker<br>\n",
    "'*' \tstar marker<br>\n",
    "'h' \thexagon1 marker<br>\n",
    "'H' \thexagon2 marker<br>\n",
    "'+' \tplus marker<br>\n",
    "'x' \tx marker<br>\n",
    "'D' \tdiamond marker<br>\n",
    "'d' \tthin_diamond marker<br>\n",
    "'|' \tvline marker<br>\n",
    "'_' \thline marker<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1, 2, 3, 4, 5, 6]\n",
    "y = [1, 4, 9, 16, 25, 36]\n",
    "\n",
    "plt.errorbar(x, y, xerr=0.5, yerr=2, fmt='ro')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mit Numpy können auch Funktionen geplottet werden. Im nächsten Beispiel werden gleichmäßig verteilt 50 Werte in einem Bereich von 0 bis 2*Pi erstellt und dann die Funktion sin(x) geplottet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.linspace(0, 2 * np.pi, 50, endpoint=True) # Plotten von 0 bis 2*Pi\n",
    "F = np.sin(X)\n",
    "\n",
    "plt.plot(X,F, label='Sinus')\n",
    "plt.legend(loc='upper right')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Auch Histogramme können ganz einfach geplottet werden. \n",
    "\n",
    "Dazu werden hier im Beispiel 100000 zufällige Werte aus einer Normalverteilung genommen und dann die Anzahl der jeweiligen Werte aufgetragen. \n",
    "Dabei werden die Werte in Bins gespeichert. \n",
    "Die Anzahl der Bins kann eingestellt werden, wodurch sich die Breite der Bins automatisch zu (Maxwert-Minwert)/Binzahl ergibt.\n",
    "\n",
    "- Führe das Programm aus\n",
    "    - Erhöhe 'size' jeweils um den Faktor 10 - was passiert? Wann kannst du die typische Glockenkurve erkennen?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gaussian_numbers = np.random.normal(size=10)\n",
    "bins = 100\n",
    "\n",
    "plt.hist(gaussian_numbers, bins)\n",
    "\n",
    "plt.title(\"Gauß-Histogramm\")\n",
    "plt.xlabel(\"Wert\")\n",
    "plt.ylabel(\"Häufigkeit\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}