FAQ.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zu den Jupyter-Notebooks\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Im Exkurs **\"was mir an python gefällt\"** muss der Code nicht geändert werden. Es reicht, den Code auszuführen mit **\"Strg+Enter\"** und das Ergebnis zu verstehen. Schaut euch den Code an und versucht zu verstehen, was gemacht wird. Einige Anweisungen kennt ihr bereits, andere widerum sind neu. \n",
    "\n",
    "    - Dieser Exkurs soll nur zeigen, zu was python alles fähig ist :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Markdownblöcke mit **\"Strg + enter\"** wieder in den Lesemodus bringen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Download: Linksklick auf das Notebook (z.B. seminar03.ipynb) -> Rechtsklick auf Feld \"Open Raw\" -> Ziel speichern unter \n",
    "- Download von Notebooks mit Firefox!\n",
    "- Öffnen von Jupyter-Notebook geht auch mit Internet-Explorer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Falls ihr einen Codeblock ausführt und ein Stern erscheint: \"In [ * ]\" , bedeutet das, dass der Code gerade ausgeführt wird. Manchmal bleibt das Notebook aber auch einfach hängen, dann benutzt folgende Möglichkeit : Kernel-> restart and clear output. Damit wird das Notebook komplett neu geladen, allerdings müsst ihr die vorherigen Codeblöcke auch neu ausführen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Allgemein"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Bitte in **beide Moodle Kurse** anmelden. Ankündigungen werden dort veröffentlicht! \n",
    "    - Man kann einstellen, dass man Emails bei neuen Forumbeiträgen bekommt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Latex-Fragen-> Tutorium oder Übung. Im Seminar braucht ihr kein Latex."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Pair-Programming** bitte einhalten: **\"nicht gleichzeitig\"** programmieren, sondern **abwechselnd aktiv** sein. Das ist für alle Beteiligten ein Vorteil!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Beispielrechnungen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "40/1.61 \n",
    "#Hier rechnen wir 40km in Meilen um. Das Ergebnis, welches Python ausgibt, bitte nicht für weitere Rechnungen verwenden.\n",
    "# Stattdessen können wir einfach den Term in Klammern benutzen (40/1.61) oder die Rechnung in einer Variable speichern (z.B. Meilen= 40/1.61)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#example\n",
    "#Ein Mann hat eine 40km Fahrradtour in 2h absolivert.  \n",
    "#1. Wieviele Sekunden pro Meter ist er im Durchschnitt gefahren?\n",
    "#2. Mit wieviel Meter pro Minute war er im Durchschnitt unterwegs?\n",
    "#3. Mit wieviel Meilen pro Stunde war er im Durchschnitt unterwegs?\n",
    "#solution:\n",
    "\n",
    "#Zeit in verschiedenen Einheiten\n",
    "Stunden=2\n",
    "Minuten=Stunde*60\n",
    "Sekunden=Minute*60\n",
    "#Strecken in verschiedenen Einheiten\n",
    "Kilometer=10\n",
    "Meter=40*1000\n",
    "Meilen=40/1.61\n",
    "print(\"In einer print()-Funktion kann man\",\"mehrere Zeichenketten und Variablen\", \" durch Kommata trennen und zusammen ausgeben\")\n",
    "print(\"Sekunden pro Meter :\", Sekunden/Meter)\n",
    "print(\"Meter pro Mintue :\", Meter/Minuten)\n",
    "print(\"Meilen pro Stunde :\", Meilen/Stunden, \"Perfekt\")\n",
    "print(\"Meilen pro Stunde :\", (40/1.61)/Stunden, \"Okay\")\n",
    "print(\"Meilen pro Stunde :\", 24.844720496894407/Stunden, \"Bitte nicht gerundete Zahlen übernehmen\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Division von integers \\n\")\n",
    "#Teilen von Ganzzahlen (integers oder int) mit \"/\" (gibt den genauen Wert zurück, typ=float)\n",
    "print(\"Hier dividieren wir mit Hilfe von /: \",2/60,3/2,8/3, sep='\\t')\n",
    "\n",
    "#Teilen von Ganzzahlen (integers oder int) mit \"//\" (gibt den abgerundeten Wert wieder, typ=int)\n",
    "print(\"Hier dividieren wir mit Hilfe von //: \",2//60,3//2,8//3, sep='\\t')\n",
    "\n",
    "print(\"\\n Division von float und integers \\n\")\n",
    "\n",
    "#Teilen von Float und Ganzzahlen (integers oder int) mit \"/\" (gibt den genauen Wert zurück, typ=float)\n",
    "print(\"Hier dividieren wir mit Hilfe von /: \",2/60.0,3.0/2,8.4/3,sep='\\t')\n",
    "\n",
    "#Teilen von Float und Ganzzahlen (integers oder int) mit \"//\" (gibt den abgerundeten Wert wieder, typ=float)\n",
    "print(\"Hier dividieren wir mit Hilfe von //: \",2//60.0,3.0//2,8.4//3,sep='\\t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Bitte diesen Codeblock einfach ausführen\n",
    "\n",
    "print(\"Variablen: \\n\")\n",
    "test_variable=\"Ich gebe erstmal nichts aus, bin aber gespeichert\"\n",
    "testVariable=\"Ich gebe auch nichts aus, bin ebenso gespeichert\"\n",
    "\n",
    "\n",
    "print(\"Nur durch diese Print-Funktion erzeuge ich einen Output: \\n test_variable:\\t\",test_variable,\"! \\n testVariable: \\t\", testVariable)\n",
    "\n",
    "\n",
    "#und ich bin nur eine Kommentarzeile. \n",
    "#Ich gebe nichts aus, kann aber beschreiben, was in diesem Codeblock gemacht wird, ohne den Codeblock auszuführen.\n",
    "#Das hilft anderen, den Code zu verstehen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Bitte diesen Codeblock einfach ausführen\n",
    "\n",
    "print(\"Durch verschiedene Zeichen kann man den Output der Print-Funktion 'verschönern'. \\n\")\n",
    "\n",
    "print('\"\\\\n\" : erzeugt einen Zeilenabsatz \\n' )\n",
    "print(\"Beispiel: \\n\", \"Hello \\n , \\n World \\n ! \")\n",
    "\n",
    "print('\"\\\\t\" : rückt den anschließenden Abstand um einen festen Abstand vor \\n' )\n",
    "print(\"Beispiel: \\t\", \"Hello \\t , \\t World \\t ! \")\n",
    "print(\"\\n\")\n",
    "\n",
    "\n",
    "print('Bis jetzt konnten wir diese Anweisung in einer Zeichenkette ausühren.Man kann der print Funktion auch einen zusätzlichen Befehl übergeben: \"sep=\\\\n\" oder \"sep=\\\\t\"')\n",
    "print(\"Dieser Befehl definiert den Abstand zwischen verschiedenen Anweisungen innerhalb der print-Funktion\")\n",
    "print(\"BeispieL: \",\"Jetzt\", \"werden\", \"wir\", \"zwischen\", \"jeder\", \"Anweisung\", \"einen\", \"Abstand\", \"definieren\", sep=\"\\t\")\n",
    "print(\"BeispieL: \",\"Jetzt\", \"werden\", \"wir\", \"zwischen\", \"jeder\", \"Anweisung\", \"einen\", \"Abstand\", \"definieren\", sep=\"\\n\")\n",
    "\n",
    "\n",
    "#Macht euch den Unterschied zwischen \\t und \\n innerhalb einer Zeichenkette und sep=\"\\n\" klar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Print - Funktion\n",
    "\n",
    "- Die Print-Funktion \"print()\" kann mehrere Argumente entgegennehmen. Das können ganz verschiedene Datentypen sein. Die verschiedenen Argumente müssen jeweils durch Kommata getrennt werden.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "variable1=\"Hello\"\n",
    "variable2=\",\"\n",
    "variable3=\"World\"\n",
    "variable4=\"!\"\n",
    "\n",
    "print(variable1,variable2,\" Zwischendurch kann man auch eine Zeichenkette einbauen, solange man sie durch Kommata von den Variablen trennt\", variable3, variable4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Um die print-Funktion zu formatieren und dadurch übersichtlicher zu gestalten, gibt es einige Hilfsmittel:\n",
    "- \"\\n\" : Backslash + n in einer Zeichenkette (d.h. in Anführungszeichen) ergeben eine neue Zeile\n",
    "- \"\\t\" : Backslash + t in einer Zeichenkette (d.h. in Anführungszeichen) ergeben eine Abstand von mehreren Leerzeichen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "variable1=\"Hello\"\n",
    "variable2=\",\"\n",
    "variable3=\"World\"\n",
    "variable4=\"!\"\n",
    "\n",
    "print('\"\\\\n\" funktioniert folgendermaßen zwischen Variablen:')\n",
    "print(variable1,variable2,\"\\n\",variable3, variable4)\n",
    "print(\"oder auch innerhalb einer Zeichenkette\")\n",
    "print(\"Hello, \\n World !\")\n",
    "\n",
    "\n",
    "print('\"\\\\t\" funktioniert analog.')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Zu guter Letzt kann man noch einen allgemeinen Abstand zwischen den Argumenten definieren, der standardmäßig ein Leerzeichen ist. Dadurch gibt man ganz am Ende einer Print-Funktion folgende Anweisung: sep= \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Standard: ein Leerzeichen : \",variable1,variable2,variable3, variable4)\n",
    "print(\"Variante: kein Zeichen : \",variable1,variable2,variable3, variable4, sep='')\n",
    "print(\"Variante: tab-Abstand : \", variable1,variable2,variable3, variable4, sep='\\t')\n",
    "print(\"Variante: neue Zeile : \", variable1,variable2,variable3, variable4, sep='\\n')\n",
    "print(\"Variante: drei Punkte (man kann jegliches Zeichen angeben) : \", variable1,variable2,variable3, variable4, sep='...')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zahlen - float"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- WICHTIG: Bei Ankündigung von Michel: Bitte Jupyter Notebooks durcharbeiten oder wenigstens versuchen. Ich verstehe, dass man nicht immer alle Übungen alleine schafft, aber zumindest die Theorie kann man mit seinem Partner durcharbeiten. \n",
    "- Falls Hilfe benötigt wird -> Michel: Email oder vorbeikommen | Tutorium Dienstags"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Gleitkommazahlen (floats) immer mit \".\" statt \",\" angeben -> 29.99 statt 29,99"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Gleitkommazahl durch Punkt getrennt -> RICHTIG\n",
    "\n",
    "preis=29.99\n",
    "print(preis)\n",
    "print(type(preis))\n",
    "# python erkennt die Zahl und gibt die Zahl wieder. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Gleitkommazahl durch Komma getrennt -> FALSCH\n",
    "\n",
    "preis=29,99\n",
    "print(preis)\n",
    "type(preis)\n",
    "# Python erkennt zwei Zahlen, die es in einem Tupel speichert."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importieren von Modulen und Bibliotheken"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Stellen Datentypen oder Funktionen für alle Python-Programme bereit\n",
    "- Syntax: `import module` \n",
    "- Konvention: Steht **immer am Anfang des Codes**\n",
    "- Beispiel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import turtle\n",
    "import csv\n",
    "\n",
    "#hier steht Code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Turtle Modul\n",
    "\n",
    "- Dokumentation mit allen turtle-Methoden: https://docs.python.org/3/library/turtle.html\n",
    "- Im Idealfall sollte in jedem Codeblock die folgenden Anweisungen stehen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Zuerst wird das Modul turtle importiert\n",
    "import turtle\n",
    "\n",
    "\n",
    "#hier steht euer Code\n",
    "\n",
    "\n",
    "\n",
    "# Um ein Arbeiten mit turtle und Jupyter-Notebook zu ermöglichen, müssen wir diese beiden Befehle am Ende des Blocks schreiben\n",
    "\n",
    "turtle.mainloop()\n",
    "turtle.bye()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Zuerst wird das Modul turtle importiert\n",
    "import turtle\n",
    "\n",
    "#Hier lernen wir die Funktionen up(), down() und fd() kennen\n",
    "\n",
    "otto=turtle.Turtle()\n",
    "\n",
    "def line(t):\n",
    "    t.fd(50)\n",
    "    t.up()\n",
    "    t.fd(50)\n",
    "    t.down()\n",
    "    t.fd(50)\n",
    "    t.fd(50)\n",
    "    t.up()\n",
    "    t.fd(50)\n",
    "    t.fd(50)\n",
    "    t.down()\n",
    "    t.fd(50)\n",
    "# Um ein Arbeiten mit turtle und Jupyter-Notebook zu ermöglichen, müssen wir diese beiden Befehle am Ende des Blocks schreiben\n",
    "line(otto)\n",
    "turtle.mainloop()\n",
    "turtle.bye()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kommentare -> commit -> nicht zu bdeuten"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import turtle\n",
    "\n",
    "otto=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen otto zugewiesen\n",
    "anna=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen anna zugewiesen\n",
    "telmo=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen telmo zugewiesen\n",
    "\n",
    "#Hier lernen wir die Funktionen shape(), color(), fd() und lt() kennen\n",
    "\n",
    "def square(t):    \n",
    "    t.shape('turtle') #wir geben der turtle t die Form einer Schildkröte\n",
    "    t.color(\"purple\",\"red\") #wir färben den zurückgelegten Weg lila (erstes Argument), die Schildkröte rot (zweites Argument)\n",
    "    for k in range(4): #schleife (4 Aufrufe): unsere turtle läuft in jedem Aufruf zuerst gerade aus und wendet sich dann um 90° nach links.\n",
    "        t.fd(100)\n",
    "        t.lt(90)       \n",
    "\n",
    "square(otto) #wir rufen square mit der turtle namens otto auf. Wir könnten aber genauso anna oder telmo nehmen\n",
    "\n",
    "turtle.mainloop()\n",
    "turtle.bye()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import turtle\n",
    "\n",
    "otto=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen otto zugewiesen\n",
    "anna=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen anna zugewiesen\n",
    "telmo=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen telmo zugewiesen\n",
    "\n",
    "#Hier lernen wir die Funktionen color(),begin_fill(), end_fill(), fd() und lt() kennen\n",
    "\n",
    "def square(t):    \n",
    "    t.color(\"purple\") #Falls nur ein Argument in color()--> Schildkröte und Weg haben dieselbe Farbe. Wir färben die Schildkröte und die Fläche, die wir einfärben wollen, lila\n",
    "    \n",
    "    t.begin_fill() # wir beginnen die Fläche, die unsere turtle läuft, zu färben\n",
    "    for k in range(4): #schleife (4 Aufrufe): unsere turtle läuft in jedem Aufruf zuerst gerade aus und wendet sich dann um 90° nach links.\n",
    "        t.fd(100)\n",
    "        t.lt(90)       \n",
    "    t.end_fill() # wir beenden das Einfärben der Fläche\n",
    "    \n",
    "square(anna) #wir rufen square mit der turtle namens anna auf. Wir könnten aber genauso otto oder telmo nehmen\n",
    "\n",
    "turtle.mainloop()\n",
    "turtle.bye()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import turtle\n",
    "from random import randint\n",
    "\n",
    "otto=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen otto zugewiesen\n",
    "anna=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen anna zugewiesen\n",
    "telmo=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen telmo zugewiesen\n",
    "\n",
    "#Hier lernen wir die Funktionen shape(), stamp(), color(), colormode() und fd() kennen\n",
    "\n",
    "colors=['red','purple','blue','yellow','orange']\n",
    "def line(t):    \n",
    "    turtle.colormode(255)\n",
    "    t.shape('turtle')\n",
    "    t.stamp() #wir machen einen Stempel an dieser Stelle von unserem turtle\n",
    "    t.fd(100)\n",
    "    turtle.colormode(255) # um RGB-Farben anzuwenden, muss man vorher diesen Colormode aktivieren\n",
    "    t.color(randint(0,255),randint(0,255),randint(0,255)) #Jetzt können wir Farben in RGB-Werten angeben (--> mehr Möglichkeiten)\n",
    "    t.stamp()  #wir machen einen Stempel an dieser Stelle von unserem turtle\n",
    "    t.fd(100)\n",
    "    t.color(randint(0,255),randint(0,255),randint(0,255))\n",
    "    t.stamp() #wir machen einen Stempel an dieser Stelle von unserem turtle\n",
    "    t.fd(100)\n",
    "    t.color(randint(0,255),randint(0,255),randint(0,255))\n",
    "    t.stamp() #wir machen einen Stempel an dieser Stelle von unserem turtle\n",
    "    t.fd(100)\n",
    "    t.color(randint(0,255),randint(0,255),randint(0,255))\n",
    "\n",
    "    \n",
    "line(telmo) #wir rufen line mit der turtle namens telmo auf. Wir könnten aber genauso anna oder otto nehmen\n",
    "\n",
    "turtle.mainloop()\n",
    "turtle.bye()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import turtle\n",
    "\n",
    "otto=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen otto zugewiesen\n",
    "anna=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen anna zugewiesen\n",
    "telmo=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen telmo zugewiesen\n",
    "\n",
    "#Hier lernen wir die Funktionen circle() und shapesize() kennen\n",
    "\n",
    "def circle(t,r): \n",
    "    t.shape('turtle') \n",
    "    t.shapesize(10) # wir ändern die Größe unserer turtle\n",
    "    t.circle(r) #wir malen einen Kreis mit Radius r\n",
    "    \n",
    "circle(telmo,100) #wir rufen line mit der turtle namens telmo auf. Wir könnten aber genauso anna oder otto nehmen\n",
    "\n",
    "turtle.mainloop()\n",
    "turtle.bye()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funktionen\n",
    "\n",
    "Funktion funktionieren in Python wie mathematische Funktionen aus der Schule: \n",
    "\n",
    "Stellt euch die Funktion f(x,y)=x*y vor. In Python definieren wir sie wie folgt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x,y):\n",
    "    return x*y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jetzt haben wir die Funktion zwar definiert, aber sie gibt noch kein Ergebnis zurück. Das passiert nur, wenn wir die Funktion aufrufen. \n",
    "\n",
    "Um die Funktion aufzurufen, müssen wir die Parameter x und y explizit angeben, z.B. x=5 und y=3.  \n",
    "\n",
    "In der Schule haben wir früher Folgendes geschrieben: f(5,3)=5*3=15. \n",
    "\n",
    "In Python machen wir nichts anderes, nur das Berechnen überlassen wir python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Es gibt verschiedene Wege: \\n \\n\")\n",
    "\n",
    "print(\"Lösung von f(x=5,y=3) : \", f(x=5,y=3)) \n",
    "print(\"\\nAlternative 1:\")\n",
    "print(\"Lösung von f(5,3) : \", f(5,3)) \n",
    "print(\"\\nAlternative 2:\")\n",
    "variable_x=5\n",
    "variable_y=3\n",
    "print(\"Lösung von f(variable_x, variable_y) : \", f(variable_x, variable_y)) "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Fazit: Um eine Funktion aufzurufen und ein Ergebnis herauszubekommen, reicht es nicht, die Funktion zu definieren. Sie muss anschließend aufgerufen werden. Die Parameter müssen explizit angegeben werden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Browser-Einstellungen für Jupyter-Notebook\n",
    "\n",
    "Jupyter-Notebook wird immer in dem Browser geöffnet, der auf dem Computer als Standardbrowser festgelegt ist.\n",
    "Im PC-Pool ist das zur Zeit der Internet-Explorer und wir können das leider nicht ändern.\n",
    "Dadurch funktionieren manche Shortcuts leider nicht.\n",
    "\n",
    "Auf euren PC's zu Hause könnt ihr es aber einfach ändern: \n",
    "\n",
    "(Wir empfehlen Firefox als Standardbrowser)\n",
    "\n",
    "macOS:\n",
    "\n",
    "    1. Öffnen sie die Systemeinstellungen.\n",
    "    2. Klicken Sie auf „Allgemein“.\n",
    "    3. Wählen Sie unter „Standard-Webbrowser“ den gewünschten Browser aus.\n",
    "\n",
    "Ubuntu Linux:\n",
    "\n",
    "    1. Öffnen Sie die System Settings.\n",
    "    2. Klicken Sie auf „Applications“.\n",
    "    3. Wählen Sie in der linken Spalte „Default Applications“ aus.\n",
    "    4. Klicken Sie in der Spalte rechts davon auf „Web Browser“.\n",
    "    5. Wählen Sie „in the following browser:“ aus.\n",
    "    6. Wählen Sie den gewünschten Browser aus.\n",
    "\n",
    "Windows:\n",
    "\n",
    "    1. Öffnen Sie die Systemsteuerung.\n",
    "    2. Klicken Sie auf „Standardprogramme“.\n",
    "    3. Klicken Sie auf „Standardprogramme festlegen“.\n",
    "    4. Klicken Sie in der Liste auf den gewünschten Browser.\n",
    "    5. Klicken Sie dann auf „Dieses Programm als Standard festlegen“.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tipps und Tricks \n",
    "- Einrücken durch die \"Tabulatortaste\", um die richtige Formatierung einfach zu bekommen (bei Definitionen von Funktionen, for- oder while-Schleifen, if-Bedingungen, etc.)\n",
    "- Beispiel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def example():\n",
    "    i=0\n",
    "    while i <= 5:\n",
    "        if i<1:\n",
    "            print(\"Mit der tab-Taste kann man immer 'eins weiter' einrücken.\")\n",
    "        elif i==5:\n",
    "            print(\"Mit 'tab' und 'shift' gleichzeitig rückt man 'eins' wieder nach hinten.\")\n",
    "        i=i+1\n",
    "         \n",
    "example()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Alternativer Python-Kurs für Interessierte: https://automatetheboringstuff.com/"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python",
   "pygments_lexer": "ipython3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}