diff --git a/BeispielDatenPGP2a.txt b/BeispielDatenPGP2a.txt deleted file mode 100644 index 39472ae..0000000 --- a/BeispielDatenPGP2a.txt +++ /dev/null @@ -1,14 +0,0 @@ -Messwertnummer Hallspannung UH Probenspannung Up Probenstrom Ip Probentemperatur Tp Flussdichte B -n/# UH/mV Up/V Ip/mA Tp/°C B/T - -1 -9,9 -2,73 -53 24,0 -0,006864 -2 -6,6 -2,03 -40 24,0 -0,006927 -3 -4,7 -1,51 -29 24,1 -0,006867 -4 -3,4 -1,09 -21 24,1 -0,006842 -5 -1,8 -0,57 -11 23,8 -0,006892 -6 -0,2 -0,04 -1 24,1 -0,006860 -7 0,9 0,52 10 24,0 -0,006849 -8 2,2 1,09 22 24,0 -0,006892 -9 3,3 1,62 32 24,1 -0,006869 -10 4,3 2,15 42 24,2 -0,006851 -11 6,3 2,55 50 24,3 -0,006860 diff --git a/Kapitel_2._Das_Auge_plottet_mit_und_das_Einlesen_von_Daten__Zusatz_.ipynb b/Kapitel_2._Das_Auge_plottet_mit_und_das_Einlesen_von_Daten__Zusatz_.ipynb deleted file mode 100644 index d073454..0000000 --- a/Kapitel_2._Das_Auge_plottet_mit_und_das_Einlesen_von_Daten__Zusatz_.ipynb +++ /dev/null @@ -1,892 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Das Einlesen von Messdaten:\n", - "\n", - "Im PGP-2 ist es in verschiedenen Versuchen nötig Messdaten von txt-Dateien einzulesen. Hierfür könnt ihr verschiedene Methoden verwenden. Dies ist oft in Python der Fall, das mehrere Wege ans Ziel führen. Im folgen möchten wir euch zwei Methoden etwas näher bringen.\n", - "\n", - "### Mit Hilfe von numpy:\n", - "\n", - "Eine weitere nützliche `numpy`-Funktion verwenden. Gucken wir uns jedoch zunächst einmal einen typischen Beispieldatensatz (*BeispielDatenPGP2.txt*) an: \n", - "\n", - "``` \n", - "Messwertnummer\tHallspannung UH\tProbenspannung Up\tProbenstrom Ip\tProbentemperatur Tp\tFlussdichte B\n", - "n/#\tUH/mV\tUp/V\tIp/mA\tTp/°C\tB/T\n", - "\n", - "1\t-9,9\t-2,73\t-53\t24,0\t-0,006864\n", - "2\t-6,6\t-2,03\t-40\t24,0\t-0,006927\n", - "3\t-4,7\t-1,51\t-29\t24,1\t-0,006867\n", - "4\t-3,4\t-1,09\t-21\t24,1\t-0,006842\n", - "5\t-1,8\t-0,57\t-11\t23,8\t-0,006892\n", - "6\t-0,2\t-0,04\t-1\t24,1\t-0,006860\n", - "7\t0,9\t0,52\t10\t24,0\t-0,006849\n", - "8\t2,2\t1,09\t22\t24,0\t-0,006892\n", - "9\t3,3\t1,62\t32\t24,1\t-0,006869\n", - "10\t4,3\t2,15\t42\t24,2\t-0,006851\n", - "11\t6,3\t2,55\t50\t24,3\t-0,006860\n", - "```\n", - "\n", - "Wie ihr sehen könnt besteht diese Datei aus mehreren bei Leerzeichen getrennten Spalten und durch Umbrüche getrennte Zeilen. Allgemein unterscheidet man bei solchen Datensätzen zwischen zwei Informationskategorien: \n", - "\n", - "1. Der Kopfzeile (*Header*) \n", - "2. Den Messwerten selbst\n", - " \n", - "Der Header enthält allegemeine Informationen über unsere Daten. In unserem obigen Beispiel ist dies z.B. der Name der einzelnen Messwerte wie *Hallspannung UH* und dessen Einheiten *mV*. Gefolgt ist der Header von unseren tatsächlichen Messwerten, welche wir für unsere Analyse brauchen. Was für uns einfach lesbar und verständlich ist, bedeutet im allgemeinen nicht, dass das gleiche auch für unseren Computer gilt. Probieren wir doch erstmal diesen Datensatz mit Hilfe von `np.genfromtxt` einzulesen." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-03T10:04:09.176914Z", - "start_time": "2019-10-03T10:04:08.956145Z" - } - }, - "outputs": [], - "source": [ - "import numpy as np" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-03T10:05:45.212389Z", - "start_time": "2019-10-03T10:05:45.000440Z" - } - }, - "outputs": [ - { - "ename": "ValueError", - "evalue": "Some errors were detected !\n Line #2 (got 1 columns instead of 11)\n Line #4 (got 6 columns instead of 11)\n Line #5 (got 6 columns instead of 11)\n Line #6 (got 6 columns instead of 11)\n Line #7 (got 6 columns instead of 11)\n Line #8 (got 6 columns instead of 11)\n Line #9 (got 6 columns instead of 11)\n Line #10 (got 6 columns instead of 11)\n Line #11 (got 6 columns instead of 11)\n Line #12 (got 6 columns instead of 11)\n Line #13 (got 6 columns instead of 11)\n Line #14 (got 6 columns instead of 11)", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;31m# Notebook befindet reicht es den Dateinamen anzuegebn. Ansonsten\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;31m# müsst ihr den gesamten Pfad angeben.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgenfromtxt\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpfad\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# <-- Einlesen der txt-Datei\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\site-packages\\numpy\\lib\\npyio.py\u001b[0m in \u001b[0;36mgenfromtxt\u001b[1;34m(fname, dtype, comments, delimiter, skip_header, skip_footer, converters, missing_values, filling_values, usecols, names, excludelist, deletechars, replace_space, autostrip, case_sensitive, defaultfmt, unpack, usemask, loose, invalid_raise, max_rows, encoding)\u001b[0m\n\u001b[0;32m 2073\u001b[0m \u001b[1;31m# Raise an exception ?\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2074\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0minvalid_raise\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2075\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0merrmsg\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2076\u001b[0m \u001b[1;31m# Issue a warning ?\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2077\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mValueError\u001b[0m: Some errors were detected !\n Line #2 (got 1 columns instead of 11)\n Line #4 (got 6 columns instead of 11)\n Line #5 (got 6 columns instead of 11)\n Line #6 (got 6 columns instead of 11)\n Line #7 (got 6 columns instead of 11)\n Line #8 (got 6 columns instead of 11)\n Line #9 (got 6 columns instead of 11)\n Line #10 (got 6 columns instead of 11)\n Line #11 (got 6 columns instead of 11)\n Line #12 (got 6 columns instead of 11)\n Line #13 (got 6 columns instead of 11)\n Line #14 (got 6 columns instead of 11)" - ] - } - ], - "source": [ - "pfad = 'BeispielDatenPGP2.txt' # <-- Pfad zur Datei, sofern sich die Datei am selben Ort wie euer\n", - " # Notebook befindet reicht es den Dateinamen anzuegebn. Ansonsten\n", - " # müsst ihr den gesamten Pfad angeben. \n", - "np.genfromtxt(pfad) # <-- Einlesen der txt-Datei" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Wie ihr seht bekommen wir eine etwas längliche Fehlermeldung, welche so viel sagt wie: *Hey du ich verstehe deine Datei nicht, mal hast du mehr Spalten mal weniger*. Das Problem hier ist, dass unser *Header* scheinbar eine andere Spaltenanzahl als unser Messdaten aufweist. Dies Problem können wir relative einfach mit dem Paramter `skip_header` umgehen: " - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-03T10:28:02.193780Z", - "start_time": "2019-10-03T10:28:02.162533Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 1., nan, nan, -53., nan, nan],\n", - " [ 2., nan, nan, -40., nan, nan],\n", - " [ 3., nan, nan, -29., nan, nan],\n", - " [ 4., nan, nan, -21., nan, nan],\n", - " [ 5., nan, nan, -11., nan, nan],\n", - " [ 6., nan, nan, -1., nan, nan],\n", - " [ 7., nan, nan, 10., nan, nan],\n", - " [ 8., nan, nan, 22., nan, nan],\n", - " [ 9., nan, nan, 32., nan, nan],\n", - " [ 10., nan, nan, 42., nan, nan],\n", - " [ 11., nan, nan, 50., nan, nan]])" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data = np.genfromtxt(pfad, \n", - " skip_header=3 # <-- Ãœberspringt die ersten 3 Zeilen unserer Files\n", - " )\n", - "data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Wie ihr sehen könnt ist uns hier schonmal ein Teilerfolg gelungen. Unsere Messwerte wurden eingelesen und wurden als ein `numpy.array` gespeichert. Ein `numpy.array` ist eine etwas bessere Form einer Liste wie ihr sie bereits kennt (denkt euch einfach das array() weg, dann sieht es genauso aus wie eine Liste. Guckt euch auch gerne mal in eurer Freizeit an wie numpy arrays funktionieren (z.B. auf youtube) arrays nehmen euch viel Arbeit ab). Des Weiteren seht ihr aber auch, dass Python nicht all unsere Messwerte richtig einglesen hat. Lasst uns nochmal die Messdaten der ersten Zeile mit unseren eingelesenen Daten vergleichen:\n", - "\n", - "Messdaten:\n", - "\n", - "```\n", - "1 -9,9 -2,73 -53 24,0 -0,006864\n", - "```\n", - "\n", - "Eingelesen in Python:\n", - "\n", - "```\n", - "[ 1., nan, nan, -53., nan, nan]\n", - "``` \n", - "\n", - "Tja dumm gelaufen \"leider\" studiert ihr in Deutschland. In Deutschland (aber auch in anderen Ländern) ist es üblich ein Dezimalkomma **\",\"** zu verwenden, wohingegen in den USA der Punkt **\".\"** das übliche Trennungszeichen ist. Sprich Python versteht nicht wie er die Zahl -9,9 in eine Float-Zahl umwandeln soll. Aus diesem Grund bekommt ihr den Wert **nan** (not a number) zurück. Aber keine Sorge auch dieses Problem lässt sich relativ einfach mit Hilfe des `converters` parameter lösen. \n", - "\n", - "Der Paramter `converts` benötigt ein sogenanntes python dictionary als Eingabe. Keine Sorge es klingt kompliziert ist aber relativ einfach. Bei einem dictionary wird einem Schlüsselbegriff (key) ein Wert (value) zu gewiesen. Dies sieht wie folgt aus:\n", - "\n", - "```python\n", - "{key1: value1, key2: value2, key3: value3}\n", - "```\n", - "\n", - "Für unseren Parameter `converts` müssen wir ein dictionary erstellen welches einer gewissen Spalte eine Funktion zuordnet. In unserem Fall muss diese Funktion das Komma durch einen Punkt ersetzen. Dies ist relativ einfach und sieht dann so aus:\n", - "\n", - "```python\n", - "{1: lambda v1: float(v1.replace(b',', b'.'))}\n", - "```\n", - "\n", - "Hierbei steht der **key** 1 für die 1. Spalte (nicht vergessen in Python starten wir bei der 0 mit dem Zählen). Als **value** wurde hier eine sogenannte `lambda`-Funktion verwendet. Eine `lambda`-Funktion ist lediglich eine mini-Funktion welche in den meisten Fällen nicht gespeichter werden soll. Unsere `lambda`-Funktion nimmt einen paramter genannt v1, was unserem Messwert entspricht und ersetzt bei diesem Wert das Komma durch ein Punkt. (Nebenbemerkung: Das kleine b vor dem String bedeutet das wir den String als bit-codiertes Wort lesen.) Es sieht sehr kompliziert aus, ist aber in der Anwendung sehr einfach. Gucken wir uns dieses Beispiel doch einfach einmal an:" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-03T10:39:26.259305Z", - "start_time": "2019-10-03T10:39:26.223312Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 1. , -9.9, nan, -53. , nan, nan],\n", - " [ 2. , -6.6, nan, -40. , nan, nan],\n", - " [ 3. , -4.7, nan, -29. , nan, nan],\n", - " [ 4. , -3.4, nan, -21. , nan, nan],\n", - " [ 5. , -1.8, nan, -11. , nan, nan],\n", - " [ 6. , -0.2, nan, -1. , nan, nan],\n", - " [ 7. , 0.9, nan, 10. , nan, nan],\n", - " [ 8. , 2.2, nan, 22. , nan, nan],\n", - " [ 9. , 3.3, nan, 32. , nan, nan],\n", - " [ 10. , 4.3, nan, 42. , nan, nan],\n", - " [ 11. , 6.3, nan, 50. , nan, nan]])" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.genfromtxt(pfad, \n", - " skip_header=3, \n", - " converters={1: lambda v1: float(v1.replace(b',', b'.'))}\n", - " )" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Wie ihr seht haben wir für Spalte 1. erfolgreich die Messwerte einlesen können. Um dies nun auch mit unseren anderen Spalten machen zu können müssen wir nur unser dictionary entsprechend erweitern:" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-03T10:59:09.375845Z", - "start_time": "2019-10-03T10:59:09.314951Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 1.000e+00, -9.900e+00, -2.730e+00, -5.300e+01, 2.400e+01,\n", - " -6.864e-03],\n", - " [ 2.000e+00, -6.600e+00, -2.030e+00, -4.000e+01, 2.400e+01,\n", - " -6.927e-03],\n", - " [ 3.000e+00, -4.700e+00, -1.510e+00, -2.900e+01, 2.410e+01,\n", - " -6.867e-03],\n", - " [ 4.000e+00, -3.400e+00, -1.090e+00, -2.100e+01, 2.410e+01,\n", - " -6.842e-03],\n", - " [ 5.000e+00, -1.800e+00, -5.700e-01, -1.100e+01, 2.380e+01,\n", - " -6.892e-03],\n", - " [ 6.000e+00, -2.000e-01, -4.000e-02, -1.000e+00, 2.410e+01,\n", - " -6.860e-03],\n", - " [ 7.000e+00, 9.000e-01, 5.200e-01, 1.000e+01, 2.400e+01,\n", - " -6.849e-03],\n", - " [ 8.000e+00, 2.200e+00, 1.090e+00, 2.200e+01, 2.400e+01,\n", - " -6.892e-03],\n", - " [ 9.000e+00, 3.300e+00, 1.620e+00, 3.200e+01, 2.410e+01,\n", - " -6.869e-03],\n", - " [ 1.000e+01, 4.300e+00, 2.150e+00, 4.200e+01, 2.420e+01,\n", - " -6.851e-03],\n", - " [ 1.100e+01, 6.300e+00, 2.550e+00, 5.000e+01, 2.430e+01,\n", - " -6.860e-03]])" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data = np.genfromtxt(pfad,\n", - " skip_header=3, \n", - " converters={1: lambda v1: float(v1.replace(b',', b'.')),\n", - " 2: lambda v1: float(v1.replace(b',', b'.')),\n", - " 4: lambda v1: float(v1.replace(b',', b'.')),\n", - " 5: lambda v1: float(v1.replace(b',', b'.'))}\n", - " )\n", - "data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Ihr könnt sehen wir haben alle Messwerte erfolgreich eingelesen auch wenn diese hier etwas gewöhnungsbedürftig in einer scientific-Schreibweise angegeben sind. Bei dieser Schreibweise steht z.B. 3.2e+01 für $3.2 \\cdot 10^1$. Jetzt können wir wie gewohnt damit Arbeiten:" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-03T11:08:26.231136Z", - "start_time": "2019-10-03T11:08:26.215482Z" - } - }, - "outputs": [], - "source": [ - "zeile1 = data[0] # <-- Erste Zeile von Messdaten\n", - "Messwertnummer = data.T[0] # <-- Erste Saplte von Messdaten mit der Messwertnummer \n", - "Hallspannung = data.T[1] # <-- Zweite Spalte mit der Hallspannung \n", - "\n", - "# Nebenbemerkung:\n", - "# Arrays verhalten sich eher wie mathematische Vektoren bzw. Matritzen\n", - "# Mit dem Befehl .T transponiert ihr im obigen Beispiel eine \"Matrix\"\n", - "# wordurch ihr die jweiligen Spalten als Zeilen bekommt." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Mit Hilfe des CSV-package:\n", - "\n", - "Eine weitere Methode welche zum Einlesen von Datein verwendet werden kann kommt mit dem CSV-Package. txt- oder csv-Dateien nutzen zur Trennung von Spalten Trennzeichen (separator), wie z.B. ‘,‘ ,‘;‘ oder auch ein Leerzeichen. Aus diesem Grund werden Dateien dieser Variante als CSV-Datei, das für comma separated variable steht, genannt. Wie im obigen Beispiel bereit gezeigt ist im deutschsprachigen Raum zu beachten, dass Kommas als Dezimaltrennzeichen benutzt werden, und daher nicht als Spaltentrennzeichen verwendet werden sollte.\n", - "\n", - "Für das Einlesen solcher CSV-Dateien hält Python das csv-Modul bereit. Hierbei ist zu beachten, dass die eingelesenen Werte zunächst vom Typ str sind und vor der Weiterverwendung in Rechnungen entsprechend umgewandelt werden müssen. Folgendes Beispiel demonstriert die notwendigen Schritte:\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-06T09:14:53.935626Z", - "start_time": "2019-10-06T09:14:53.910827Z" - } - }, - "outputs": [], - "source": [ - "import csv\n", - "Messwertnummer = [] # Liste zur Speicherung der Spannungswerte\n", - "Hallspannung = [] # Liste zur Speicherung der Stromwerte\n", - "\n", - "pfad = 'BeispielDatenPGP2.txt'\n", - "\n", - "with open(pfad) as csvfile:\n", - " # Initialisieren des CSV-Readers und Festlegen des Trennzeichens, \n", - " # optionale Parameter müssen explizit benannt werden\n", - " readCSV = csv.reader(csvfile, delimiter='\\t')\n", - " \n", - " # alle Zeilen der Textdatei nacheinander einlesen\n", - " for row in readCSV: \n", - " # Erste Spalte enthält die Messwertnummber (Die Werte werden in Fließkommazahlen umgewandelt)\n", - " messwertnummer = float(row[0])\n", - " # Zweite Spalte enthält die Hallspannung\n", - " hallspannung = float(row[1].replace(',', '.')) # <-- Hier müssen wir wieder das Komma erstzen\n", - " # die Werte werden in die entsprechenden Listen eingefügt\n", - " Messwertnummer.append(messwertnummer)\n", - " Hallspannung.append(hallspannung)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Leider gibt uns auch dieser Ansatz erstmal eine Fehlermeldung, da wir wieder unseren Header überspringen müssen. Dazu wird eine weitere for-Schleife eingesetzt, die nur die Header-Zeilen liest ohne sie weiterzuverarbeiten.\n", - "\n", - "Um hieraus nutzen ziehen zu können müssen wir den obigen Code wie folgt modifizieren:" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-06T09:14:47.437191Z", - "start_time": "2019-10-06T09:14:47.422617Z" - } - }, - "outputs": [], - "source": [ - "import csv\n", - "Messwertnummer = [] # Liste zur Speicherung der Spannungswerte\n", - "Hallspannung = [] # Liste zur Speicherung der Stromwerte\n", - "\n", - "pfad = 'BeispielDatenPGP2.txt'\n", - "\n", - "with open(pfad, encoding=\"utf8\") as csvfile:\n", - " readCSV = csv.reader(csvfile, delimiter='\\t')\n", - " \n", - " n = 3 # Anzahl der Headerzeilen, die übersprungen werden müssen\n", - " for i in range(n):\n", - " next(readCSV) # Zeilen auslesen, aber icht weiterverarbeiten\n", - " \n", - " for row in readCSV: # restliche Zeilen mit Daten auslesen und in Liste speichern \n", - " messwertnummer = float(row[0])\n", - " hallspannung = float(row[1].replace(',', '.')) \n", - " Messwertnummer.append(messwertnummer)\n", - " Hallspannung.append(hallspannung)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Das Auge plottet mit:\n", - "\n", - "In diesem Notebook möchte ich noch ein paar weitere nützlichen Befehle rund ums Thema **Plotten** zeigen. Hierbei handelt es sich nur um verschiedene Beispiele wie ihr eure Plots noch etwas weiter ausschmücken könnt. Nehmen wir hierfür wieder unseren Spannungsplot aus Kapitel 1.:" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-06T12:31:32.872223Z", - "start_time": "2019-10-06T12:31:31.934942Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "# ------------\n", - "# \"Messwerte\":\n", - "# ------------\n", - "spannung = [0.9, 2.0, 3.0, 4.1, 4.9, 6.2] # [V]\n", - "strom = [105, 204, 298, 391, 506, 601] # [mA]\n", - "spannung_error = [0.3]*len(spannung) \n", - "strom_error = [14, 9, 12, 8, 7, 11]\n", - "\n", - "# Spannungsfunktion:\n", - "Spannung = lambda I,R: I*R # <--- Eine lambda-Funktion ist eine andere Variante um kleine \n", - " # Funktionen zu definieren.\n", - "\n", - "plt.errorbar(strom, \n", - " spannung,\n", - " xerr=strom_error,\n", - " yerr=spannung_error, \n", - " ls='', \n", - " marker='d', \n", - " mfc='orange', \n", - " mec='k', \n", - " ms=7,\n", - " ecolor='k', \n", - " elinewidth=2, \n", - " capsize=5, \n", - " capthick=2 \n", - " ) \n", - "\n", - "plt.ylabel('Spannung [V]')\n", - "plt.xlabel('Strom [mA]')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plotgröße ändern\n", - "\n", - "Als erstes kann es nützlich sein die Größe unseres Plottes zu erhöhen. Die können wir über `plt.figure()` erreichen. Je nach dem solltet ihr auch die fontsize eurer Beschriftung entsprechend anpassen." - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-06T12:31:33.247151Z", - "start_time": "2019-10-06T12:31:32.872223Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4QAAAKTCAYAAABB6sasAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAXEQAAFxEByibzPwAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdf5Rd51kf+u8ThAQDIQ2eGQdKpGBf8WNsfFscILQ3EBnuiqnTSE0LTYHEQNpeQYvlhkq5ml5+lIB0kWgRyaLYK/yKAzW0FKQ0Abu0VoDS25KYElFPiYRMmACOZ8YhDUHESsh7/zijSLZn7NHMnjlzZn8+a511Zt53n/d9tHKWlK/33s+u1loAAADon2cNuwAAAACGQyAEAADoKYEQAACgpwRCAACAnhIIAQAAekogBAAA6CmBEAAAoKcEQgAAgJ4SCAEAAHpKIAQAAOgpgRAAAKCnBEIAAICeEggBAAB6atuwC9isqur9ScaSvG/YtQAAACzj+UkutNaet5oPV2ut43q2hqr60I4dO559/fXXD7sUAACAJZ0/fz6PP/74n7bWPmM1n3eGcHnvu/7666ceeuihYdcBAACwpBtuuCEzMzOrvqrRPYQAAAA9JRACAAD0lEAIAADQUwIhAABATwmEAAAAPSUQAgAA9JRACAAA0FMCIQAAQE8JhAAAAD0lEAIAAPSUQAgAANBTAiEAAEBPCYQAAAA9JRACAAD0lEAIAADQUwIhAABATwmEAAAAPSUQAgAA9JRACAAA0FMCIQAAQE8JhAAAAD21bdgFAAAArNX8/Hyn601MTHS63mYlEAIAACNvcnKy0/Vaa52ut1m5ZBQAAKCnBEIAAICeEggBAAB6yj2EAADAyJubm1t2bmFhIVNTU08Ym5mZyfj4+HqXtekJhAAAwMi72q6g4+Pjvekk+nRcMgoAANBTAiEAAEBPCYQAAAA9JRACAAD0lEAIAADQUwIhAABATwmEAAAAPSUQAgAA9JRACAAA0FMCIQAAQE8JhAAAAD0lEAIAAPSUQAgAAGx68/PzqaonvObn57f83utNIAQAALa08+fPP2Xs4YcfHkIlm49ACAAAbFmttUxPTydJbr0peelNg/Hp6em01oZY2eYgEAIAAFvWyZMnc/r06Wzflrzh9uSNtyfbtyUPPPBATp06Nezyhk4gBAAAtqQLFy7kzjvvTJIcelmy+3mD18HbBvMHDhzIhQsXhljh8AmEAADAlnTkyJHMzs5m13hy+OWXx6f3JjuvSWZnZ3P06NHhFbgJCIQAAMCWc/bs2Rw/fjxJcuJVydiOy3NjOwZjSXLs2LGcO3duCBVuDtuGXQAAAMBqLCwsLDneWsv+/ftz8eLF3HpTsvfmpx6z74WDBjP3n7mY/fv35957701VXdU+W4FACAAAjKSpqamnnb/USGapnFc1aDBz4+sGDWauvfbadapyc3PJKAAAsCUdvG3QRGY5VzaY6SuBEAAAoKcEQgAAYEs6/vbk3PuXnz/7yOCYPnMPIQAAMJJmZmYyPj7+lPHWWl75ylfm9OnTuePNyS8deup9hK0ld9yTXPxYcssttzxjU5lnul9xVAmEAADASBofH8/ExMSSc3fffXduvPHG3HfmYk49OOgqeqWT70ruP5Ns3749d911VyYnJzeg4s3HJaMAAMCWs3v37hw8eDBJcuCe5MLjl+cuPJ7c+ZbBz4cOHcru3buHUOHmIBACAABb0vT0dHbu3JnZx5Kjb708fuRUMvtYsmvXrhw+fHh4BW4CAiEAALAljY2N5cSJE0mSY28bNJi5spHMiRMnMjY2NsQKh889hAAAwJa1b9++7Nmz5xMNZlouN5LZu3fvsMsbOmcIAQCALauqcvTo0STJfWcGjWSS5MiRI8t2Fe2TkQ+EVfW8qvqhqjpbVX9eVR+oqger6tiwawMAAIbvuuuuW9FYH430JaNV9eVJfinJX0oyk+StSZ6dZCrJa5McGl51AABAVyYmJtJa693e621kA2FVfXYGYXBHkle01n7xSfNfOpTCAAAARsTIBsIk/28GZwa//clhMElaa7+58SUBAACMjpG8h7Cqnpvk65L8ryQ/NuRyAAAARtKoniH86xlcKvofk3y0qv5Okv8jyScn+d0k/6a19ugQ6wMAANj0RjUQ3rD4/miSX0/y5U+aP1pV39xa+7cbWxYAAMDoGNVA+NzF91cneTzJazLoMPrpSb49gw6jP11V72mtnXm6harqoWWmru+oVgAAgE1pJO8hTPJJi+/bkry2tfYTrbWF1tp7W2vfkeTnk2yPx04AAAAsa1TPEP7p4vvHk7x5ifmfSPJ3krzkmRZqrd2w1PjimcOpVdYHAACw6Y3qGcL3Lr6/v7X2+NPMT25INQAAACNoVAPhf198f25V1RLz1yy+f3iD6gEAABg5IxkIW2u/k+T3k3xqki9b4pCXLL7/1kbVBAAAMGpGMhAu+oHF9zdU1filwaq6Ocl3LP5614ZXBQAAMCJGtalMkrwpyVcl+dok76mq/5LBYyf+WgYdRt/UWvv5IdYHAABskPn5+WXnFhYWVjR2pYmJiTXXNApGNhC21j5eVa9M8o4kfz/JLUlakncluau19pYhlgcAAGygycmr6yc5NfX0DxRora2lnJExsoEwGYTCJP9q8QUAAMBVGOV7CAEAAFgDgRAAAKCnRvqSUQAAgCSZm5sbdgkjSSAEAABGXl+6gnbNJaMAAAA9JRACAAD0lEAIAADQUwIhAABATwmEAAAAPSUQAgAA9JRACAAA0FMCIQAAQE8JhAAAAD0lEAIAAPSUQAgAANBTAiEAAEBPCYQAAAA9JRACAAD0lEAIAADQUwIhAABATwmEAAAAPSUQAgAA9JRACAAA0FMCIQAAQE8JhAAAAD0lEAIAAPSUQAgAANBTAiEAAEBPCYQAAAA9JRACAAD0lEAIAADQUwIhAABATwmEAAAAPSUQAgAA9JRACAAA0FMCIQAAQE8JhAAAAD0lEAIAAPSUQAgAANBTAiEAAEBPCYQAAAA9JRACAAD0lEAIAADQUwIhAABATwmEAAAAPSUQAgAA9JRACAAA0FMCIQAAQE8JhAAAAD0lEAIAAPSUQAgAANBTAiEAAEBPCYQAAAA9JRACAAD0lEAIAADQUwIhAABATwmEAAAAPSUQAgAA9NS2YRcAAABXY35+vtP1JiYmOl0PRolACADASJmcnOx0vdZap+vBKHHJKAAAQE8JhAAAAD0lEAIAAPSUewgBABgpc3Nzy84tLCxkamrqCWMzMzMZHx9f77JgJAmEAACMlKvtCjo+Pq6TKCzDJaMAAAA9JRACAAD0lEAIAADQUwIhAABATwmEAAAAPSUQAgAA9NTIBsKqekdVtad53TrsGgEAADazrfAcwn+X5MNLjP/RRhcCAAAwSrZCIPynrbX3DrsIAACAUTOyl4wCAACwNgIhAABAT22FS0ZfU1XXJPl4krNJTrbWZodcEwAAwKa3FQLh//Ok33+wql7fWnv9Sj5cVQ8tM3X92soCAKAr8/PzmZycfMLY3NxcJiYmhroWjLpRvmT015K8KoPgNpbk85P8syQfS/K9VXVgiLUBADAE58+ff8rYww8/PIRKYDSMbCBsrX1Xa+2nW2sPt9b+vLV2trV2JMm+xUP+eVV96grWuWGpV5Kn/m0CAMCm1VrL9PR0kuTWm5KX3jQYn56eTmttiJXB5jWygXA5rbX/kORdSZ6T5EVDLgcAgA1y8uTJnD59Otu3JW+4PXnj7cn2bckDDzyQU6dODbs82JS2XCBcdG7x/bOGWgUAABviwoULufPOO5Mkh16W7H7e4HXwtsH8gQMHcuHChSFWCJvTVg2Ez118//BQqwAAYEMcOXIks7Oz2TWeHH755fHpvcnOa5LZ2dkcPXp0eAXCJrXlAmFVTSR58eKvvzXMWgAAWH9nz57N8ePHkyQnXpWM7bg8N7ZjMJYkx44dy7lz55ZYAfprJANhVb2oqvZUVT1p/AVJfjHJpyV5a2vtD4dQHgAAG2BhYSFzc3PZv39/Ll68mFtvSvbe/NTj9r1w0GDm4sWL2b9/f+bn5ze+WNikRvU5hF+Q5CeTPFJVZ5O8P8nnJLk5yackeSjJPxheeQAArLepqalP/HypkcwTTxcMVA0azNz4ukGDmRtuuGEDq4TNbSTPECb5b0l+NMkjSaaS/O0kNyb57STfkeRLWmtzwysPAICNdPC2QROZ5VzZYAa4bCTPELbW/meSbxt2HQAAAKNsVM8QAgDAJxx/e3Lu/cvPn31kcAzwRAIhAAAjaWZmJo8++mj27NmTix9L7nhz0tpTj2stueOe5OLHkltuuSUPPfTQxhcLm5RACADASBofH8/k5GTuvvvubN++PfedSU49+NTjTr4ruf9Msn379tx1112ZmJjY+GJhkxIIAQAYabt3787BgweTJAfuSS48fnnuwuPJnW8Z/Hzo0KHs3r17CBXC5iUQAgAw8qanp7Nz587MPpYcfevl8SOnktnHkl27duXw4cPDKxA2KYEQAICRNzY2lhMnTiRJjr1t0GDmykYyJ06cyNjY2BArhM1pJB87AQAAT7Zv377s2bMnp0+fHjSYyeVGMnv37h12ebApOUMIAMCWUFU5evRokuS+M4NGMkly5MiRVNUQK4PNSyAEAGDLuO6661Y0Bgy4ZBQAgE1vYmIibamHDA55LRh1zhACAAD0lEAIAADQUwIhAABATwmEAAAAPSUQAgAA9JRACAAA0FMCIQAAQE8JhAAAAD0lEAIAAPSUQAgAANBTAiEAAEBPCYQAAAA9tW3YBQAAwNWYn59fdm5hYWFFY1eamJhYc00wqgRCAABGyuTk5FUdPzU19bTzrbW1lAMjzSWjAAAAPSUQAgAA9JRACAAA0FPuIQQAYKTMzc0NuwTYMgRCAABGiq6g0B2XjAIAAPSUQAgAANBTAiEAAEBPCYQAAAA9JRACAAD0lEAIAADQUwIhAABATwmEAAAAPSUQAgAA9JRACAAA0FMCIQAAQE9tG3YBAMDmNz8/3+l6ExMTna4HwOoIhADAM5qcnOx0vdZap+sBsDouGQUAAOgpgRAAAKCnBEIAAICecg8hAPCM5ubmlp1bWFjI1NTUE8ZmZmYyPj6+3mUBsEYCIQDwjK62K+j4+LhOogAjwCWjAAAAPbXqM4RVtbOrIlprs12tBQAAwMqs5ZLR9ybp4iFCbY11AAAAsAprDWJzSX53DZ//giTdPukWAACAFVlrIPzl1tq3rPbDVfWTSV69xhoAAABYhWE3lakh7w8AANBbazlD+FeTfGCN+39nkh9a4xoAAACswqoDYWvt3WvdvLX2viTvW+s6AAAAXL1VXzJaVa+pqs/oshgAAAA2zlruIXxTkvdX1c9V1cuqyqMjAAAARshaAuE7kmxP8rVJTiV5pKreWFUv6qIwAAAA1teqA2Fr7ZYkO5O8LsnvJLkmyT9K8htVda6qvquqru+mTAAAALq2psdOtNb+uLV2vLX2V5LcmOQHMmgSc32S705ytqp+o6r2V9Vnrr1cAGAjzM/Pp6qe8Jqfn9/0awNwdTp7DmFrbaa1dri19oIkX5nkx5N8MMmXJ/mRJH9cVSer6u9U1fau9gUAhuv8+fNPGXv44YeHUAkAV2tdHkzfWvv11to/TPK8JH87yS8m+XiSv5nk55K8fz32BQA2Vmst09PTSZJbb0peetNgfHp6Oq21IVYGwEqsSyC8pLX20dbaL2bQeOb2DB5kX0mes577AgAb4+TJkzl9+nS2b0vecHvyxtuT7duSBx54IKdOnRp2eQA8g3UNhFX1xVX1L5P8UZKfzaDxzF8kuW899wUA1t+FCxdy5513JkkOvSzZ/bzB6+Btg/kDBw7kwoULQ6wQgGfSeSCsqs+tqn9WVTNJ3pnkzgwuHf3tJK9N8pdba7d1vS8AsLGOHDmS2dnZ7BpPDr/88vj03mTnNcns7GyOHj06vAIBeEadBMKq+syq+taq+s9Jfi/J9yb5ggzODP5Akhtbaze31k601ua62BMAGJ6zZ8/m+PHjSZITr0rGdlyeG9sxGEuSY8eO5dy5c0OoEICV2LbaD1bVpyR5eZJvTPLSxbUqyZ8m+XdJ3pLkHc0d5QCwJSwsLCQZNJLZv39/Ll68mFtvSvbe/NRj971w0GDm/jMXs3///tx7772pqiesA8DwrToQJnk0yadnEAI/lsF9gW9JcrK19pEOagMANpGpqakn/H6pkcxiznuCqkGDmRtfN2gwc+21125QlQBcjbVcMvrsJP89yT9J8jmttdtaaz8rDAJAPxy8bdBEZjlXNpgBYHNayxnCG1pr/7OzSgAAANhQqz5DuJnC4GJTm7mqalX1u8OuBwD64Pjbk3PvX37+7CODYwDYvFYdCKvqjqr66rVsXlVfXVV3rGWNRf8yyXgH6wAAy5iZmcnc3FweffTR7NmzJxc/ltzx5mSp9nGtJXfck1z8WHLLLbfk0UcfzdzcXObm5jIzM7PxxQOwpLXcQ3giydevcf9vSPJDa1mgqr4qye1J3rTGWgCApzE+Pp6JiYlMTk7m7rvvzvbt23PfmeTUg0899uS7kvvPJNu3b89dd92VycnJTExMZGJiIuPj/hsuwGbR+YPpN1JVfWqSu5LMJPnBIZcDAL2xe/fuHDx4MEly4J7kwuOX5y48ntz5lsHPhw4dyu7du4dQIQArsdZAeHtV/cVqX0levcb9vzvJ9Um+NclH17gWAHAVpqens3Pnzsw+lhx96+XxI6eS2ceSXbt25fDhw8MrEIBntJYuo7NJhvbQ+aq6Kcl3JPnJ1tqvVdULhlULAPTR2NhYTpw4kVe84hU59rbk1S8e3Dt4qZHMiRMnMjY2NtwiAXhaqw6ErbUXdFjHVamqZ2Vwz+AHkxwaVh0A0Hf79u3Lnj17cvr06UGDmVxuJLN3795hlwfAM1jLGcJh+vYkX5rkm1trj61loap6aJmp69eyLgD0QVXl6NGjedGLXpT7zlweP3LkSKpqeIUBsCIj11Smqp6f5PuS/Gpr7aeGXA4A9N511123ojEANp9RPEP4r5Jsz6CRzJq11m5YanzxzOFUF3sAwKiZmJhIW+oBg5t8bQCuzigGwpdlcO/gjz7pUpRPWXzfWVXvuHRsa+3DG1gbAADAyBjFQJgkfynJVy4z96lXzI3qnw8AAGDdjdw9hK21WuqV5HMXD3nPFeMfHGatAAAAm9nIBUIAAAC6IRACAAD0lEAIAADQU501Xamqh1d46MUkjyX57ST/urX2G13s31p7bxJPwAUAAFihLrtwvuAqj//yJPur6kdba/+4wzoAAABYgc4uGW2tPSvJG5L8SZLvTfJFSZ6z+PqixbEPJHljkucn+XtJ/jDJt1bVN3ZVBwAAACvT5SWj357k/0ryJa21//Gk6YeSPFRVP5/knUkebq39cFXNJPmtJK9J8tNd1QIAAMAz67KpzP4kDywRBj9hce6BDIJjWmu/k+RdSf73DusAAABgBboMhJ+b5MMrOO7DufwQ+SR5b5KxDusAAABgBbpsKrOQ5Cur6tNaa3+21AFV9elJXpJk/orh52Zw3yEAsEnNz88vO7ewsLCisStNTEysuSYA1q7LQPhvkrw2yX1V9drW2juvnKyqL0nyL5KMJ/mhxbHKoOHM2Q7rAAA6Njk5eVXHT01NPe18a20t5QDQkS4D4XcneXGSv57kv1bVHyZ5X5KWZGeSz8ngOYHvSvI9i5+5KcmHkvxsh3UAAACwAp0Fwtban1XVVyQ5mOQfZvBoiedfccgfJ7k7yfHW2kcWP/PuJF/YVQ0AAACsXJdnCNNaezzJ9yX5vqp6fpLPXpx6pLU22+VeAAAArE2ngfBKrbX3ZXDJKAAw4ubm5oZdAgDrYN0CIQCwdegKCrA1dRoIq2oyybcl+Yokn5VkxzKHttba9V3uDQAAwNXpLBBW1Rcm+dUk12TQTRQAAIBN7FkdrnU8g2cM/kKSm5M8u7X2rOVeHe4LAADAKnR5yeiLk7wnydc1T5sFAADY9Lo8U1dJfkcYBAAAGA1dBsJ3JfnfOlwPAACAddRlIPyeJF9UVV/X4ZoAAACsk66fQ/jDSX6mqv5Gkl9J8odJlryEtLX2ax3vDQAAwFXoMhC+I4PwV0leneRVz3D8J3W4NwAAAFepy0B4T5Y5GwgAAMDm01kgbK19U1drAQAAsP48IB4AAKCnBEIAAICe6uyS0ar6ias4vLXWXtPV3gAAAFy9LpvKfNMKjrnUhbQlEQgBAACGqMtAuGeZ8WcleX6Slyb5u0l+KMm/73BfAAAAVqHLLqO/+gyH3FNVv5zkJ5K8tat9AQAAWJ0NbSrTWvvpJA8l+Z6N3BcAAICnGkaX0XNJXjiEfQEAALjChgbCqnpWkpuSfHwj9wUAAOCpNiQQVtVYVf2VJPcm2Z3kme43BAAAYJ11+RzCv1jJYUnmkxzsal8AAABWp8vHTrwvg+cLLuVikkcyODP4I621uQ73BQAAYBW6fOzEC7paCwAAgPU3jC6jAAAAbAICIQAAQE91eQ9hkqSqXpLkK5J8VpIdyxzWWmuv6XpvAAAAVq7LLqPPSXIqyYsz6Cb6dFoSgRAAAGCIujxD+AMZnBn8vSQ/muRskg93uD4AAAAd6jIQ7k3yaJIXtdY+0OG6AAAArIMum8o8J8l/EQYBAABGQ5eB8FySiQ7XAwAAYB11GQjfmORLq+qLOlwTAACAddJZIGyt/ViSH07yy1X1TVX1l7taGwAAgO51+diJv7j0Y5IfXxxb7vDWWuv8GYgAAACsXJeh7H0ZPF8QAACAEdBZIGytvaCrtQAAAFh/LtsEYEnz8/OdrjcxoRE1AGw2AiEAS5qcnOx0vdbcVQAAm03ngbCqPjfJi5N8VpIdyxzWWmuv73pvAAAAVq7LLqPbk/xYkm+4NPQ0h7ckAiEAAMAQdXmG8HuTfGOSP0ny00nOJvlwh+sDAADQoS4D4dcn+WCSL26t/UGH6wIwBHNzc8vOLSwsZGpq6gljMzMzGR8fX++yAIAOdRkIJ5PcLwwCbA1X2xV0fHxcJ1EAGDHP6nCtP0jyaR2uBwAAwDrqMhD+eJIvrarnd7gmAAAA66TLQPiDSd6e5Jer6iVV9XRdRgEAABiyLu8h/L3F911J/lOSj1bVIxk8YuLJWmvt+g73BgAA4Cp1GQhf8KTft2cQDgEAANiEOguErbUuLz8FAABgnQlxAAAAPSUQAgAA9FSX9xB+QlU9O8n1SZ6dZMluo621X1uPvQEAAFiZTgNhVd2Y5ESSl2SZIHiFT+pybwAAAK5OZ4GwqnYn+c9JPiPJbyT5rCSfm+Rnk1yX5IsX93trkg92tS8AAACr0+U9hP9PBpeIfnNr7cVJfj1JWmvf0Fr78iQ3ZBAYp5K8tsN9AQAAWIUuA+EtSf5na+3NS0221n4vyd4kE0le3+G+AFyF+fn5VNUTXvPz872tAwD6rMtAOJlk5orfP5okVfUplwZaax9M8o4kL+twXwA22Pnz558y9vDDDw+hEgBgLboMhB9I8ilP+j1Jdi1x7ORaN6uq11bVL1TVuar6X1X1eFX9QVW9uapuWOv6ACyttZbp6ekkya03JS+9aTA+PT2d1toQKwMArlaXgfD3M2gic8lvZ9Bp9JWXBqpqPIMOpLMd7Ded5GsyCJ7/Kcnbk3wkyauT/FZVfU0HewDwJCdPnszp06ezfVvyhtuTN96ebN+WPPDAAzl16tSwywMArkKXgfA/JJmqqkuh8N8nWUjyXVX1c1X1L5K8M8lzkvybDvbbm+S5rbUva629YvH1+Um+Lcn2JD9WVR5tAdChCxcu5M4770ySHHpZsvt5g9fB2wbzBw4cyIULF4ZYIQBwNboMhG9JciyDpjFprf1ZBmcH/yTJ1yb5JxlcPvofk3z/Wjdrrf1Ga+0jS4z/aJLfS/LZST5/rfsAcNmRI0cyOzubXePJ4ZdfHp/em+y8Jpmdnc3Ro0eHVyAAcFU6C4SttfOttcOttd+8YuyBDELg30jyDUm+pLX20tba413tu4y/WHy/uM77APTG2bNnc/z48STJiVclYzsuz43tGIwlybFjx3Lu3LkhVAgAXK3OHky/nMUzhfet9z6XVNWrMzgzeDaJlncAK7CwsPC086217N+/PxcvXsytNyV7b37qMfteOGgwc/+Zi9m/f3/uvffeVNWq9wQA1t+6BcKquiaDyzaT5JHW2rr8y19VBzN46P2nJfnCxZ//OMnXt9Y+vh57Amw1U1NTKzruUiOZpXJe1aDBzI2vGzSYufbaazuuEgDoWqeBsAb/KfgfLb4+70lz55L8SJIf6TiovTTJV13x+/uSvKq19uBKPlxVDy0zdf1aCwPYag7eNmgis5xLDWa+X7NRABgJnd1DWFU7ktyf5IczuGTzg0neneTM4s+fl+REkvsXj+1Ea+2rW2uV5LlJviLJe5K8o6r+WVd7AAAAbEVddhmdTvLVSR5K8jWttWtaa1/cWvurrbVrMnhm4P9IcsvisZ1qrX2wtfbrGTSweTDJ66vqS1bwuRuWeiU533WNAKPu+NuTc+9ffv7sI4NjAIDR0OUlo9+YwZnAPa21x5482Vq7v6oezKDZy6uSfHeHe1+5z0er6ueS3Jzkb2bw7EMAnsbMzEzGx8eXnW+t5ZWvfGVOnz6dO96c/NKhp95H2Fpyxz3JxY8lt9xyy4qayqz03kUAYH10GQg/O8nblgqDl7TWFqrqgSS3dbjvUi41sJlY530AtoTx8fFMTDz9X5l33313brzxxtx35mJOPTjoKnqlk+9K7j+TbN++PXfddVcmJyfXsWIAoAtdXjL6R0m2r+C4T86gC+h6+srFd5d9AnRk9+7dOXjwYJLkwD3JhSueKHvh8eTOtwx+PnToUHbv3j2ECgGAq9VlIPyZJF9VVbuWO2Bx7quS/Ou1bFRVL66qv1tV2540/slV9e0ZXJL650l+bi37APBE09PT2blzZ2YfS46+9fL4kVPJ7GPJrl27cvjw4eEVCABclS4D4fcl+U9Jfq2qvqWqPu3SRFV9WlV9S5JfXTzme9e41/VJfjbJI1V1X1X9TFXdn+QPkrwhycUk39Rae98a9zTNdakAAB/dSURBVAHgCmNjYzlx4kSS5NjbBg1mrmwkc+LEiYyNjQ2xQgDganR5D+F7klSSz0nypiRvqqo/WZx77hXHtSTveVKjgdZau5rn/v1qkiMZXBp6U5LxDELge5P8fJI3tNZ+bxV/BgCewb59+7Jnz55PNJhpudxIZu/evcMuDwC4Cl0GwhcsMfaZS4wte0npSrXWfj+J5wwCDEFV5ejRo3nRi16U+85cHj9y5MjTdhUFADafzgJha63Ly08B2MSuu+66FY0BAJtbl2cIARgBExMTaa0Nu4xNUwcA9JmzegAAAD216kBYVduqarKqnrPM/DVVdXdV/WFVfaSqHq6q41X17NWXCwAAQFfWcobwm5I8kuTAkycWQ+J/SfL3k3x2Bg+sf0GS1yb5j09+fiAAAAAbby2B8CUZdBt/0xJz00l2J7mQ5NuTfFGSv5Xk95O8MMlr1rAvAAAAHVhLIPyrSX6ntfbIEnO3ZxAWv6e19iOttYdaa6eSfM3i+NeuYV8AAAA6sJZAeG0GD6N/gqqaSjKZ5ONJfurKudbauSS/mcEZQwAAAIZoLYHw2Uk+aYnxL198/x+ttceWmJ9N8pfWsC8AAAAdWEsg/ECSz1ti/MUZXBb635b53Ccn+dAa9gUAAKADawmE/y3JjVX10ksDVTWeZN/ir7+yzOe+MMkfr2FfAAAAOrCWQPgjSSrJyap6c1X9YJJ3JvmMDALfW5/8gap6QZLPT/LuNewLAABAB1b9PMDW2q9U1euTfGeSV2VwmWgl+UiSb26tfXSJj33r4jH3r3ZfAAAAurGmB8S31r67qt6awTMGJ5L8YZKfaa09vMxHLib54SS/vJZ9AQAAWLs1BcIkaa09mOTBFR77nWvdD4CNMT8/v+zcwsLCisauNDExseaaAIBurTkQArA1TU5OXtXxU1NTTzvfWltLOQDAOlhLUxkAAABGmEAIAADQUwIhAABAT7mHEIAlzc3NDbsEAGCdCYQALElXUADY+lwyCgAA0FMCIQAAQE8JhAAAAD0lEAIAAPSUQAgAANBTAiEAAEBPCYQAAAA9JRACAAD0lEAIAADQUwIhAABATwmEAAAAPSUQAgAA9JRACAAA0FMCIQAAQE8JhAAAAD0lEAIAAPSUQAgAANBTAiEAAEBPCYQAAAA9JRACAAD0lEAIAADQUwIhAABATwmEAAAAPSUQAgAA9JRACAAA0FMCIQAAQE8JhAAAAD0lEAIAAPTUtmEXAGwO8/Pzna43MTHR6XoAAHRPIASSJJOTk52u11rrdD0AALrnklEAAICeEggBAAB6SiAEAADoKfcQAkmSubm5ZecWFhYyNTX1hLGZmZmMj4+vd1kAAKwjgRBIcvVdQcfHx3USBQAYcS4ZBQAA6CmBEAAAoKcEQgAAgJ4SCAEAAHpKIAQAAOgpgRAAAKCnBEIAAICeEggBAAB6SiAEAADoKYEQAACgpwRCAACAnhIIAQAAekoghJ6Zn59PVT3hNT8/P7L7AACwegIh8IzOnz//lLGHH354CJUAANClkQyEVTVWVfuq6ser6kxVfaiq/qyq3l1V31VVnz7sGmGraK1leno6SXLrTclLbxqMT09Pp7U2xMoAAFirkQyESb4+yS8m+ZYM/gz3Jfn1JJ+b5J8neWdVTQ6vPNg6Tp48mdOnT2f7tuQNtydvvD3Zvi154IEHcurUqWGXBwDAGoxqILyY5EeTfF5r7cbW2te11m5N8vlJ/nuSL0hyYpgFwlZw4cKF3HnnnUmSQy9Ldj9v8Dp422D+wIEDuXDhwhArBABgLUYyELbW7mmtfVtr7dyTxh9J8o8Wf31FVW3f+Opg6zhy5EhmZ2ezazw5/PLL49N7k53XJLOzszl69OjwCgQAYE1GMhA+g3cvvu9Ics0wC4FRdvbs2Rw/fjxJcuJVydiOy3NjOwZjSXLs2LGcO3duiRUAANjstg27gHVw3eL7R5N8YJiFwKhYWFh4wu+ttezfvz8XL17MrTcle29+6mf2vXDQYOb+Mxezf//+3HvvvamqZdcEAGDz2YqB8MDi+32ttceHWgmMiKmpqSXHLzWSuSLnfULVoMHMja8bNJi59tpr17lKAAC6tqUCYVX9jSSvyeDs4Heu8DMPLTN1fVd1wag6eNugicxyLjWY+X7NRgEARtKWuYewqr4wyU8nqSQHW2vvfoaPAAAA9NqWOENYVZ+TwbMIn5vkX7bWfniln22t3bDMmg8lWfo6OuiJ429Pbv+K5c8Snn1kcAwAAKNp5M8QVtV4kl9JsjPJTyb5p8OtCEbPzMxM5ubmPvF69NFHs2fPnlz8WHLHm5PWnvqZ1pI77kkufiy55ZZb8uijjz5hjZmZmY3/gwAAcFVG+gxhVT07yS9n8CD6X0jyD1pb6v+6Ak9nfHw8ExMTTxi7++67c+ONN+a+Mxdz6sFBV9ErnXxXcv+ZZPv27bnrrrsyOTm5gRUDANCFkT1DWFU7kpxK8sIk9yf5e621vxhuVbB17N69OwcPHkySHLgnuXBFz94Ljyd3vmXw86FDh7J79+4hVAgAwFqNZCCsqk9Kcm+SPUl+PckrWmsXh1sVbD3T09PZuXNnZh9Ljr718viRU8nsY8muXbty+PDh4RUIAMCajOolo/84yd9a/Hkhyb+qpR6UlvzT1pqnY8MqjY2N5cSJE3nFK16RY29LXv3iwb2DlxrJnDhxImNjY8MtEgCAVRvVQPjcK37+W8selXxPBoERWKV9+/Zlz549OX369KDBTC43ktm7d++wywMAYA1G8pLR1tr3tNZqBa/3DrtWGHVVlaNHjyZJ7jszaCSTJEeOHMkyZ+YBABgRIxkIgY113XXXrWgMAIDRMqqXjAKrNDExkY14OstG7QMAwOo5QwgAANBTAiEAAEBPCYQAAAA9JRACAAD0lEAIAADQUwIhAABATwmEAAAAPSUQAgAA9JRACAAA0FMCIQAAQE8JhAAAAD0lEAIAAPTUtmEXAGwO8/Pzy84tLCysaOxKExMTa64JAID1JRACSZLJycmrOn5qaupp51traykHAIAN4JJRAACAnhIIAQAAekogBAAA6Cn3EAJJkrm5uWGXAADABhMIgSS6ggIA9JFLRgEAAHpKIAQAAOgpgRAAAKCnBEIAAICeEggBAAB6SiAEAADoKYEQAACgpwRCAACAnhIIAQAAekogBAAA6CmBEAAAoKcEQgAAgJ4SCAEAAHpKIAQAAOgpgRAAAKCnBEIAAICeEggBAAB6SiAEAADoKYEQAACgpwRCAACAnhIIAQAAekogBAAA6CmBEAAAoKcEQgAAgJ4SCAEAAHpKIAQAAOgpgRAAAKCnBEIAAICeEggBAAB6SiAEAADoKYEQAACgpwRCAACAnhIIAQAAekogBAAA6CmBEAAAoKcEQgAAgJ4SCAEAAHpq27ALYH3Mz893ut7ExESn6wEAAMMnEG5Rk5OTna7XWut0PQAAYPhcMgoAANBTAiEAAEBPCYQAAAA95R7CLWpubm7ZuYWFhUxNTT1hbGZmJuPj4+tdFgAAsIkIhFvU1XYFHR8f10kUAAB6xiWjAAAAPSUQAgAA9JRACAAA0FMCIQAAQE8JhAAAAD0lEAIAAPTUyD52oqpuTvJ/JvnSJF+W5LOTPN5a+5ShFgYAADAiRjYQJvnOJHuHXQQAAMCoGuVA+P8leXeSdy6+3j/ccgAAAEbLyAbC1toPXPl7VQ2rFAAAgJGkqQwAAEBPCYQAAAA91ftAWFUPLfVKcv2wa7tkfn4+VfWE1/z8/LDL+oTNXh8AALC03gfCPjp//vxTxh5++OEhVAIAAAxT7wNha+2GpV5JnpqatoDWWqanp5Mkt96UvPSmwfj09HRaa0OsDAAA2Gi9D4R9c/LkyZw+fTrbtyVvuD154+3J9m3JAw88kFOnTg27PAAAYAMJhD1y4cKF3HnnnUmSQy9Ldj9v8Dp422D+wIEDuXDhwhArBAAANpJA2CNHjhzJ7Oxsdo0nh19+eXx6b7LzmmR2djZHjx4dXoEAAMCGEgh74uzZszl+/HiS5MSrkrEdl+fGdgzGkuTYsWM5d+7cECoEAAA22rZhF8DqLCwsrPjY1lr279+fixcv5tabkr03P/WYfS8cNJi5/8zF7N+/P/fee2+qqvNaAACAzWNkA2FV3ZbkO580vL2q/usVv7++tfb2DSxrw0xNTV31Zy41klkq51UNGszc+LpBg5lrr722gyoBAIDNbGQDYZKJJF/2pLF60tjExpWz+R28bdBEZjmXGsx8v2ajAADQCyMbCFtrP5Xkp4ZcBgAAwMjSVKZHjr89Off+5efPPjI4BgAA6IeRPUPYdzMzMxkfH1/Rsa21vPKVr8zp06dzx5uTXzr01PsIW0vuuCe5+LHklltuueqmMqu5pxEAABgugXBEjY+PZ2Ji5bdI3n333bnxxhtz35mLOfXgoKvolU6+K7n/TLJ9+/bcddddmZyc7LhiAABgs3HJaE/s3r07Bw8eTJIcuCe58PjluQuPJ3e+ZfDzoUOHsnv37iFUCAAAbDSBsEemp6ezc+fOzD6WHH3r5fEjp5LZx5Jdu3bl8OHDwysQAADYUAJhj4yNjeXEiRNJkmNvGzSYubKRzIkTJzI2NjbECgEAgI3kHsKe2bdvX/bs2fOJBjMtlxvJ7N27d9jlAQAAG8gZwp6pqhw9ejRJct+ZQSOZJDly5MiKu4oCAABbg0DYQ9ddd92KxgAAgK3NJaMjYGJiIq21YZexrM1eHwAAsDRnCAEAAHpKIAQAAOgpgRAAAKCnBEIAAICeEggBAAB6SiAEAADoKYEQAACgpwRCAACAnhIIAQAAekogBAAA6CmBEAAAoKcEQgAAgJ7aNuwCWB/z8/PLzi0sLKxo7EoTExNrrgkAANhcBMItanJy8qqOn5qaetr51tpaygEAADYhl4wCAAD0lEAIAADQUwIhAABAT7mHcIuam5sbdgkAAMAmJxBuUbqCAgAAz8QlowAAAD0lEAIAAPSUQAgAANBTAiEAAEBPCYQAAAA9JRACAAD0lEAIAADQUwIhAABATwmEAAAAPSUQAgAA9JRACAAA0FMCIQAAQE8JhAAAAD0lEAIAAPSUQAgAANBTAiEAAEBPCYQAAAA9JRACAAD0lEAIAADQUwIhAABATwmEAAAAPVWttWHXsClV1Yd27Njx7Ouvv37YpQAAACzp/Pnzefzxx/+0tfYZq/m8QLiMqnp/krEk7xt2LWt0KdGeH2oVjBrfG1bD94bV8L1hNXxvWI2t+r15fpILrbXnrebDAuEWV1UPJUlr7YZh18Lo8L1hNXxvWA3fG1bD94bV8L1ZmnsIAQAAekogBAAA6CmBEAAAoKcEQgAAgJ4SCAEAAHpKl1EAAICecoYQAACgpwRCAACAnhIIAQAAekogBAAA6CmBEAAAoKcEQgAAgJ4SCAEAAHpKINzEqurmqvq/q+oXquqPqqpV1UdW8LlXV9VvVtWHq+oDVfVLVfXXnuEzf23xuA8sfu43q+r27v40bJSqGquqfVX141V1pqo+VFV/VlXvrqrvqqpPf5rP+u70WFW9dvHvm3NV9b+q6vGq+oOqenNV3fA0n/O9IUlSVZ9ZVXOL/1797jMc63vTY1X1jsXvyXKvW5f5nO8NqarnVdUPVdXZqvrzxf9tH6yqY8sc/7Kq+tXFf9s+tPjzy55hjy+sqn9bVfOLe/xOVf2Tqtp6+am19v+3d+dBllX1Ace/P/YtsjgMcWNRCWoUiojiuGLEUEE0QbYiBhyLYGIUCeJoGZeAC5VoYoEKSdRSTAZBVDJiQAXRQRCEsMqiyOKEyKgwyCDbDMPwyx/nPLle73v9eqaZ193v+6k6dbrP8t6Ze37T/U7fe881TdMELAKylVZM0Ofjtd2Dtf83gVXAI8D+ffrsX+sfBRYDXwHuqa/z8VEfB9Ok4+avGvFyPXBmjYNf17IfAXONHVPHfC4DHgIuA86q6aY6nyuBPzVuTBPE0Kl1XhP48YB2xs2YpzqHWefx1I70POPG1GdO5zXm8AbgS8C5wBLgkY72b69tVwHfqLHzYC17e5/3eBHwQG1zWX2PnzdiNkZ9HKb0mI56AKYBkwPvBo4H9gO2Y4IFIfDHtc0yYOdG+bz6YW45sHWrz9a1PIHXN8q3A26u5a8c9bEwTSpuDgdOacZALX8ScFWd0y8aO6aO2HkJsElH+VvqfN4BrG/cmPrEz6vq/P07AxaExo2pzt3iOm87DtneuDEBPJmyGHyQjj8CAC9sff8HlIXgCmBeq3xZrWt/XtoAuKXGxzGN8i2AS2r5m0Z9LKb0uI56AKZJTNbEC8Jzapu/66g7qdYd2ypfUMsXdfTZv9Z9fdT/dtOUxdC8XhwBGxk7pknETu/D03OMG1PH3G1aY+QGYGcGLwiNGxNMfkFo3JgA/qPO29uGbH9ybX9iR90xte6TrfKDavk1HX12r3XXjfpYTGWafdfAjqmI2ITy11kop7LbemWvbZXv16pvOoeycNi7vr5mvmtrvjHwRDB2NLTVNX8YjBv9jn8AnkE5m7yqXyPjRmvCuBFARGwNHAzcC3x2yG6DYuDLNR86bjLzauA24LkRseOQY5j2XBDOHs+ifMi/KzN/1lF/Vc13bZXv2qr/jcx8mHIP2ibALlM0To3W02u+CvhV/drY0UARcThlHn9C+UUIxo2qiNgVOBb4fGZ+b4Lmxo3ajoiIUyLiUxHx9ojYvqONcSMotzVsDFwMrIqIAyPixIg4OSKOiojtmo0jYiugF09Xt1+sxtIyYIeI2LJRtVvNfyduWuW79amfcVwQzh69gO/6QUlmPkC9vj4ifg8gIp4AbDWoX6O86we0Zp6ja/7NzFxZvzZ29FsiYkFEnFp3V7se+AKwFPiLzHy0NjNuRN1t7zOUuX7XEF2MG7W9j3Jm+a2USz9viYj3t9oYNwLo7Xb9S+Aiyhm+o4G/BT4B3BoRBzXa9+b1nhojXbpiYGC89ekzo7kgnD16jxJ4cECb3n+GLVr5oH7tPpqhImJf4AjK2cHmL1tjR237AG8EDqT8Av4/ymLwykYb40YARwEvBBZk5t1DtDdu1PM94DDKpcabUc7SvZeyI+gHI+LoRlvjRlA2CYKyed6ulM802wI7UXag3RxYWK9agDWLm2H6zbq4cUE4e0TNc4g2/b4fpo9moIh4NrCQMp8LMvPaZnXNjR0BkJl7Z2ZQfvm+nPLoicUR8d5GM+NmzEXE04APAxdm5qnDdqu5cTPmMvMDmbkwM2/LzIcy8yeZeQLw57XJ8RGxaf3auBHA+jXfAHhHZn4uM5dl5pLMPJZyz99GPHa1wprETVO/frMublwQzh731XzzAW02q/n9rT7Nuon6aIaJiKdSntW0NeWZSye1mhg76pSZyzPzImBf4ErgQxHxglpt3OgUyoevt0yij3GjgTLzPOAKYEvKs+DAuFHRm9NHKbcytH2u5nu12k8mbppf9+s36+LGBeHscXvNn9pVGRGbU66lX56Z9wFk5q8pOzX17dcov71PvaaxiJgDnE+5zv3zwDs7mhk7GigzV1Eeyhs8thubcaP9KJdU/WtELO4l4Ixav32jvHdplXGjYdxc8yfV3LgRlAfPA/yisQ9CV/3cmvfmdesaI126YmBgvPXpM6O5IJw9bqI8mHXbekao7Y9q/sNW+bWt+t+IiA2B59bXvWmKxql1pN5Y/w3K7mxnAUdmfYhOi7GjYSyr+bY1N24E5UP4K1ppz1q3aaNsg1pm3GgYvXvFemdgjBvBYzuFbh0RXZdtPrHm90O5yoXHFm27txvXWJoD3J6Z9zaq+sZNq7wdbzOWC8JZIjMfAr5Tvz2wo0mv7L9b5ecM6LMfZTvmCzJzxVoPUutMRGwMfA3YA/gWcGhmru5qa+xoSK+o+a1g3AgyM7oSZYMHgJsa5ctrH+NGA0XEtsDL6rdXgXGjIjOvA35K+WPTnh1N9qp583ERg2KgtyPp0HETEbtTHuF1Y2b+dOJRzxCP51PvTVObKDe3rhhQv3dtswzYuVE+j/Lw1XuBbVp9tqnlCby+UT6XcslGAq8a9b/dNKk4WZ9yRjApu7htNkQfY2fME+UD2CHABq3yDSk7Sa6mXB74NOPGNEEs7Vjn8cd96o2bMU+UewNfCURH7Fxc5/Nrxo2pI3b+us7b5cCcRvnzgXtq3YGN8l0oO9euAF7UKN+5xtIjwC6t99iQ8szdBI5plG8OXFLLjxj1sZjS4zrqAZgGTA68BvhBIyXlRtpm2WtafU6s7R4AFgHnUh4zsBo4oM/7HFDrHwW+S3muS+8/1UmjPg6mScfN0XXukrIwPLVPmtPqZ+yMcQLm13m7i7IJ0WmUs8tLa/lDwMEd/YwbU3t+d2TAgtC4MTV+3iwFFlPuO724/pxJygPj5xo3po75XA84s87f3cDX67yurGWf7uhzTK1bVWNmEeUPnL+14Gv1eXGjzQ8o99H3fh/+F7DeqI/FlB7XUQ/ANGByHvuBOSjN79PvivoDc3n9cPfSCd7rJZT7ze6p/a4A3jTqY2Bao7g5boi4SWBHY8fUmMedgI/UD2VLgYcp92FcT3ng7zMH9DVuTM253ZEJFoTGzXgn4NmUXWqvBO6sH9SXA5cC7wA2NW5MA+ZzPcrD6K+q83k/8H3gsAF9Xku5auq+mi4CXjfB+/wh5VEWyyhnGG8AjgXWH/UxmOoU9R8sSZIkSRozbiojSZIkSWPKBaEkSZIkjSkXhJIkSZI0plwQSpIkSdKYckEoSZIkSWPKBaEkSZIkjSkXhJIkSZI0plwQSpIkSdKYckEoSZIkSWPKBaEkSZIkjSkXhJIkSZI0plwQSpKmjYh4dUQsiohfRMTDEXF3RNwYEadFxJERsdGox7guRcTiiMhGOnEdv/8hjfc+dIK217TGetw6GqYkaS24IJQkTQsRcTxwHvBnwF3A14ELgFXAocCngW1afTIilqzbkY7EV4EvAJev4/c9rM/XXc6mjPH7j99wJElTbYNRD0CSpIjYA/gA8DCwf2ae26p/CnAksHIEw5sO3pmZS9blG0bEtsA+wP216NURMTcz7+xqn5kfqP3mAy9ZJ4OUJK01zxBKkqaD/Wt+ZnsxCJCZd2TmcZl5zzoe1zg7lPKH468CZ9WvB142KkmaeVwQSpKmg21rftcwjSNifkRk/XaH1r1rixvtltSyiIijIuLaiHgwIq5pvd6+EXF+RNwTESsi4qaI+MeI2KrjvY+rrzk/Ip4fEd+IiOUR8auIODMinlrbbR4RH6tjWBER10fEgWt0dPofh8dzLL1LRBfWBPCXUzl+SdLouSCUJE0HP6v5AfVSxYncQrlfDeCB+nUvfbOj/b8B/wLcSbnX7bZeRUS8BzgH2Au4ElgEbAa8G7gsIrbrM4Y9KffLPQ34NnA3cBBwQURsCXwXeBNwHXAp8BzgzIjYZ4h/32RN6Vgi4lnAHsBS4DuUezmXAnvUOknSLOE9hJKk6eA04D3A9sAtEbEIuIiyeLkxM7PZODMvBi6OiDcCyzJz/gSv/3pg98y8oVkYES8APgzcB+ydmZfX8o2B/6Qsqj4JHNzxmn8DHJOZJ9Y+GwLnAnsDl1AWnzv3LnONiCOAzwJ/D3xrogMySVM9lt7ZwdMz89Ha5wzgHZSzhO+b4vFLkkbEM4SSpJHLzFspu4suBZ4AHA58Brge+EVEfLTr8s1J+Kf2YrB6G+V34Ym9xWAdz8pa9xDlrOVTOvp+r7cAq31WAZ+o3+4CHNm65/FUYBkwry7YptKUjSUiAnhD/XZho+o3l43WNpKkWcAFoSRpWsjM84CnU87GfQb4IfAoMBdYAPzPkJeTdjm7T/nLan5ax3jupDwGYz3gxR19z+8o612KuiQzb2m93mpgCbAhMGfiIU/KVI7l5cAOwPWZeU2jz9XADbXupVMzbEnSqLkglCRNG5m5MjO/nJlvzszdgN8H3gU8CDwTOGENX/r2PuVPBhL43z71Sxrt2u7oKHtgQF2zfuM+9WtqKsfS3EymbWGrjSRphvMeQknStJWZdwEfi4iHKPfyvWYNX2fF2g5lyLJh6h4PUzKWiNgE6O0++oaIeG2ryRNqflBEHFUvrZUkzWAuCCVJM8Himk/1pZZLgZ0ol0He1FG/Q81/PsXvO129Dtiyfv28Ae22AvajPKNQkjSDecmoJGnkhtik5Bk1X9oqX8Xa/XHzopq/oV1R71f8E8p9jJesxXvMJL1LQd+amdGVgDfXNj6TUJJmAReEkqTp4EN1J9Gd2hURsTPlGYIAZ7WqlwLbrcUOpCdTFnxHR8QejffciHKJ6mbAWZnZ7z68WSMi5gD7AKuBrwxo+lXKQnzfiNhmXYxNkvT4cUEoSZoOtqDsJHprRPwoIs6KiC9FxKXAjylnCK8Ejm/1O5tyhvCqiFgYEZ+NiAXDvml91MT7KffGXRoR50fE6ZQH3x8C3Ex5/MQ4OJSy6+i36w6rnTLzV5RdTTei+/mMkqQZxAWhJGk6+DDl2YNfBB4BXkF5mPwzgQuBtwIvzsx7W/3eA3yKsig8BDiCSW48k5knUO6HuxB4QX3flcBHgT0z85dr9k+acXqXi54xRNvTW30kSTNUZK7rjdAkSdIwImIxZXG8U2YuGe1ohhMR84HPA8dn5nGjHY0kaSLuMipJ0vT3zxFxP3BeZn5x1IPpEhEfBLannNWVJM0QLgglSZr+Dqj5cspltdPR64DdRj0ISdLkeMmoJEmSJI0pN5WRJEmSpDHlglCSJEmSxpQLQkmSJEkaUy4IJUmSJGlMuSCUJEmSpDHlglCSJEmSxpQLQkmSJEkaUy4IJUmSJGlMuSCUJEmSpDHlglCSJEmSxpQLQkmSJEkaUy4IJUmSJGlMuSCUJEmSpDHlglCSJEmSxpQLQkmSJEkaU/8PLYVik8Vg8OwAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(7,5), # <-- figsize gibt die Seitenlänge des Plots in\n", - " # Zoll (1 Zoll = 2.54 cm) wieder. (7,5) ist ein gutes Format für A4\n", - " dpi=150) # Auflösung des Plots\n", - "plt.errorbar(strom, \n", - " spannung,\n", - " xerr=strom_error,\n", - " yerr=spannung_error, \n", - " ls='', \n", - " marker='d', \n", - " mfc='orange', \n", - " mec='k', \n", - " ms=7,\n", - " ecolor='k', \n", - " elinewidth=2, \n", - " capsize=5, \n", - " capthick=2 \n", - " ) \n", - "\n", - "plt.ylabel('Spannung [V]')\n", - "plt.xlabel('Strom [mA]')\n", - "plt.show() " - ] - }, - { - "cell_type": "markdown", - "metadata": { - "ExecuteTime": { - "end_time": "2019-09-30T10:13:03.757411Z", - "start_time": "2019-09-30T10:13:03.316577Z" - } - }, - "source": [ - "### Linien in allen Arten und Farben:\n", - "\n", - "Das zweite nützliche Feature sind verschiedene Arten von Hilfslinien welche wir zu unserem Plot hinzufügen können. Fangen wir mit einem einfachen Gitternetz an dies könnt über `plt.grid` zu eurem Plot hinzufügen:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-06T12:31:33.590804Z", - "start_time": "2019-10-06T12:31:33.247151Z" - } - }, - "outputs": [], - "source": [ - "plt.errorbar(strom, \n", - " spannung,\n", - " xerr=strom_error,\n", - " yerr=spannung_error, \n", - " ls='', \n", - " marker='d', \n", - " mfc='orange', \n", - " mec='k', \n", - " ms=7,\n", - " ecolor='k', \n", - " elinewidth=2, \n", - " capsize=5, \n", - " capthick=2 \n", - " ) \n", - "\n", - "plt.ylabel('Spannung [V]')\n", - "plt.xlabel('Strom [mA]')\n", - "\n", - "plt.grid() # <-- Dieser Befehl fügt das Gitternet hinzu.\n", - "\n", - "plt.show" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Natürlich können wir auch für das Gitternet verschiedene Optionen spezifizieren:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-06T12:31:33.887611Z", - "start_time": "2019-10-06T12:31:33.590804Z" - } - }, - "outputs": [], - "source": [ - "plt.errorbar(strom, \n", - " spannung,\n", - " xerr=strom_error,\n", - " yerr=spannung_error, \n", - " ls='', \n", - " marker='d', \n", - " mfc='orange', \n", - " mec='k', \n", - " ms=7,\n", - " ecolor='k', \n", - " elinewidth=2, \n", - " capsize=5, \n", - " capthick=2 \n", - " ) \n", - "plt.ylabel('Spannung [V]')\n", - "plt.xlabel('Strom [mA]')\n", - "\n", - "\n", - "plt.grid(color='k', # Farbe \n", - " ls='dashed', # Linientyp\n", - " axis='x') # Axe\n", - "\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In kombination mit `plt.minorticks_on()` kann der Plot sehr detailreich gestaltet werden:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-06T12:31:34.418733Z", - "start_time": "2019-10-06T12:31:33.887611Z" - } - }, - "outputs": [], - "source": [ - "plt.errorbar(strom, \n", - " spannung,\n", - " xerr=strom_error,\n", - " yerr=spannung_error, \n", - " ls='', \n", - " marker='d', \n", - " mfc='orange', \n", - " mec='k', \n", - " ms=7,\n", - " ecolor='k', \n", - " elinewidth=2, \n", - " capsize=5, \n", - " capthick=2 \n", - " ) \n", - "\n", - "\n", - "\n", - "plt.ylabel('Spannung [V]')\n", - "plt.xlabel('Strom [mA]')\n", - "\n", - "plt.minorticks_on() # Aktiviert Unterskalenteile \n", - "plt.grid(which='minor', # <-- Grid für die kleinen Ticks \n", - " color='gray',\n", - " ls='dashed'\n", - " )\n", - "plt.grid(which='major',\n", - " color='gray',\n", - " ls='solid')\n", - "\n", - "plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Manchmal ist es ebenfalls sinnvoll besondere Linien einzuführen um Dinge hervorzuheben. Hierzu könnt ihr die Funktionen `plt.hlines` and `plt.vlines` für horizontale und vertikale Linien verwenden." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-06T12:31:35.026277Z", - "start_time": "2019-10-06T12:31:34.513883Z" - }, - "scrolled": true - }, - "outputs": [], - "source": [ - "plt.errorbar(strom, \n", - " spannung,\n", - " xerr=strom_error,\n", - " yerr=spannung_error, \n", - " ls='', \n", - " marker='d', \n", - " mfc='orange', \n", - " mec='k', \n", - " ms=7,\n", - " ecolor='k', \n", - " elinewidth=2, \n", - " capsize=5, \n", - " capthick=2 \n", - " ) \n", - "\n", - "\n", - "\n", - "plt.ylabel('Spannung [V]')\n", - "plt.xlabel('Strom [mA]')\n", - "\n", - "plt.minorticks_on() \n", - "plt.grid(which='minor', \n", - " color='gray',\n", - " ls='dashed'\n", - " )\n", - "plt.grid(which='major',\n", - " color='gray',\n", - " ls='solid')\n", - "\n", - "plt.vlines(400, # <-- Position für die vertikale Linie\n", - " 2, # <-- Start y-Wert\n", - " 4, # <-- End y-Wert\n", - " label='Line',\n", - " color='red',\n", - " ls='dashed'\n", - " )\n", - "\n", - "plt.hlines([2.2,3.4], # <-- Ihr könnt auch mehrere Linien plotten\n", - " 200, \n", - " 400, \n", - " label='horizontale Linen',\n", - " color='blue',\n", - " ls='dashed'\n", - " )\n", - "\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Mehr Text ist manchmal mehr Information:\n", - "\n", - "Als letztes möchte ich euch noch zeigen wir ihr auf zwei unterschiedliche Arten und weisen Texte zu eurem Plot hinzufügen könnt. Dies kann nützlich sein um besondere Messwerte hervorzuheben oder einfach zusätzliche Informationen unter zu bringen.\n", - "\n", - "Fangen wir mit `plt.annotate` an. Mit dieser Funktion können wir einen beschrifteten Pfeil in unseren Plot einfügen. Dies könnte zum Beispiel so aussehen:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-06T12:31:35.914992Z", - "start_time": "2019-10-06T12:31:35.387045Z" - } - }, - "outputs": [], - "source": [ - "plt.errorbar(strom, \n", - " spannung,\n", - " xerr=strom_error,\n", - " yerr=spannung_error, \n", - " ls='', \n", - " marker='d', \n", - " mfc='orange', \n", - " mec='k', \n", - " ms=7,\n", - " ecolor='k', \n", - " elinewidth=2, \n", - " capsize=5, \n", - " capthick=2 \n", - " ) \n", - "\n", - "\n", - "\n", - "plt.ylabel('Spannung [V]')\n", - "plt.xlabel('Strom [mA]')\n", - "\n", - "plt.minorticks_on() \n", - "plt.grid(which='minor', \n", - " color='gray',\n", - " ls='dashed'\n", - " )\n", - "plt.grid(which='major',\n", - " color='gray',\n", - " ls='solid')\n", - "\n", - "plt.annotate(f\"Messwertnummer {3 + 1}\", # Beschriftung des Pfeils\n", - " xy = (strom[3], spannung[3]), # Position der Pfeilspitze\n", - " xytext = (strom[3]-300, spannung[3] + 1), # Position des Textes (und des Pfeilendes)\n", - " arrowprops = {'arrowstyle': '->'}, # Style des Pfeils\n", - " fontsize=14)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Eine andere nützliche Art Beschriftungen in einen Plot hinzuzufügen stellt die Methode `plt.text` dar. Diese Methode ist insbesondere nützlich um Fitdaten in einen Plot zu zeigen. Führen wir zunächst wie in Kapitel 1. gezeigt einen Fit unsere Messdate durch:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-06T12:36:18.690010Z", - "start_time": "2019-10-06T12:36:17.672149Z" - } - }, - "outputs": [], - "source": [ - "from scipy.optimize import curve_fit" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-06T12:48:03.095908Z", - "start_time": "2019-10-06T12:48:03.080287Z" - } - }, - "outputs": [], - "source": [ - "para, pcov = curve_fit(Spannung, \n", - " strom, \n", - " spannung,\n", - " sigma=spannung_error, # <-- Diesesmal mit Fehler\n", - " absolute_sigma=True # <-- Diesen Option müssen wir auf Wahr setzen, da \n", - " # wir in der Regel absolute und keine relativen \n", - " # Unsicherheiten messen.\n", - " )\n", - "\n", - "chi2 = sum([ (Spannung(I,para[0]) - U)**2/dU**2 for I, U, dU in zip(strom, spannung, spannung_error)])\n", - "ndof = len(spannung) - len(para)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "ExecuteTime": { - "end_time": "2019-10-06T12:48:38.876540Z", - "start_time": "2019-10-06T12:48:38.345426Z" - } - }, - "outputs": [], - "source": [ - "plt.figure(figsize=(7,5))\n", - "plt.errorbar(strom, \n", - " spannung,\n", - " xerr=strom_error,\n", - " yerr=spannung_error, \n", - " ls='', \n", - " marker='d', \n", - " mfc='orange', \n", - " mec='k', \n", - " ms=7,\n", - " ecolor='k', \n", - " elinewidth=2, \n", - " capsize=5, \n", - " capthick=2,\n", - " label='Messwerte'\n", - " ) \n", - "\n", - "plt.plot(strom, \n", - " Spannung(strom, para),\n", - " color='Orange',\n", - " label='$U(I)=R \\cdot I$' )\n", - "\n", - "\n", - "\n", - "plt.ylabel('Spannung [V]')\n", - "plt.xlabel('Strom [mA]')\n", - "\n", - "plt.minorticks_on() \n", - "plt.grid(which='minor', \n", - " color='gray',\n", - " ls='dashed'\n", - " )\n", - "plt.grid(which='major',\n", - " color='gray',\n", - " ls='solid')\n", - "\n", - "\n", - "R = para[0] * 1000 # Widerstand in Ohm\n", - "deltaR = pcov[0][0]**(1/2)* 1000 # Fehler des Widerstands in hm\n", - "\n", - "plt.text(100, # <-- X-Position des Textes\n", - " 4.5, # <-- Y-Position des Textes\n", - " f'R: ({R:.2f} +/- {deltaR:.2f}) Ohm\\n$\\chi^2$/ndof: {chi2:.2f}/{ndof}', \n", - " fontsize=14\n", - " )\n", - "plt.legend()\n", - "plt.show()" - ] - } - ], - "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 -} diff --git a/documentation/Kapitel 0. Wie installiere ich Jupyternotebooks .md b/documentation/Kapitel 0. Wie installiere ich Jupyternotebooks .md deleted file mode 100644 index af47207..0000000 --- a/documentation/Kapitel 0. Wie installiere ich Jupyternotebooks .md +++ /dev/null @@ -1,59 +0,0 @@ - -# Kapitel 0.: Wie installiere ich Jupyter Notebooks ? - -## Installieren von IPython: - -Im allgemeinen empfiehlt es sich als Einsteiger **IPython** bzw. **Jupyter Notebooks** über [**Anaconda**](https://anaconda.org/) zu beziehen. **Anconda** ist dabei eine Art Verwaltungsumgebung für Pyhton. Über Anconda könnt ihr eure Packages verwalten, Notebooksteilen und verschiedene Entiwcklungsumgebungen ausprobieren. Im folgenden wollen wir uns speziellen die **Jupyter**-Umgebung beschränken. Leider können wir aus zeitlichen Gründen nicht genauer auf Anaconda eingehen. Ihr könnt aber viele nützliche Videos auf Youtube finden bzw. einen Blick in die [Dokumentation](https://docs.anaconda.com/anaconda/) werfen. - -Da es sich bei **Jupyter-Notebooks** um eine Webanwendung handelt, empfiehlt es sich auch einen gescheiten Browser zu nutzen. Zu empfehlen wären hier entweder **Firefox** oder **Google Chrome**. - -### Installieren unter Windows: - -Hier eine kurze Anleitung für das installieren von Jupyter unter Windows: - -1. Geht auf **https://www.anaconda.com/download/** und klickt auf den großen grünen Button unter Python 3.7 und started den download. - - - -2. Führt die `Anaconda3-2019.07-Windows-x86_64.exe` aus und folgt den Instellationsanweiungen. - * Sofern ihr nicht den Standardpfad verwenden wollt, könnt ihr auch euren Wunschpfad während der Installation angeben. - * Folgt anschließend der Installation mit den Standardeinstellungen. - * Am Ende werdet ihr noch gefragt ob ihr *Microsoft Visual Studio Code* installiern wollt. Diesen Schritt könnt ihr überspringen. -3. Glückwunsch ihr habt die Installation erfolgreich abgeschlossen. Ihr könnt IPython bzw. das Jupyter-Interface starten über Anaconda starten. Hierzu sucht entweder in der Suchleiste nach Anaconda, oder sofern ihr eine Verknüpfung in die Startleiste oder Desktop erstellt habt klickt ihr auf das Anaconda Logo. - -4. Habt ihr Anaconda gestartet seht ihr nun das folgende Fenster: - - - - * Im roten Kasten markiert mit der 1. seht ihr eure jetzige Programmierumgebung. Gerade für unterschiedliche Projekte kann es sich lohnen verschiedene projektspezifische Umgebungen anzulegen. Für euer Studentenalltag ist dies eher nicht der Fall, hier könnt ihr einfach die Standardumgebung verwenden. - * Über den *Launch*-Button markiert mit dem zweiten roten Kasten könnt ihr ein jupyter-notebook starten. Dieses wird sich in eurem Browser öffnen. - -5. Im laufe des Kurses werden verschiedene so genannte "Packages" kennen lernen. Diese Pakete stellen uns je nach Zweck unterschiedliche und nützliche Funktionen zur Verfügung und werden in eurer Programmierumgebung gespeichert. Solltet ihr mal ein weiteres Paket installieren möchten ist dies relative einfach. Klickt hierfür zunächst den Button "Environments" an. Dies öffnet das folgende Fenster: - - - - * Über "Create" (gekennzeichnet mit der 0.) könnt ihr für eine neues Projekt eine neue Umgebung erstellen. - * Sofern ihr nur eine bestehend Umgebung mit einem neuen Paket erweitern möchtet geht wie folgt vor: - * Klickt die Umgebung an (Kasten 1.) - * Wechselt in dem zweiten roten Kasten von *Installed* zu *Not Installed*. - * Sucht mit Hilfe des Suchfeldes in Kasten 3. nach dem Paket/en euer Wahl und setzt für dieses/diese ein Häkchen (Kasten 4.). Anschließen drückt auf das grüne Feld *Apply*. - -### Installation unter Linux: - -Die Installationsanweisung für LINUX können [hier](https://docs.anaconda.com/anaconda/install/linux/) gefunden werden. - -1. Geht auf die Anconda Donwloadseite **https://www.anaconda.com/download/** wechselt auf LINUX und klickt auf den großen grünen Button unter Python 3.7 und started den download. -2. Nach dem ihr die Datei gedownlaoded habt installiert ihr sie mit dem Kommando `~/Downloads/Anaconda3-2019.07-Linux-x86_64.sh` folgt den Installtionsanweisungen. - * Sofern ihr den Standardpfad ändern möchtet könnt ihr dies tun. Ihr solltet lediglich aufpassen, dass der angegebene Pfad nur ein Dateipräfix ist welchem anaconda3 am Ende angefügt wird. - * Am Ende der Installation werdet ihr gefragt ob die `PATH`-Variable von anaconda eurer .bashrc angefügt werden soll. Dies solltet ihr bejahen. Solltet ihr den `PATH`-Eintrag manuell setzten wollen so könnt ihr dies auch tun indem ihr eurer .bashrc um den Eintrag `PATH=EurenPfadname\anaconda3\bin:$PATH` erweitert. -3. Sofern ihr den `PATH` richtig gesetzt habt könnt ihr dies testen in dem ihr im terminal conda list eintippt. Anschließend sollte eine Auflistung von allen installierten python packages erscheinen. -4. Glückwunsch ihr habt die Installation erfolgreich abgeschlossen. -5. Ihr könnt nun jupyter-notebooks über das Kommando `jupyter-notebook` in eurem Terminal starten. - -### Installation ZDV-Rechner: - -1. Sucht in der Suchleiste von Windows 10 nach den ZDV Apps V5. -2. Öffnet anschließend die **ZDV-Apps** Verwaltung. -3. Sucht innerhalb der Appverwaltuung nach **Jupyter** und fügt es zu euren Apps hinzu. -4. Meldet euch von eurem Rechner ab und wieder an, damit euren neuen Apps geladen werden. -5. Startet nun Jupyter über das entsprechende Symbol, oder sucht danach wieder in der Windows 10 Suchleiste. \ No newline at end of file