Update Intro_pre.ipynb, Kontrollstrukturen_pre.ipynb,...

Update Intro_pre.ipynb, Kontrollstrukturen_pre.ipynb, add_material/ewpwicht_homework.png, add_material/ewpwicht_programming.png, add_material/ewpwicht.png, add_material/ewpwicht_video.png files

Intro_pre.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img src=\"./add_material/headerCD.png\">\n",
+    "\n",
+    "# Einführung in wissenschaftliches Programmieren\n",
+    "\n",
+    "\n",
+    "Dozenten: Dr. Martin Bracke, Matthias Andres\n",
+    "\n",
+    "Kontakt: ewp@mathematik.uni-kl.de \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%autosave 0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Wegweiser durch die Vorlesung\n",
+    "<img src=\"./add_material/ewpwicht.png\" width=\"40px\" align=\"left\"> Dieses Symbol markiert wichtige Informationen."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img src=\"./add_material/ewpwicht_programming.png\" width=\"50px\" align=\"left\"> Wenn Ihr dieses Symbol seht, dürft Ihr selbst aktiv werden und einen kleinen Selbsttest lösen."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img src=\"./add_material/ewpwicht_homework.png\" width=\"50px\" align=\"left\"> \n",
+    "Dieses Symbol markiert zusätzliche Inhalte wie z.B. Hintergrundinformationen. Diese sind natürlich interessant, aber es bietet sich an (gerade für die Programmieranfänger), diese Inhalte beim ersten Durchlesen erstmal zu überspringen. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a href=\"https://vcm.uni-kl.de/Panopto/Pages/Viewer.aspx?id=6217dc46-aa1c-449e-bf57-ab9c013ca8f3\">  <img src=\"./add_material/ewpwicht_video.png\" width=\"100px\" align=\"left\"> </a> Hinter diesem Symbol verbirgt sich ein Link auf externes Videomaterial - Probier es mal aus und klicke auf das Symbol!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Grundlagen in Python\n",
+    "In diesem Notebook lernen wir die ersten Grundlagen in Python kennen:\n",
+    "* Allgemeine Infos zu Python: Was ist das und wie verwende ich es?\n",
+    "* Allgemeine Syntax in Python\n",
+    "* Was ist eine Variable?\n",
+    "* Programmablaufpläne\n",
+    "\n",
+    "Hinweis: Diese Vorlesung basiert unter anderem auf der Arbeit von J. R. Johansson. Einige Inhalte wurden zum Teil direkt übernommen bzw. für die Vorlesung angepasst. Wir verweisen auf\n",
+    "* https://github.com/jrjohansson/scientific-python-lectures\n",
+    "* https://creativecommons.org/licenses/by/3.0/"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Was ist Python?\n",
+    "Man unterscheidet zwischen **interpretierten** und **kompilierten** Programmiersprachen (http://www.mnn.ch/abc/html/Programm_3.html):\n",
+    "* Interpretiert (Python, Matlab, R, ...): Der Computer nimmt den Quellcode und geht Zeile für Zeile vor, in dem er jede Zeile übersetzt und ausführt. Diesen Vorgang nennt man interpretieren.\n",
+    "* Kompiliert (C, Fortran, Java, ...): Der Computer nimmt den Quellcode und übersetzt ihn als Ganzes (kompilieren). Dabei entsteht ein maschinenlesbarer Code. Dieser kann dann später ausgeführt werden.\n",
+    "\n",
+    "\n",
+    "Python ist eine interpretierte höhere Programmiersprache. In der Vorlesung verwenden wir **Python3**.\n",
+    "* Vorteile\n",
+    "    * Die benötigte Zeit zur Entwicklung, Fehlersuche (Debugging) und Pflege des Codes ist vergleichsweise kurz.\n",
+    "    * Durch den Design der Programmiersprache wird eine gute Programmierpraxis nahegelegt (Modularisierung, objektorientiertes Programmieren, Wiederverwendung von Code, Dokumentation)\n",
+    "    * Es besteht eine Vielzahl an Bibliotheken für verschiedenste Anwendungsgebiete.\n",
+    "* Nachteile\n",
+    "    * Die Zeit zur Ausführung eines in Python geschriebenen Programms kann (wesentlich) langsamer sein als ein äquivalentes Programm in einer kompilierten Programmiersprache (z.B. C oder Fortran).\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Wie installiere ich Python auf meinem Computer?\n",
+    "In dieser Vorlesung verwenden wir Python3. \n",
+    "Es gibt verschiedene Möglichkeiten, Python auf dem eigenen Computer zu installieren. Wir empfehlen die Installation mit Hilfe von Anaconda https://www.anaconda.com/ .\n",
+    "\n",
+    "Hier findet Ihr eine kurze Anleitung zur Installation des Anaconda-Navigators unter Linux:\n",
+    "<a href=\"https://vcm.uni-kl.de/Panopto/Pages/Viewer.aspx?id=72591aef-fbd6-4496-976a-ab9c013e0aff\">  <img src=\"./add_material/ewpwicht_video.png\" width=\"100px\" align=\"center\"> </a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "## Wie führe ich Python Code aus?\n",
+    "Es gibt verschiedene Möglichkeiten, Python Code auszuführen.\n",
+    "### 1) Python Interpreter: Ausführung in der Kommandozeile\n",
+    "Der *Python Interpreter* ist ein Programm welches einen Python Code einliest und ausführt. Hier gibt es zwei Möglichkeiten:\n",
+    "Bei Eingabe von **python** (ggf. **python3**) in der Kommandozeile öffnet sich die sogenannte **Python Konsole** - alle Befehle, die man jetzt in diesem Fenster eingibt, werden vom Python Interpreter verarbeitet. Hier kann man nun einzelne Befehle nacheinander eingeben und durch drücken der Return-Taste direkt ausführen lassen. Dies bietet sich für kleinere Rechnungen oder zum Experimentieren an.\n",
+    "\n",
+    "<img src=\"./add_material/ScreenshotPythonKonsole.png\" width=\"800px\"> *Ausführen eines Hello-World Programms in der Python Konsole.*\n",
+    "\n",
+    "Längere Codes speichert man in der Regel in Textdateien mit der Endung **.py** ab. Diese nennen wir **Python Skripte**. Diese kann man mit Hilfe des Python Interpreters in der Kommandozeile ausführen. Hierzu muss entweder der vollständige Pfad zur Datei angegeben werden, sofern die Datei nicht im aktuellen Arbeitsverzeichnis der Kommandozeile liegt. Das aktuelle Arbeitsverzeichnis kann man sich mit Hilfe des Kommandos **pwd** in der Kommandozeile ausgeben lassen.  Die Datei **hello_world.py** ist im beiliegenden Ordner **add_material** hinterlegt. \n",
+    "\n",
+    "<img src=\"./add_material/ScreenshotPythonFromCommandLine.png\" width=\"800px\"> *Aufruf eines Hello-World Python Skripts in der Kommandozeile.*\n",
+    "\n",
+    "Man kann externen Python Code auch von der Python Konsole aus ausführen. Ein entscheidender Unterschied hier ist, dass ggf. Ergebnisse aus vorherigen Rechnungen noch im Arbeitsspeicher hinterlegt sein können. Dies kann zu Fehlern bei der Entwicklung von Code führen (s. unten).\n",
+    "\n",
+    "<img src=\"./add_material/ScreenshotPythonKonsoleExec.png\" width=\"800px\"> *Aufruf eines Hello-World Python Skript in der Python Konsole.*\n",
+    "\n",
+    "### 2) IPython\n",
+    "IPython ist eine andere Version der Standard Python Konsole, die noch mehr Möglichkeiten der Interaktion bietet. \n",
+    "\n",
+    "<img src=\"./add_material/ScreenshotIpythonKonsole.png\" width=\"800px\"> *Ausführen eines Hello-World Programms in der IPython Konsole.*\n",
+    "\n",
+    "### 3) Integrierte Entwicklungsumgebung (IDE) (Alltag in den Übungen)\n",
+    "Eine Integrierte Entwicklungsumgebung ist eine Benutzeroberfläche, welche verschiedene Werkzeuge zur Entwicklung von Programmen bereitstellt, z.B. einen geeigneten Texteditor und eine Schnittstelle, um Code direkt auszuführen und die Ergebnisse weiterzuverarbeiten. Im späteren Verlauf der Vorlesung werden wir eine Möglichkeit kennenlernen, mit Hilfe einer IDE systematisch Fehler im Code zu finden (Debugging). Für Python gibt es viele verschiedene IDEs. Zum Einstieg, vor allem für den späteren Umstieg auf Matlab, eignet sich **Spyder** (https://www.anaconda.com/download/). In Spyder findet man voreingestellt ein Fenster mit einer IPython Konsole.\n",
+    "<img src=\"./add_material/ScreenshotSpyder.png\">\n",
+    "\n",
+    "### 4) IPython / Jupyter Notebooks (Alltag in der Vorlesung)\n",
+    "Notebooks (Endung **.ipynb**) werden über einen web browser als HTML bereitgestellt und bieten die Möglichkeit, sowohl Quelltext in einer IPythonumgebung auszuführen und die Ergebnisse anzeigen zu lassen als auch formatierten Text anzuzeigen. Dies eignet sich insbesondere für die Lehre und zur anschaulichen und interaktiven Präsentation von Ergebnissen. Durch die Verwendung von IPython kann dem Nutzer die Möglichkeit zur Interaktion geboten werden - er kann den vorliegenden Code selbst verändern und sich das Ergebnis direkt ausgeben lassen. Das Dokument, welches dieses Vorlesung beinhaltet, ist ebenfalls ein Notebook.\n",
+    "\n",
+    "<img src=\"./add_material/ScreenshotNotebook.png\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Allgemeine Syntax\n",
+    "* Das Zeichen # definiert den Rest der Zeile als **Kommentar**\n",
+    "* Code-Blöcke werden durch **Einrücken** definiert (PEP8 Standard: 4 Leerzeichen)\n",
+    "* Befehle, auf die ein eingerückter Befehlsblock folgt, enden immer auf **:**\n",
+    "* Ausgabe in der Konsole: **print()**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = 3.0\n",
+    "b = 0 #  Das ist ein Kommentar\n",
+    "#  Das ist ein Kommentar\n",
+    "if (0.2 < a):\n",
+    "    b = 1\n",
+    "    print(a)\n",
+    "    print(\"Winter is coming!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Was ist eine Variable?\n",
+    "Eine ausführliche Übersicht über Variablen findet man z.B. unter folgendem Link:\n",
+    "https://realpython.com/python-variables/\n",
+    "\n",
+    "In Python stellen Variablen  **symbolische Namen** dar, die auf eine bestimmte Stelle im Speicher verweisen. Was genau an dieser Stelle im Speicher vorzufinden ist, z.B. eine ganze Zahl, eine Zeichenkette, eine Funktion, eine selbstgeschriebene Klasse, etc., spielt hier keine Rolle.\n",
+    "\n",
+    "<img src=\"./add_material/PythonMemory.png\" width=\"200px\">\n",
+    "\n",
+    "Wir schauen uns das folgende Beispiel an:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n = 10"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Bei der Ausführung der obigen Zeile, führt der Python Interpreter folgende Schritte durch:\n",
+    "* Erzeuge ein ganzzahliges Objekt im Speicher (wie auch immer das intern funktioniert).\n",
+    "* Gib diesem ganzzahligen Objekt den Wert 10.\n",
+    "* Erzeuge eine Referenz auf dieses Objekt im Speicher und nenne sie **n**.\n",
+    "\n",
+    "Wir können nun mit Hilfe der Variablen auf den Inhalt des Speichers zugreifen. Je nach Datentyp bietet uns Python hier verschiedene Möglichkeiten, die wir im Laufe der Vorlesung kennen lernen werden. Wir werden im Kapitel **Datenstrukturen** noch näher auf verschiedene Objekttypen in Python eingehen. Existiert eine Zeichenkette (String) als Repräsentation für unser Objekt (bei Zahlen intuitiv, bei selbstgeschriebenen Objekten teilweise schwierig), können wir diese mit Hilfe des print Befehls auf dem Bildschirm ausgeben lassen."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(n)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Für den Moment merken wir uns:\n",
+    "\n",
+    "<img src=\"./add_material/ewpwicht.png\" width=\"50px\" align=\"left\"> **In Python stellen wir uns Variablen als Namen vor, die an ein bestimmtest Objekt im Speicher 'angeheftet' sind.**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Das Gleichheitszeichen wird hier als Zuweisung verwendet, d.h. die Variable auf der linken Seite verweist nun auf das Objekt, das auf der rechten Seite erzeugt bzw. auf das auf der rechten Seite verwiesen wird. Dies mag am Anfang verwirrend sein, wenn man zum ersten Mal einen Ausdruck wie in der nächsten Zelle sieht:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n = n + 10"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Zu Beginn der obigen Zeile verweist die Variable n auf ein Integer Objekt (d.h. eine ganze Zahl). Dann wird zunächst ein neues Integer Objekt im Speicher mit dem Wert n + 10 erzeugt. Anschließend wir die Variable n umdefiniert, sodass sie nun auf dieses neue Objekt verweist."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(n)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Programmablaufpläne\n",
+    "Ein Computerprogramm ist im wesentlichen eine Abfolge von Anweisungen, die vom Computer ausgeführt werden können (hier mit Hilfe des Python Interpreters).\n",
+    "Zum erfolgreichen Lösen eines Problems mit Hilfe einer Programmiersprache ist es neben dem Erlernen der Syntax (welche Vokabeln und Konzepte stellt mir eine Programmiersprache zur Verfügung, meine Lösungsstrategie zu formulieren) wichtig, sich vorab Gedanken über die Struktur eines Programms zu machen. Insbesondere ist es bei größeren Problemstellungen wichtig, diese in einzelne, kleinere Teilprobleme zu zerlegen. Hier helfen Programmablaufpläne. Die wichtigsten Bausteine listen wir hier  auf:\n",
+    "\n",
+    "* <img src=\"./add_material/Start.png\" width=\"80px\" align=\"left\"> Jedes Programm besitzt einen Anfang. An dieser Stelle existieren keine Variablen im Arbeitsspeicher. Wir können nur auf Variablen zugreifen, die wir nach dem Start und vor dem aktuellen Zeitpunkt definiert haben. In Python ist der Start eines Programms durch den Aufruf eines Python Skripts mit Hilfe des Python Befehls in der Kommandozeile, oder durch den Start der Python Konsole definiert.\n",
+    "\n",
+    "<img src=\"./add_material/ewpwicht.png\" width=\"25px\" >  **Vorsicht**: In interaktiven Umgebungen wie der Python Konsole können wir Python Code ausführen und im Anschluss auf erzeugte Variablen zugreifen, um diese z.B. visuell darzustellen oder zu analysieren. Beim Ausführen mehrerer Codes wird dabei der Inhalt des Arbeitsspeichers nicht jedesmal zurückgesetzt. Ein häufiger Fehler ist es hier, in seinem Code auf Variablen zuzugreifen, die im Code selbst nicht definiert sind. Dieser Fehler fällt oft in derselben Session der Python Konsole nicht auf, da die Variable noch im Arbietsspeicher existiert. Startet man die Python Konsole allerdings neu (oder schickt seine Lösung den Übungsleitern), kann es sein, dass beim nächsten Ausführen das Programm plötzlich nicht mehr funktioniert.\n",
+    "* <img src=\"./add_material/Verzweigung.png\" width=\"80px\" > Logische Verzweigungen\n",
+    "* <img src=\"./add_material/Anweisung.png\" width=\"80px\"> Ausführbare Anweisung: Ein Befehl, für dessen Ausführung alle Grundlagen geschaffen sind (z.B. nötige Variablen wurden bereits definiert, etc.).\n",
+    "* <img src=\"./add_material/Stop.png\" width=\"80px\" > Ende des Programms: Es muss klar sein, wann das Programm (erfolgreich?) beendet ist.\n",
+    "\n",
+    "\n",
+    "Programmablaufpläne kann man z.B. mit Hilfe des yED Editors erstellen (auch als Onlineversion verfügbar: https://www.yworks.com/products/yed-live)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Beispiel: Die Betragsfunktion\n",
+    "Wir betrachten die Funktion \n",
+    "$$ f:\\mathbb{R} \\rightarrow \\mathbb{R}_{\\geq 0}: x \\mapsto |x|.$$\n",
+    "\n",
+    "Alternativ können wir $f$ wie folgt definieren:\n",
+    "$$  f:\\mathbb{R} \\rightarrow \\mathbb{R}_{\\geq 0}: x \\mapsto \\begin{cases} x &, x\\geq0 \\\\ -x &,x<0 \\end{cases}.$$\n",
+    "Wir überführen diese abstrakte Formulierung in einzelne ausführbare Teilschritte.\n",
+    "\n",
+    "<img src=\"./add_material/Betragsfunktion.png\" width=\"250px\">\n",
+    "\n",
+    "In den kommenden Vorlesungen lernen wir die nötige Syntax kennen, um Programmablaufpläne in Pythonprogramme umzuwandeln. In der nächsten Zelle sehen wir beispielhaft den hier vorgestellten Programmablaufplan zur Betragsfunktion als Pythonprogramm umgesetzt. Man kann den Inhalt der Zelle ausführen, indem man sie durch Mausklick auswählt und anschließend STRG + ENTER drückt."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x = -7\n",
+    "if x >= 0:\n",
+    "    print('f(x) = ', x)\n",
+    "else:\n",
+    "    print('f(x) = ', -x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "<img src=\"./add_material/ewpwicht_programming.png\" width=\"50px\" align=\"left\"> **Kurzer Selbsttest:**\n",
+    "Wir berechnen für ein gegebenes $n \\in  \\mathbb{N}$ die Summe der Zahlen von 0 bis $n$:\n",
+    "\\begin{align*}\n",
+    "    x = 1 + 2 + \\ldots + n = \\sum_{k=0}^n k .\n",
+    "\\end{align*}\n",
+    "Erstelle einen zugehörigen Programmablaufplan.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Beispiel: verschachtelte Schleife\n",
+    "Schleifen sind Kontrollstrukturen, mit denen man den Programmablauf steuern kann. Diese werden in einem eigenen Notebook behandelt. Hier aber schon mal vorweg ein Beispiel, wie verschachtelte Schleifen in einem Programmablaufplan aussehen könnten.\n",
+    "<img src=\"./add_material/verschachtelteSchleifen.png\" width=\"500px\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Beispiel: Funktionen\n",
+    "Funktionen erlauben es, Programme in einzelne Teilprogramme zu gliedern. Diese werden in einem eigenen Notebook behandelt. Hier aber schon mal vorweg ein Beispiel, wie Funktionen in einem Programmablaufplan aussehen könnten.\n",
+    "<img src=\"./add_material/FunktionenPAP.png\" width=\"500px\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Links und weiterführendes Material\n",
+    "<img src=\"./add_material/ewpwicht_homework.png\" width=\"50px\" align=\"center\"> \n",
+    "\n",
+    "* Python-Distribution (**Python 3**): https://www.anaconda.com/download/\n",
+    "* Editor für Flussdiagramme: https://www.yworks.com/yed-live/\n",
+    "* https://github.com/jrjohansson/scientific-python-lectures/blob/master/Lecture-0-Scientific-Computing-with-Python.ipynb **Vorsicht**: In der Vorlesung benutzen wir Python 3, in dieser Quelle wird jedoch Python 2 benutzt. Das Tutorial ist jedoch sehr übersichtlich und viele Inhalte sind weiterhin gültig.\n",
+    "* Unterschied Python 2.x und 3.x: https://sebastianraschka.com/Articles/2014_python_2_3_key_diff.html\n",
+    "\n",
+    "***"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Hinweise zur Lizenz\n",
+    "Teile dieser Materialien basieren auf der Arbeit von Robert Johansson (https://github.com/jrjohansson/scientific-python-lectures), welche unter der Creative Commons Lizenz (https://creativecommons.org/licenses/by/3.0/) nutzbar ist. \n",
+    "\n",
+    "Wir weisen hier darauf hin, dass Bildinhalte nicht verändert oder weitergegeben werden dürfen.\n",
+    "\n",
+    "Die vollständigen Materialien sind insbesondere nur für den eigenen Gebrauch bestimmt und werden im Rahmen des Studiums an der TU Kaiserslautern bereitgestellt und dürfen nicht an Dritte weitergegeben werden."
+   ]
+  }
+ ],
+ "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": 4
+}