From 8cfec48172890b0a6c6b5af95d59f7746a2c8641 Mon Sep 17 00:00:00 2001
From: Daniel Hahn <daniel.hahn@tu-braunschweig.de>
Date: Tue, 24 Jan 2023 16:34:22 +0100
Subject: [PATCH] added Uebung10

---
 Uebung10/Grundlagen_Dateien.ipynb | 1183 +++++++++++++++++++++++++++++
 Uebung10/Uebung_10.ipynb          |  493 ++++++++++++
 Uebung10/Uebung_10_LSG.ipynb      |  587 ++++++++++++++
 3 files changed, 2263 insertions(+)
 create mode 100644 Uebung10/Grundlagen_Dateien.ipynb
 create mode 100644 Uebung10/Uebung_10.ipynb
 create mode 100644 Uebung10/Uebung_10_LSG.ipynb

diff --git a/Uebung10/Grundlagen_Dateien.ipynb b/Uebung10/Grundlagen_Dateien.ipynb
new file mode 100644
index 0000000..ac57dc1
--- /dev/null
+++ b/Uebung10/Grundlagen_Dateien.ipynb
@@ -0,0 +1,1183 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "f0b13807-b3b2-4f55-9581-9f8d4ffaa3b5",
+   "metadata": {},
+   "source": [
+    "### <font color='blue'>**Einleitendes Thema**</font>\n",
+    "Sehr oft ist es notwendig, erzeugte Daten nicht nur temporÃ¤r im Speicher zu haben, sondern permanent auf der Festplatte abzuspeichern und auch weiterversenden zu kÃ¶nnen. Das ermÃ¶glicht die Nutzung von Daten in verschiedenen Programmen (z.B. Berechnung und Auswertung, nicht auf Python beschrÃ¤nkt), von verschiedenen Personen oder der langfristigen Sicherung, damit nicht alle Berechnungen neu durchgefÃ¼hrt werden mÃ¼ssen, wenn nach einiger Zeit ein neuer Aspekt oder in einer anderen Darstellungsform ausgewertet werden soll."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "78480fdf-603c-48e5-b671-5b634c94fbaa",
+   "metadata": {},
+   "source": [
+    "### <font color='blue'>**Kompaktes Fallbeispiel**</font>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "c54061cb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[['Zahl', 'Quadratzahl'], [0.0, 0.0], [1.0, 1.0], [2.0, 4.0], [3.0, 9.0], [4.0, 16.0], [5.0, 25.0], [6.0, 36.0], [7.0, 49.0], [8.0, 64.0], [9.0, 81.0], [10.0, 100.0]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "In diesem Beispiel wird eine Datenreihe in einer CSV (comma-separated-value) Datei abgespeichert.\n",
+    "Diese kann mit anderen Programmen geoeffnet (und auch bearbeitet) werden.\n",
+    "Anschliessend wird die Datei eingelesen und das eingelesene Feld ausgegeben.\n",
+    "\"\"\"\n",
+    "\n",
+    "# Hilfreiche Bibliothek fuer die arbeit mit csv\n",
+    "import csv\n",
+    "\n",
+    "# Beispiel-Datenreihe\n",
+    "quadratzahlen = [[0,0], [1,1], [2,4], [3,9], [4,16], [5,25], [6,36], [7,49], [8,64], [9,81], [10,100]]\n",
+    "\n",
+    "#Schreiben der Datei\n",
+    "with open('quadratzahlen.csv','w', newline='') as f: \n",
+    "    writer = csv.writer(f, quoting=csv.QUOTE_NONNUMERIC, delimiter = ';') # Instanziieren eines Objekts, das die Schreib-Methoden enthaelt\n",
+    "    writer.writerow(['Zahl','Quadratzahl']) # Ãœberschriften, damit die Datei noch nachvollzogen werden kann\n",
+    "    writer.writerows(quadratzahlen) # Schreiben der Daten selbst\n",
+    "    \n",
+    "\"\"\"\n",
+    "Tipp:\n",
+    "Oeffne die Datei in einem Tabellenkalukationsprogramm (z.B. Excel, Open Office Calc oder Mac Numbers.)\n",
+    "Es kann sein, dass das Komma auf deutschen Systemen als Dezimalzeichen erkannt wird, deswegen verwenden wir hier \";\" als Trennzeichen (Standard bei Excel).\n",
+    "Es gibt aber auch Moeglichkeiten, wenn \",\" verwendet wird.\n",
+    "In Excel ist es zum Beispiel am einfachsten, die CSV als Datenimport einzulesen, dabei kann das Trennzeichen gewaehlt werden\n",
+    "Man sollte eine Tabelle mit den beiden Spalten erhalten.\n",
+    "\n",
+    "Oder Ã¶ffne die Datei in einem Texteditor, dann siehst du, wie die Daten im csv Format abgelegt sind\n",
+    "\"\"\"\n",
+    "\n",
+    "rows = [] # Hier lesen wir gleich die Daten ein\n",
+    "\n",
+    "#Lesen der Datei\n",
+    "with open(\"quadratzahlen.csv\",'r', newline='') as f:\n",
+    "    reader = csv.reader(f, quoting=csv.QUOTE_NONNUMERIC, delimiter = ';') # Instanziieren eines Objekts, das die Lese-Methoden enthaelt\n",
+    "    for row in reader: \n",
+    "        rows.append(row) # Jede Zeile wird an row angehaengt\n",
+    "\n",
+    "imported_quadratzahlen = rows # Dies ist nur zum Verdeutlichen, dass wir die Zahlen aus der Datei importiert haben\n",
+    "print(imported_quadratzahlen) # Ausgabe der Zahlen"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9837909c-0cc2-43bd-9692-bb149a7a87ba",
+   "metadata": {},
+   "source": [
+    "# <font color='blue'>**Ãœbersicht - \"Dateien\"**</font>\n",
+    "\n",
+    "Es gibt sehr viele verschiedene Datenformate. Wir werden in diesem Notebook zunÃ¤chst das allgemeine Schreiben und Lesen von Dateien in Python behandeln, und anschlieÃŸend auf ein paar gÃ¤ngige Dateiformate und dazu passende Module in Python eingehen. Allerdings kann dieses Notebook nur einen groben Ãœberblick geben, da es unzÃ¤hlige MÃ¶glichkeiten zur Arbeit mit Dateien und den entsprechenden Modulen gibt. Das Grundlagennotebook gibt einen EinstiegsÃ¼berblick und beinhaltet nÃ¼tzliche Funktionen."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3b34e520-f385-4530-b2c7-4b6df641d72b",
+   "metadata": {},
+   "source": [
+    "### <font color='blue'>**Lernziele des Notebooks**</font>\n",
+    "* ASCII Dateien\n",
+    "    * Allgemeine Textdateien\n",
+    "    * typische Formate\n",
+    "        * csv\n",
+    "        * json\n",
+    "        * xml\n",
+    "* BinÃ¤rdateien mit Pickle"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f6012101-a726-4880-8bbc-ccfee49d9ceb",
+   "metadata": {},
+   "source": [
+    "# <font color='blue'>**\"ASCII-Dateien\"**</font>\n",
+    "\n",
+    "ASCII-Dateien sind Dateien, in denen ausschlieÃŸlich lesbare Zeichen (Text mit Zahlen und Sonderzeichen) enthalten ist. ASCII selbst ist der Standard zur Zuordnung von Zeichen (also Buchstaben, Sonderzeichen, etc.) zu den jeweiligen BinÃ¤rzahlen im Speicher. Solche Dateien kann man mit Texteditoren Ã¶ffnen und lesen.\n",
+    "\n",
+    "Im Gegensatz dazu stehen BinÃ¤rdateien, in denen kein lesbarer Text enthalten ist. Solche Dateien kÃ¶nnen nur (sinnvoll) von Programmen geÃ¶ffnet werden, die wissen, wie die BinÃ¤rdatei aufgebaut ist (wo Zahlen stehen, wo Texte stehen, was diese Bedeuten usw.). Ã–ffnet man BinÃ¤rdateien in einem Texteditor, sieht man als Mensch nur wirre Zeichen.\n",
+    "\n",
+    "Bei ASCII-Dateien ist klar definiert, dass alle darin enthaltenen BinÃ¤rzahlen als Zeichen ausgewertet und angezeigt werden. Deshalb werden sie auch \"human-readable\" also \"von Menschen lesbar\" bezeichnet. Dass man sie mit Texteditoren Ã¶ffnen und lesen kann, bedeutet nicht, dass ASCII-Dateien nur fÃ¼r Texteditoren gut sind. Man kÃ¶nnte zum Beispiel ein Bild in einer ASCII-Datei speichern, indem man in der Datei zunÃ¤chst die BildhÃ¶he und Bildbreite in Pixeln angibt, und eine Liste anschlieÃŸt, in der die Helligkeitswerte fÃ¼r jeden Farbkanal (rot, grÃ¼n, blau) fÃ¼r jeden Pixel aufgelistet sind. Eine solche Datei kÃ¶nnte man in einem Texteditor Ã¶ffnen und die vielen Zahlen ansehen, oder in einem (kompatiblen) Programm zur Bildbetrachtung Ã¶ffnen, das weiÃŸ, wie es diese Informationen als Bild darstellen kann, und als Bild ansehen (fÃ¼r Interessierte: https://de.wikipedia.org/wiki/Portable_Anymap)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "97a85106-b815-4d8b-bc87-ecd93aae5312",
+   "metadata": {},
+   "source": [
+    "### **<font color='blue'>Grundlagen</font>**\n",
+    "\n",
+    "Python bringt standardmÃ¤ÃŸig bereits Werkzeuge zum Schreiben und Lesen von ASCII Dateien mit. Eine Datei wird mit dem Befehl ````open(dateiname)````  geÃ¶ffnet (falls sie im aktuellen Verzeichnis nicht existiert, wird sie dort angelegt). Diese hat neben dem bereits oben aufgefÃ¼hrten Dateinamen der zu Ã¶ffnenden Datei einige optionale Parameter, von denen der erste, ````mode```` der wichtigste ist. Mit diesem wird festgelegt ob gelesen oder geschrieben werden soll.\n",
+    "\n",
+    "|mode|Bedeutung|\n",
+    "|----|:----|\n",
+    "|\"r\"| lesen |\n",
+    "|\"w\"| schreiben (Ã¼berschreibt bisherige Datei mit dem gleichen Namen) |\n",
+    "|\"a\"| schreiben (fÃ¼gt den Inhalt an bisherige Datei mit dem gleichen Namen an)|\n",
+    "|\"x\"| schreiben (nur, falls bisher keine Datei mit dem gleichen Namen gibt, sonst Fehler)|\n",
+    "|\"b\"| (angehÃ¤ngt) im BinÃ¤rformat |\n",
+    "\n",
+    "Der Befehl ````open()```` gibt ein Objekt zurÃ¼ck, mit dem die Datei bearbeitet werden kann. Eine geÃ¶ffnete Datei wird im Betriebssystem blockiert, sodass kein Anderes Programm gleichzeitig darauf zugreifen kann. Es kÃ¶nnten sonst korrupte Dateien entstehen. Daher mÃ¼ssen Dateien nach dem Ã–ffnen und Bearbeiten geschlossen werden. In Python gibt es dafÃ¼r eine praktische Methode: Das ````with````. Der Befehl lautet voll ````with open(dateiname, mode) as f:```` und Ã¶ffnet einen Block, an dessen Ende die Datei automatisch geschlossen wird. f ist dabei der Name des Objekts (er kÃ¶nnte beliebig anders sein. Ebenfalls typisch ist ````fid```` (abk. file identifier)). Mit diesem Objekt kÃ¶nnen nun zum Beispiel mit ````write(string)```` analog zu print Zeichenketten in die Datei (anstatt auf den Bildschirm) geschrieben werden. Mit ````readlines()```` kann eine Liste mit allen Zeilen ausgelesen werden. Wie die entsprechenden Daten formatiert, oder verarbeitet werden ist vollstÃ¤ndig frei."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "9161b653",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Die erste Zeile.\n",
+      "\n",
+      "In der dritten Zeile werden nun drei Zahlen stehen.\n",
+      "\n",
+      "1 2 3\n",
+      "['1', '2', '3']\n",
+      "Die Summe der 3 Zahlen: 6\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Erstellen einer Datei und schreiben von Text\n",
+    "with open(\"eine_erste_datei.txt\",\"w\") as f:\n",
+    "    f.write(\"Die erste Zeile.\\n\")\n",
+    "    f.write(\"In der dritten Zeile werden nun drei Zahlen stehen.\\n\")\n",
+    "    f.write(\"1 2 3\")\n",
+    "    \n",
+    "# Die Datei sollte im Ordner zu finden sein und geoeffnet werden koennen\n",
+    "\n",
+    "# Lesen der Datei\n",
+    "with open(\"eine_erste_datei.txt\",\"r\") as f:\n",
+    "    zeilen = f.readlines()\n",
+    "\n",
+    "# Nun koennen wir die Daten beliebig weiterverwenden\n",
+    "# 1. Einfach auf dem Bildschirm ausgeben):\n",
+    "\n",
+    "for zeile in zeilen:\n",
+    "    print(zeile)\n",
+    "\n",
+    "# Alternative, in der nicht jeder Zeilenumbruch doppelt ausgefÃ¼hrt wird (Zeilenumbruch in Datei + neuer print-befehl)\n",
+    "# for zeile in zeilen:\n",
+    "#    print(zeile, end = \"\")\n",
+    "\n",
+    "# 2. Die Zahlen der 3. Zeile zusammenzaehlen. Hierbei muessen wir ein paar Funktionen nutzen, um die Zeichenkette \"1 2 3\"\n",
+    "# zu 3 getrennten Zahlen umzuwandeln. Das ist zunÃ¤chst die Methode \"split()\", die eine Zeichenkette aufteilt [...]\n",
+    "\n",
+    "zahlen_zeichen = zeilen[2].split()\n",
+    "print(zahlen_zeichen) # Kontrollausgabe\n",
+    "\n",
+    "# [...] und die Funktion \"int()\", die ein Zahlenzeichen in eine Ganzzahl umwandelt. Wir bilden direkt in einer Schleife die Summe.\n",
+    "\n",
+    "summe = 0\n",
+    "for zahl_zeichen in zahlen_zeichen:\n",
+    "    summe += int(zahl_zeichen)\n",
+    "\n",
+    "print(f\"Die Summe der 3 Zahlen: {summe}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c2847319",
+   "metadata": {},
+   "source": [
+    "Die gezeigte Methode ````split()```` in einer Zeichenkette teilt diese standardmÃ¤ÃŸig an den Leerzeichen in eine Liste von Zeichenketten auf. Hat man andere Trennzeichen, so kann man das Trennzeichen (bzw. die Trennzeichenkette) als Parameter Ã¼bergeben:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "ecaec008",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['Das ist eine typische Trennung bei Zahlenwerten:', '1', '2.5', '4', '5.5']\n",
+      "['Das', 'ist', 'eine', 'untypische', 'Trennung']\n"
+     ]
+    }
+   ],
+   "source": [
+    "text_typischer_trennung = \"Das ist eine typische Trennung bei Zahlenwerten:;1;2.5;4;5.5\"\n",
+    "print(text_typischer_trennung.split(\";\"))\n",
+    "\n",
+    "#Das soll nur die allgemeine Moeglichkeit demonstrieren\n",
+    "text_untypischer_trennung  = \"DasTRENNUNGistTRENNUNGeineTRENNUNGuntypischeTRENNUNGTrennung\"\n",
+    "print(text_untypischer_trennung.split(\"TRENNUNG\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a11a3c0e",
+   "metadata": {},
+   "source": [
+    "Mit diesen Grundlagen kann man fÃ¼r seine Programme bereits nahezu alles abspeichern und auch wieder einlesen, sofern man sich Ã¼berlegt, wie die Datei strukturiert wird."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d6dd17cb",
+   "metadata": {},
+   "source": [
+    "### **<font color='blue'>Typische Datenformate</font>**\n",
+    "\n",
+    "Es bietet sich an, nicht fÃ¼r jeden Anlass ein komplett neues Prinzip der Dateistruktur ( = Format) auszudenken. Viele Dinge sind fÃ¼r viele DatensÃ¤tze gleich. So gibt es standardisierte Datenformate fÃ¼r verschiedene Zwecke. Ein groÃŸer Vorteil, diese zu verwenden, liegt darin, dass in Python (sowie anderen Sprachen und Programmen) Module zu VerfÃ¼gung stehen, die diese Dateien unterstÃ¼tzen. In Python kÃ¶nnen wir so einfacher solche Daten Schreiben und Auslesen und mÃ¼ssen nicht jedes Zeichen einer potentiell ausgedachten Datenstruktur manuell auswerten. Das gleiche gilt fÃ¼r andere Sprachen. In anderen Programmen, kann das Format ggf. auch eingelesen werden. Zum Beispiel haben Tabellenkalkulationsprogramme wie Excel die MÃ¶glichkeit CSV-Dateien zu laden.\n",
+    "\n",
+    "Wir wollen nun 3 Formate ansehen. csv, json und xml. Alle diese Formate sind ASCII-Dateien und weit verbreitet. Wir werden zunÃ¤chst die Dateieformate zeigen und danach ein bisschen in die passenden Python Pakete sehen. Theoretisch kÃ¶nnte man auch jedes dieser Formate manuell schreiben (programmieren). In diesem Notebook geht es nicht darum, alle Details dazu zu erfassen, sondern hauptsÃ¤chlich, diese Formate mal gesehen zu haben. Sehr wahrscheinlich wird man dem ein oder anderen Format davon spÃ¤ter in Studium, Beruf oder Freizeit noch mal begegnen.\n",
+    "\n",
+    "Hier zunÃ¤chst ein grober Ãœberblick Ã¼ber die Eigenschaften:\n",
+    "* csv (comma separated value)\n",
+    "    * geeignet fÃ¼r Datenreihen in Tabellenform\n",
+    "    * Sehr Speicherplatz schonend\n",
+    "* json (JavaScript Object Notation)\n",
+    "    * geeignet fÃ¼r jegliche hierarchische Daten\n",
+    "    * trotz \"JavaScript\" im Namen fÃ¼r alle Sprachen geeignet\n",
+    "    * Speicherplatz schonend\n",
+    "    * erfÃ¤hrt zunehmend weite Verbreitung, ist in vielen neuen Programmen/Systemen der Standard\n",
+    "* xml (extensible markup language)\n",
+    "    * geeignet fÃ¼r jegliche hierarchische Daten\n",
+    "    * benÃ¶tigt mehr Speicherplatz als json\n",
+    "    * weit verbreitet, ist in vielen Ã¤lteren Programmen/Systemen der Standard\n",
+    "    \n",
+    "### **<font color='blue'>Beispiele</font>**\n",
+    "\n",
+    "#### **<font color='blue'>Beispiel: Tabelle</font>**\n",
+    "\n",
+    "Wir wollen uns die Datenformate nun anhand zweier (programm-unabhÃ¤nger) BeispieldatensÃ¤tze ansehen. Das erste Beispiel sind Datenreihen fÃ¼r Ergebnisse eines Kart-Rennens:"
+   ]
+  },
+  {
+   "attachments": {
+    "Karting.PNG": {
+     "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPUAAABVCAYAAACRraKLAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAfWSURBVHhe7ZxLkqM6EEW9Li/I6/G0o7q24ZX0rOa1DZpESpCEPpAp+SPdE6F4jbEp65IHgR/i8vv7O1H7+/fv8l80WUN+uob8dM3N7/L9/T19fX1Nf/78QUND66CtIzUtADmXy8X+C0j49++f/Rc4C9WeW3+QuhKQWgeklgOpGwGpdUBqOZC6EZBaB6SWA6kbAal1QGo5kLoRL5f6cZsu1/v0Yxc/jZdL/cH5HZb6cbtM17vTRer05Tq5L53h536dLreHXeoPX+qf6X41QW/tNjXtvbIol/0zf09vnz8RX+rPyo+z4/bsMue/yxyT+uc+XZVfdkSpXUEoz6b9FxflY7rN3/16f+y+8zOJSf0R+ZEbzueM4I0PQAECqc1O3+VpRecNbuvp/fOIfqeRndZd505v76P2qsJpCfVrY1+UftGY9V6m0fUme87Ri83L3+btFaXZBmdeLrTId34iJanfPz/Lst3gbzWGvyNTkDp19J7DcgJYjk7rMgfphzD2SG0LZO3/saJ0C9EfqcLt28ydfRKObP4+ihFu87nkpbZ5vHV+Fvoe7zxSmzcfOOosRyfuiAnIC3xmRKk5bGq+LMeKMrney9uyWx/uN9ovuX0ZFvpzKV1Tv39+xGsy5IyY4un3ImPkyGNed4OH1BvBzqWC8TJUFuVuezO7onT3DbfPkvqz8qNNzO9Zv8Pz4O/HHLimNgF5QoaheEc+SM2ZbYLEl8VFeWikCdYXCb/jczly+v3O+b1KaEIg9bK0iLouUwBOp5cOrcsZqV/U6WeQl3omlhmHtBSRWxSlog32R+Lz3t8vIvlMPQ79UPaW+Zn3bp99PkKpZ2zHOSgjsmnX+30OKS/1Gtzy/ld1vx1uqPGiCHMxyybDOTuv6EpFOePkuXyelr3CssW2vmdu0cJzv8fWnr2PilK/a360Xfc93HYCtIP/JpOUGpzDDRWcx5canAFSNwJS64DUciB1IyC1DkgtB1I3AlLrgNRydlK7zyjjlWhoaJ/X6MBIDSN1JShUIAcjtRyWmoHUlYDUOiC1HEjdCEitA1LLgdSNgNQ6ILUcSN0ISK0DUsuB1I2A1DogtRxIrYCnm8bui+5T6sj9z8E9zf4U3NTUxPJ2+pQ61+9yJiup+8vtfAteZiD1IczkgdxzvNxQ+8EUXqrWjs+8y2+H6FnqeL/LmeRwZ6lBahVmR0Bqgg50pSeBMJB6j0LqZYbZlj2kVjGm1Fw03um1LSzvoZLJCs1sxzLG6bfb73ImKby55DO8DQZSn2I0qX3M9bO5jjPXeaHkx0YebzuWEX4oi/Wbya3zCeeVQ2olY0vtFdQitVuE6Wz27AtzBKlj/d7IrduI/Y4BqVUMLrV7LRdc152SevfZQaSO9Hslt24lLj6kVjGW1I+bX2TLtdw6SgRZeKfjZh1f9+W3Y+hR6ly/j2Qb/kaROkWH1CLMEZLD4+bK7YbaDeH/Hw1ENKPLtn6rwaAoS9uZ6XKkzvU7m0lMalODqQGFGgOpK+GGCs4zxjV1GyB1IyC1DkgtB1I3AlLrgNRyIHUjILUOSC1nJ7X7jDIKFk3WKNTY62horRtLvS5jpK6De6QE56FiBDJYagZSVwJS64DUciB1IyC1DkgtB1I3AlLrgNRyIHUjILUOSC0HUjcCUuuA1HIgtRBzM70Jj1pwr70Xaj/Ye5Cdfm/3I+fW7Snl16fU9fIjOMPw/m/+PAOpj0ATF5wb7mOzZdxQ+8EUXrzWcusCDuTXs9Tq/NbJHPFn5EHqGkTmvkLqE0Tyg9RHMJ+B1C1Yps2NM1Jz0dR6xlYsvzFOv7X5QepGpIPtndhpM5Nb5xPPb4QfyvT5QeomxJ7aQYwgNV/bxU8Zc+s2UvmNILU+P0hdnVRBEkNIHbkWXsmts+TyG0JqZX6QuiomzFRBEj1KXe8ZW+X8epS69jPKIHVNwudJcXNCp+XuqPWMrQP5dTlS18rPnpp7758by83LDKSuhBsqOM8Y19RtgNSNgNQ6ILUcSN0ISK0DUsuB1I2A1DogtZyd1HhGWZ1GocZeR0Nr3VjqdRkjdR3cIyU4DxUjkMFSM5C6EpBaB6SWA6kbAal1QGo5kLoRkFoHpJYDqRsBqXVAajmQuhGQWgeklgOphZj5ria82LzXPqW29yCv/Z5b6X7uzJxgzjCckED0KXUmP4tfV+lZWrn649cZSH2Ix3RzbrhfZtQEO8cNtR9MUQZdTRLLxWAmJKSesUX0LHUqv0VUbyJHinz9QeoKxHbG8FIr5gMT40lNB7pSXnHC+oPUanjU8fdGz1Jz0eROD9OjtMuYUkfzswfBq7v+0NFzX3/8eQZSH8W9hoyE74baK+a6LnbNbAqtXJOjSe3j5bfUUyh5JsNM/fHrDKQWECvuEaROyRu7HIkzttRefoukbg2lswkJ6w9S1yBy/TiE1NHr5qOjNDG41G5+uyyPSx1+FlJLoBCdqh1lpM4/R8sQy4ILdH+ZMpbUR55DtmbhnY4H+RXqD1KLsCHb8GI/GPUotSk0p9+7U+z9jzaGUGrzPm9bwee6HKlL+S0j7rZ+8zbML19//DoDqSvhhgrOM8Y1dRsgdSMgtQ5ILQdSNwJS64DUciB1IyC1DkgtJys1r0RDQ/u8xngPHoy9EQ0N7TMane1Qw+l3JXD6qAP56XDzg9SVQFHqQH46tvym6T9R+Am8HiBB1wAAAABJRU5ErkJggg=="
+    }
+   },
+   "cell_type": "markdown",
+   "id": "238f45d7",
+   "metadata": {},
+   "source": [
+    "![Karting.PNG](attachment:Karting.PNG)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ab2d96dc",
+   "metadata": {},
+   "source": [
+    "#### **csv**\n",
+    "\n",
+    "Csv steht fÃ¼r \"Comma separated value\", also \"durch Kommata getrennte Werte\". Dieser Name ist etwas streng, man mÃ¼sste eher \"durch Trennzeichen getrennte Werte\" dazu sagen. Oft wird nÃ¤mlich kein Komma, sondern ein Semikolon genutzt. Typischerweise wird so eine Datei in Spalten und Zeilen aufgeteilt, wobei die Spalten durch das gewÃ¤hlte Trennzeichen und die Zeilen durch einen Zeilenumbruch getrennt werden. Die Kartergebnisse sÃ¤hen z.B. folgendermaÃŸen aus.\n",
+    "\n",
+    "```\n",
+    "\"Kart\",\"Runde 1\",\"Runde 2\"\n",
+    "1,56.5,55.7\n",
+    "2,55.2,55.1\n",
+    "3,57.1,56.3\n",
+    "```\n",
+    "\n",
+    "Hier ist als Trennzeichen das \",\" gewÃ¤hlt, und Texte sind in AnfÃ¼hrungszeichen gestellt. Das wÃ¤re nicht zwingend nÃ¶tig, erleichtert aber die automatisierte Auswertung, da klar ist, was als Zahl ausgewertet werden soll und was nicht. Aufgrund der minimalistischen Schreibweise, in der fast nur die Werte ohne ErklÃ¤rung stehen, ist das Format sehr speicherplatzschonend. CSV Daten kÃ¶nnen von den gÃ¤ngigen Tabellenverarbeitungsprogrammen gelesen und geschrieben werden."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b67df868",
+   "metadata": {},
+   "source": [
+    "#### **json**\n",
+    "\n",
+    "Json steht fÃ¼r \"JavaScript Object Notation\". Trotz Javascript im Namen kann das Format in jeder Sprache genutzt werden. Das Format ist fast identisch mit (verschachtelten) Dictionaries und Listen in Python. Es gibt immer einen SchlÃ¼ssel (key) und den dazugehÃ¶rigen Wert hinter einem Doppelpunkt. Dieser Wert kann auch eine Liste von Werten, oder von Dictionaries sein.\n",
+    "Kleie Unterschiede zur Python Darstellung sind z.B. das kleine ````true```` oder ````false```` (in Python groÃŸ: ````True````,````False````) oder ````null```` statt Pythons ````none````. Das Ã¤uÃŸerste Element kann entweder eine Liste oder ein Dictionary sein. \n",
+    "\n",
+    "Die Kartergebnisse sÃ¤hen z.B. folgendermaÃŸen aus.\n",
+    "\n",
+    "```\n",
+    "[\n",
+    "    {\n",
+    "        \"Kart\": 1,\n",
+    "        \"Runde 1\": 56.5,\n",
+    "        \"Runde 2\": 55.7\n",
+    "    },\n",
+    "    {\n",
+    "        \"Kart\": 2,\n",
+    "        \"Runde 1\": 55.2,\n",
+    "        \"Runde 2\": 55.1\n",
+    "    },\n",
+    "    {\n",
+    "        \"Kart\": 3,\n",
+    "        \"Runde 1\": 57.1,\n",
+    "        \"Runde 2\": 56.3\n",
+    "    }\n",
+    "]\n",
+    "```\n",
+    "\n",
+    "Die EinrÃ¼ckungen sind optional und dienen der Lesbarkeit. Es braucht etwas mehr Speicherplatz als csv, da jeder Key wiederholt wird. Diese Liste von Ergebnissen kÃ¶nnten wir zum Beispiel direkt in Python einlesen und so verwenden, als hÃ¤tten wir sie in Python angelelegt. JSON wird zunehmend auf breiter Basis eingesetzt."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a0dc8519",
+   "metadata": {},
+   "source": [
+    "#### **xml**\n",
+    "\n",
+    "Xml steht fÃ¼r \"Extensible Markup Language\". Das Format wurde als Menschen- und Maschinenlesbares Format fÃ¼r hierarchische Daten entwickelt. Das Prinzip basiert auf dem Ã–ffnen und SchlieÃŸen von *tags*, die gewissermaÃŸen die Knoten in einer Baumstruktur darstellen. GeÃ¶ffnet wird mit ````<tag_name>````, geschlossen wird mit ````</tag_name>````. Die Daten stehen als freier Text zwischen den tags. Die Kartergebnisse sÃ¤hen z.B. folgendermaÃŸen aus:\n",
+    "```\n",
+    "<Ergebnisse>\n",
+    "  <Kart>\n",
+    "    <Nr>1</Nr>\n",
+    "    <Runde 1>56.5</Runde 1>\n",
+    "    <Runde 2>55.7</Runde 2>\n",
+    "  </Kart>\n",
+    "    <Nr>2</Nr>\n",
+    "    <Runde 1>55.2</Runde 1>\n",
+    "    <Runde 2>55.1</Runde 2>\n",
+    "  <Kart>\n",
+    "  </Kart>\n",
+    "  <Kart>\n",
+    "    <Nr>3</Nr>\n",
+    "    <Runde 1>57.1</Runde 1>\n",
+    "    <Runde 2>56.3</Runde 2>\n",
+    "  </Kart>\n",
+    "</Ergebnisse>\n",
+    "```\n",
+    "\n",
+    "Auch hier sind die EinrÃ¼ckungen optional und dienen der Ãœbersicht. XML wurde vor json entwickelt und ist der Standard in vielen bewÃ¤hrten Programmen und Anwendungen geworden. Der Speicherplatzverbrauch ist etwas hÃ¶her als bei json, da hier nun jeder Tag sowohl geÃ¶ffnet, als auch geschlossen wird, was Text erzeugt."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "04a4474e",
+   "metadata": {},
+   "source": [
+    "#### **<font color='blue'>Beispiel: Hierarchische Datenstruktur</font>**\n",
+    "\n",
+    "Das zweite Beispiel ist ein etwas komplexerer hierarchischer Datansatz einer Bibliothek, die BÃ¼cher und Zeitschriften verwaltet, wobei Zeitschriften nochmal in Ausgaben und Artikel aufgeteilt werden. Im folgenden Bild ist der vollstÃ¤ndige Datensatz als Baum aufgezeichnet:"
+   ]
+  },
+  {
+   "attachments": {
+    "Hierarchisch_klein.PNG": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "id": "4f4c2176",
+   "metadata": {},
+   "source": [
+    "![Hierarchisch_klein.PNG](attachment:Hierarchisch_klein.PNG)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "425796d3",
+   "metadata": {},
+   "source": [
+    "#### **csv**\n",
+    "Csv ist nicht fÃ¼r hierarchische Datenstrukturen entwickelt worden. Die Daten mÃ¼ssen alle irgendiwe in einer Tabelle angeordnet werden. Im folgenden Beispiel wird die CSV Datei so geschrieben, dass in jeder Zeile entweder ein Buch oder ein Artikel steht, und in den Spalten alle mÃ¶glichen Attribute (wobei zum Beispiel zwischen B_Titel, ZS_titel und Art_Titel unterschieden werden muss). Zutreffende Felder werden ausgefÃ¼llt, nicht zutreffende nicht. Auf die optionalen AnfÃ¼hrungszeichen wird verzichtet, da ohnehin fast alles als Text ausgewertet werden soll. Zwar lassen sich die Daten so relativ kompakt aufschreiben, aber es ersichtlich, dass csv nicht sonderlich gut fÃ¼r die ReprÃ¤sentation solcher hierarchischer (baumartiger) Strukturen geeignet ist. \n",
+    "\n",
+    "```\n",
+    "B_Titel,B_Autor,B_Jahr,ZS_titel,ZS_Verlag,ZS_Ausg_Nr,Art_Titel,Art_Autor\n",
+    "Das erste Buch,M. Muster,2013,,,,,\n",
+    "Ein Beispielbuch,E.Beispiel,2022,,,,,\n",
+    ",,,Die beste Zeitschrift,TOPVerlag,1/2023,Editorial,A. Top\n",
+    ",,,Die beste Zeitschrift,TOPVerlag,1/2023,Untersuchung von xy,C. Schlau\n",
+    ",,,Die beste Zeitschrift,TOPVerlag,2/2023,,\n",
+    "```\n",
+    "\n",
+    "Die Baumstruktur geht nicht optisch daraus hervor, und wir nennen die Zeitschrift mehrfach. Man kÃ¶nnte dies auch sicher Ã¼ber eine Indizierung lÃ¶sen, aber der Kern dieser Darstellung ist, dass CSV nicht das beste Format fÃ¼r solche Strukturen ist und man sich gut Ã¼berlegen muss, wie man die Tabelle am besten gestaltet. CSV glÃ¤nzt eher im Speichern von vielen und groÃŸen gleichberechtigten Zahlenreihen, wie zum Beispiel als Ergebnis einer zeitlich abhÃ¤ngigen Bewegungssimulation: Zeit, Kraft_x, Kraft_y, Kraft_z, Moment_x, Moment_y, Moment_z, Ort_x, Ort_y, Ort_z [etc.]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a3d2a6ed",
+   "metadata": {},
+   "source": [
+    "#### **json**\n",
+    "In json wird nicht viel anders gemacht, als beim Kartbeispiel, abgesehen davon, dass es einige Verschachtelungen mehr gibt:\n",
+    "```\n",
+    "{\n",
+    "    \"Buecher\": [\n",
+    "        {\n",
+    "            \"Titel\": \"Das erste Buch\",\n",
+    "            \"Autor\": \"M. Muster\",\n",
+    "            \"Jahr\": 2013\n",
+    "        },\n",
+    "        {\n",
+    "            \"Titel\": \"Ein Beispielbuch\",\n",
+    "            \"Autor\": \"E Beispiel\",\n",
+    "            \"Jahr\": 2012\n",
+    "        }\n",
+    "    ],\n",
+    "    \"Zeitschriften\": [\n",
+    "        {\n",
+    "            \"Titel\": \"Die beste Zeitschrift\",\n",
+    "            \"Verlag\": \"TOPVerlag\",\n",
+    "            \"Ausgaben\": [\n",
+    "                {\n",
+    "                    \"Nr\": \"1/2023\",\n",
+    "                    \"Artikel\": [\n",
+    "                        {\n",
+    "                            \"Titel\": \"Editorial\",\n",
+    "                            \"Autor\": \"A. Top\"\n",
+    "                        },\n",
+    "                        {\n",
+    "                            \"Titel\": \"Untersuchung von xy\",\n",
+    "                            \"Autor\": \"C. Schlau\"\n",
+    "                        }\n",
+    "                    ]\n",
+    "                },\n",
+    "                {\n",
+    "                    \"Nr\": \"2/2023\",\n",
+    "                    \"Artikel\": []\n",
+    "                }\n",
+    "            ]\n",
+    "        }\n",
+    "    ]\n",
+    "}\n",
+    "```\n",
+    "Die Struktur der Daten wird wesentlich einfacher ersichtlich. Nach wie vor kÃ¶nnte dieses Dictionary direkt in Python importiert und verwendet werden."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2c43d5db",
+   "metadata": {},
+   "source": [
+    "#### **xml**\n",
+    "In XML sind nun einige Knoten mehr als beim Kart-Beispiel enthalten, aber auch hier bleibt das Prinzip gleich.\n",
+    "```\n",
+    "<Bibliothek>\n",
+    "  <Buecher>\n",
+    "    <Buch>\n",
+    "      <Titel>Das erste Buch</Titel>\n",
+    "      <Autor>M. Muster</Autor>\n",
+    "      <Jahr>2013</Jahr>\n",
+    "    </Buch>\n",
+    "    <Buch>\n",
+    "      <Titel>Ein Beispielbuch</Titel>\n",
+    "      <Autor>E. Beispiel</Autor>\n",
+    "      <Jahr>2022</Jahr>\n",
+    "    </Buch>\n",
+    "  </Buecher>\n",
+    "  <Zeitschriften>\n",
+    "    <Zeitschrift>\n",
+    "      <Titel>Die beste Zeitschrift</Titel>\n",
+    "      <Verlag>TOPVerlag</Verlag>\n",
+    "      <Ausgaben>\n",
+    "        <Ausgabe>\n",
+    "          <Nr>1/2023</Nr>\n",
+    "          <AlleArtikel>\n",
+    "            <Artikel>\n",
+    "              <Titel>Editorial</Titel>\n",
+    "              <Autor>A. Top</Autor>\n",
+    "            </Artikel>\n",
+    "            <AlleArtikel>\n",
+    "              <Titel>Untersuchung von xy</Titel>\n",
+    "              <Autor>C. Schlau</Autor>\n",
+    "            </AlleArtikel>\n",
+    "          </AlleArtikel>\n",
+    "        </Ausgabe>\n",
+    "        <Ausgabe>\n",
+    "          <Nr>2/2023</Nr>\n",
+    "          <Artikel/>\n",
+    "        </Ausgabe>\n",
+    "      </Ausgaben>\n",
+    "    </Zeitschrift>\n",
+    "  </Zeitschriften>\n",
+    "</Bibliothek>\n",
+    "```\n",
+    "Im Vergleich zu json muss man mehr lesen (und die Datei ist daher grÃ¶ÃŸer), aber auch bei xml sind die Daten deutlich selbsterklÃ¤render, als im csv-Beispiel."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "08431e54",
+   "metadata": {},
+   "source": [
+    "### **<font color='blue'>Welches Datenformat?</font>**\n",
+    "\n",
+    "Welches Datenformat verwendet wird, hÃ¤ngt also immer vom Anwendungsfall und auch von der bisher bestehenden Architektur ab (wenn man keine Anwendung von Grund auf entwickelt). GrundsÃ¤tzlich ist CSV sehr gut fÃ¼r Tabellen geeignet, wÃ¤hrend json und xml fÃ¼r hierarchische Daten besser geeignet sind. json ist etwas platzsparender und daher schneller und ist fÃ¼r neue Anwendungen eine gute Wahl. Es wird auch stark zunehmend, insbesondere fÃ¼r Webanwendungen, genutzt. XML ist etwas weniger platzsparend als json, aber in vielen bestehenden Anwendungen und Architekturen der etablierte standard. XML bietet noch einige Features, die wir im Rahmen dieses Notebooks nicht besprechen kÃ¶nnen (Attribute, Schemata), und wird als flexibler bezeichent."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5932056c",
+   "metadata": {},
+   "source": [
+    "### **<font color='blue'>Verwendung in Python</font>**\n",
+    "FÃ¼r alle diese Formate gibt es (gleichnamige) Module in Python, die die Arbeit mit diesen Formaten erleichtern. So muss man nicht manuell einprogrammieren, wie die Formatierung gemacht werden soll.\n",
+    "\n",
+    "#### **csv**\n",
+    "Das Paket ````csv```` enthÃ¤lt Klassen fÃ¼r das Lesen und Schreiben von csv Dateien. Dabei kann eine Formatierung (z.B. Trennzeichen fÃ¼r Spalten (````delimiter = ''````) und AnfÃ¼hrungszeichen bei Texten (````quoting = csv.QUOTE_NONNUMERIC````) etc.) beim Anlegen konfiguriert werden. Mit diesen Objekten lassen sich dann Felder von Feldern direkt schreiben oder auslesen. Die fÃ¼r Zahlenreihen wichtigsten Optionen sind im folgenden Beispiel (Kart) gezeigt und ausfÃ¼hrlich kommentiert:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "c0f40ef4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Direkte Ausgabe: [['Kart', 'Runde 1', 'Runde 2'], [1.0, 56.5, 55.7], [2.0, 55.2, 55.1], [3.0, 57.1, 56.3]]\n",
+      "formatierte Ausgabe\n",
+      "Kart \tRunde 1 \tRunde 2 \t\n",
+      "1.0 \t56.5 \t55.7 \t\n",
+      "2.0 \t55.2 \t55.1 \t\n",
+      "3.0 \t57.1 \t56.3 \t\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Zunaechst bereiten wir die Daten vor\n",
+    "\n",
+    "# Daten anlegen\n",
+    "kart_1 = [56.5,55.7]\n",
+    "kart_2 = [55.2,55.1]\n",
+    "kart_3 = [57.1,56.3]\n",
+    "\n",
+    "# Wir wollen die Kartnummer in der Tabelle haben und legen ein Feld mit den Feldern fÃ¼r jedes Kart an\n",
+    "alle_karts = [[1]+kart_1, [2]+kart_2, [3]+kart_3]\n",
+    "\n",
+    "# Nun CSV\n",
+    "import csv\n",
+    "\n",
+    "# Beim oeffnen geben wir bereits .csv an, das hat allerdings noch keine besondere Bedeutung. Wir koennen immer noch in die Datei schreiben was wir wollen.\n",
+    "# newline = '' ist fuer das csv modul noetig, da es selbst Steuerzeichen fuer den Zeilenumbruch setzt\n",
+    "\n",
+    "with open('karts.csv','w',newline='') as f:\n",
+    "    \n",
+    "    # Nun erstellen wir den csv writer und uebergeben diesem das Datei-Objekt f, sowie hier den optionalen Parameter \"quoting\" fuer das Setzen von anfuehrungszeichen bei Text\n",
+    "    writer = csv.writer(f, quoting=csv.QUOTE_NONNUMERIC)\n",
+    "    \n",
+    "    # Nun koennen wir mit writerow() eine Liste in eine Zeile schreiben. Wir machen dies fuer die Ueberschriften\n",
+    "    writer.writerow([\"Kart\",\"Runde 1\", \"Runde 2\"])\n",
+    "    \n",
+    "    # Mit writerows() koennen wir eine Liste von Listen uebergeben. Damit wird fuer jede innere Liste writerow() aufgerufen.\n",
+    "    # Unsere Rundendaten sind solche Listen von Listen. Somit koennen wir mit dem einen Befehl den Rest der Daten schreiben.\n",
+    "    writer.writerows(alle_karts)\n",
+    "\n",
+    "# Zum Lesen Erstellen wir zuerst eine Liste fÃ¼r die inneren Listen\n",
+    "rows = []\n",
+    "    \n",
+    "#Das Oeffnen zum Lesen funktioniert analog zum Schreiben (Modus \"r\"). Wir erstellen analog zum csv-writer objekt ein csv-reader objekt\n",
+    "with open('karts.csv','r',newline='') as f:\n",
+    "    reader = csv.reader(f, quoting=csv.QUOTE_NONNUMERIC)\n",
+    "    \n",
+    "    # nun koennen wir \"reader\" verwenden wie eine Liste der Zeilen (die wir allerdings nur ein einziges mal von vorne nach hinten durchlaufen koennen)\n",
+    "    # Wir iterieren also ueber \"reader\" und speichern alle Zeilen in \"rows\"\n",
+    "    for line in reader:\n",
+    "        rows.append(line)\n",
+    "        \n",
+    "# Nun ist in rows der gesamte Datensatz gespeichert. Wir koennen ihn verwenden, wie wir moechten. Z.B. ausgeben:\n",
+    "print(f\"Direkte Ausgabe: {rows}\")\n",
+    "\n",
+    "#Oder eine formatiertere Ausgabe:\n",
+    "print(\"formatierte Ausgabe\")\n",
+    "for line in rows:\n",
+    "    for element in line:\n",
+    "        print(f\"{element} \\t\", end =\"\") # \\t ist ein Steuerzeichen fÃ¼r \"tab\", end=\"\" verhindert einen Zeilenumbruch\n",
+    "    print(\"\") # Dieses print erzeugt den Zeilenumbruch fuer das naechste Kart"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "602a06df",
+   "metadata": {},
+   "source": [
+    "#### **json**\n",
+    "Das Paket ````json```` enthÃ¤lt Funktionen fÃ¼r das Konvertieren (````json.dump()````) von Python-Dictionaries in json-Strings und umgekehrt (````json.loads()````). Diese Strings kÃ¶nnen mit den Attribut ````indent = 4```` zur besseren Ãœbersicht eingerÃ¼ckt werden. Die Strings kÃ¶nnen direkt eine Datei geschrieben werden und nach dem Auslesen in ein Dictionary konvertiert werden. Das folgende Beispiel zeigt wieder die Karts:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "c0ea1ff7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[\n",
+      "    {\n",
+      "        \"Kart\": 1,\n",
+      "        \"Runde 1\": 56.5,\n",
+      "        \"Runde 2\": 55.7\n",
+      "    },\n",
+      "    {\n",
+      "        \"Kart\": 2,\n",
+      "        \"Runde 1\": 55.2,\n",
+      "        \"Runde 2\": 55.1\n",
+      "    },\n",
+      "    {\n",
+      "        \"Kart\": 3,\n",
+      "        \"Runde 1\": 57.1,\n",
+      "        \"Runde 2\": 56.3\n",
+      "    }\n",
+      "]\n",
+      "[\n",
+      "    {\n",
+      "        \"Kart\": 1,\n",
+      "        \"Runde 1\": 56.5,\n",
+      "        \"Runde 2\": 55.7\n",
+      "    },\n",
+      "    {\n",
+      "        \"Kart\": 2,\n",
+      "        \"Runde 1\": 55.2,\n",
+      "        \"Runde 2\": 55.1\n",
+      "    },\n",
+      "    {\n",
+      "        \"Kart\": 3,\n",
+      "        \"Runde 1\": 57.1,\n",
+      "        \"Runde 2\": 56.3\n",
+      "    }\n",
+      "]\n",
+      "{'Kart': 1, 'Runde 1': 56.5, 'Runde 2': 55.7}\n",
+      "56.5\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Die Rohdaten sind oben bereits bei CSV in \"alle_karts\" angelegt, wir erstellen eine passende Liste mit Dictionaries:\n",
+    "\n",
+    "karts_dict_list = []\n",
+    "for kart_daten in alle_karts:\n",
+    "    karts_dict_list.append({\"Kart\":kart_daten[0], \"Runde 1\":kart_daten[1], \"Runde 2\":kart_daten[2]})\n",
+    "\n",
+    "# In diesem Dictionary sind nun die Daten gespeichert. Wir importieren json und erstellen den passenden string mit Einrueckung\n",
+    "import json\n",
+    "json_string = json.dumps(karts_dict_list, indent = 4)\n",
+    "\n",
+    "#Kontrollausgabe\n",
+    "print(json_string)\n",
+    "\n",
+    "#Dies string koennen wir mit den oben vorgestellten tools in eine Datei schreiben:\n",
+    "with open(\"karts.json\",\"w\") as f:\n",
+    "    f.write(json_string)\n",
+    "    \n",
+    "#Beim Lesen haengen wir jede Zeile an eine Zeichenkette an, damit wir keine Liste von Zeichenketten, sondern nur eine einzige Zeichenkette erhalten\n",
+    "with open(\"karts.json\",\"r\") as f:\n",
+    "    json_from_file = \"\"\n",
+    "    for line in f.readlines():\n",
+    "        json_from_file+=line\n",
+    "\n",
+    "#Kontrollausgabe\n",
+    "print(json_from_file)\n",
+    "\n",
+    "#Um eine Liste aus dem String zu erhalten nutzen wir json.loads()\n",
+    "imported_list = json.loads(json_from_file)\n",
+    "\n",
+    "#Kontrollausgaben\n",
+    "print(imported_list[0])\n",
+    "print(imported_list[0][\"Runde 1\"])\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "04e13d48",
+   "metadata": {},
+   "source": [
+    "#### **xml**\n",
+    "Das Paket ````xml```` enthÃ¤lt sehr viele Funktionen fÃ¼r das Arbeiten mit xml-Daten und den entsprechenden Baumstrukturen. Wir behandeln hier nur die grundlegendsten.\n",
+    "\n",
+    "***Baum anlegen***\n",
+    "\n",
+    "Um eine Baumstruktur einzulesen oder zu schreiben wird das Unterpaket ````xml.etree.ElementTree```` als ````ET```` verwendet. Jeder Baum hat einen ersten Wurzelknoten. Dieser wird mit ````ET.Element(tag)```` angelegt. Diese Funktion legt einen Knoten an und gibt ein Objekt aus, das den von diesem Knoten ausgehenden Baum enthÃ¤lt. Unterknoten kÃ¶nnen mit ````ET.SubElement(elternknoten,tag)```` angelegt werden, wobei zuerst das Objekt des Elternknotens und anschlieÃŸend der Tag (Name) Ã¼bergeben werden. An diesen Knoten kann man weitere Unterknoten anschlieÃŸen, oder einen Wert speichern. Um einen Wert zu speichern, weiÃŸt man dem Attribut ````.text```` des Objekts den gewÃ¼nschten Wert zu. FÃ¼r eine gÃ¼ltige xml muss der Wert als Zeichenkette eingespeichert werden. Im folgenden Beispiel wird der Baum fÃ¼r die Kartergebnisse angelegt:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "5e92c505",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import xml.etree.ElementTree as ET\n",
+    "\n",
+    "\n",
+    "# manuell angelegt (um die Struktur klar zu machen, in der Praxis unpraktikabel)\n",
+    "ergebnisse = ET.Element(\"Ergebnisse\")\n",
+    "\n",
+    "kart_1 = ET.SubElement(ergebnisse, \"Kart\")\n",
+    "kart_2 = ET.SubElement(ergebnisse, \"Kart\")\n",
+    "kart_3 = ET.SubElement(ergebnisse, \"Kart\")\n",
+    "\n",
+    "kart_1_nr = ET.SubElement(kart_1, \"Nr\")\n",
+    "kart_1_nr.text = \"1\"\n",
+    "kart_1_R1 = ET.SubElement(kart_1, \"Runde_1\")\n",
+    "kart_1_R1.text = \"56.5\"\n",
+    "kart_1_R2 = ET.SubElement(kart_1, \"Runde_2\")\n",
+    "kart_1_R2.text = \"55.7\"\n",
+    "\n",
+    "kart_2_nr = ET.SubElement(kart_2, \"Nr\")\n",
+    "kart_2_nr.text = \"2\"\n",
+    "kart_2_R1 = ET.SubElement(kart_2, \"Runde_1\")\n",
+    "kart_2_R1.text = \"55.2\"\n",
+    "kart_2_R2 = ET.SubElement(kart_2, \"Runde_2\")\n",
+    "kart_2_R2.text = \"55.1\"\n",
+    "\n",
+    "kart_3_nr = ET.SubElement(kart_3, \"Nr\")\n",
+    "kart_3_nr.text = \"3\"\n",
+    "kart_3_R1 = ET.SubElement(kart_3, \"Runde_1\")\n",
+    "kart_3_R1.text = \"57.1\"\n",
+    "kart_3_R2 = ET.SubElement(kart_3, \"Runde_2\")\n",
+    "kart_3_R2.text = \"56.3\"\n",
+    "\n",
+    "# In Schleife angelegt (praktikabel, da es bei exakt diesem Code (8 Zeilen) bleibt, auch wenn es 10 Karts und 20 Runden sind)\n",
+    "# Der manuelle Code fuer 3 Karts und 2 Runden hat 22 Zeilen. Bei 10 Karts und 20 Runden haette er 441 Zeilen.\n",
+    "# Das Feld \"alle karts\" mit den Unterfeldern fuer Nummer und Rundenzeiten steht noch zur Verfuegung\n",
+    "ergebnisse_neu = ET.Element(\"Ergebnisse\")\n",
+    "for kart_daten in alle_karts:\n",
+    "    current_kart = ET.SubElement(ergebnisse_neu, \"Kart\") \n",
+    "    nr = ET.SubElement(current_kart, \"Nr\")\n",
+    "    nr.text = str(kart_daten[0])\n",
+    "    \n",
+    "    for runde_nummer in range(1,len(kart_daten)):\n",
+    "        runde = ET.SubElement(current_kart, f\"Runde_{runde_nummer}\")\n",
+    "        runde.text = str(kart_daten[runde_nummer])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d4fdd3cf",
+   "metadata": {},
+   "source": [
+    "Nun ist der Baum angelegt.\n",
+    "\n",
+    "***Baum in Datei schreiben und aus Datei laden***\n",
+    "\n",
+    "Wir kÃ¶nnen ihn mit ````ET.tostring(baum, encoding=\"unicode\")```` in eine Zeichenkette mit der xml Syntax Ã¼berfÃ¼hren. Der Parameter ````encoding =\"unicode\"```` sorgt fÃ¼r einen ASCII-String. FÃ¼r die optisch hilfreichen EinrÃ¼ckungen steht ab Python Version 3.9 die Funktion ````ET.indent(baum, space=\" \", level=0)```` zur VerfÃ¼gung, die vor Erstellen des Strings aufgerufen werden muss.  Diesen String kÃ¶nnen wir ganz konventionell in eine Datei schreiben."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "5a6c1745",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<Ergebnisse><Kart><Nr>1</Nr><Runde_1>56.5</Runde_1><Runde_2>55.7</Runde_2></Kart><Kart><Nr>2</Nr><Runde_1>55.2</Runde_1><Runde_2>55.1</Runde_2></Kart><Kart><Nr>3</Nr><Runde_1>57.1</Runde_1><Runde_2>56.3</Runde_2></Kart></Ergebnisse>\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Folgende Zeile nur ab Python 3.9\n",
+    "# ET.indent(ergebnisse, space=\" \", level=0)\n",
+    "\n",
+    "xml_string = ET.tostring(ergebnisse_neu, encoding=\"unicode\")\n",
+    "print(xml_string)\n",
+    "\n",
+    "with open(\"karts.xml\",\"w\") as f:\n",
+    "    f.write(xml_string)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4af0ceb8",
+   "metadata": {},
+   "source": [
+    "Zum Einlesen steht entweder die Funktion ````ET.fromstring(string)```` zur VerfÃ¼gung, die den String erhÃ¤lt und ein Knotenobjekt fÃ¼r den Wurzelknoten ausgibt. Mit diesem kann auf den ganzen Baum zugegriffen werden, wie gleich gezeigt wird.\n",
+    "Es gibt zusÃ¤tzlich noch eine Methode, mit der man direkt eine xml-Datei einlesen kann. Man muss dann also nicht mehr manuell die Datei Ã–ffnen und des String auslesen. Diese Methode ist \"ET.parse(dateiname)\". Dies importiert den Baum. Um dann den Wurzelknoten als Objekt zu erhalten ruft man ````.getroot()```` in dem erhaltenen Objekt auf."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "0ec639e5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Variante 1 (allerdings hier mit dem noch im Speicher befindlichen xml_string, koennte aber auch wie bei json aus der Datei eingelesen werden)\n",
+    "\n",
+    "ergebnisse = ET.fromstring(xml_string)\n",
+    "\n",
+    "#Variante 2 (nun wirklich aus der Datei)\n",
+    "\n",
+    "baum_importiert = ET.parse(\"karts.xml\")\n",
+    "ergebnisse = baum_importiert.getroot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6adb0fb8",
+   "metadata": {},
+   "source": [
+    "***Zugriff auf die Daten im Baum***\n",
+    "\n",
+    "Die Daten in einem Baum auslesen kÃ¶nnen wir folgendermaÃŸen: Jedes Knoten-Objekt hat ein Attribut ````.tag````, in dem der Tag gespeichert ist. Im Attribut ````.text```` sind die Werte abgelegt. Das Objekt selbst ist sozusagen eine Liste mit seinen Unterknoten. Auf diese kÃ¶nnen wir mit dem Indexoperator zugreifen (Die Reihenfolge entspricht dabei dem Anlegen, bzw. dem eingelesenen xml file. Ein Knoten hat noch folgende nÃ¼tzliche Methoden: ````.findall(tag)```` gibt alle Unterknoten mit dem entsprechenden Tag zurÃ¼ck. ````.find(tag)```` gibt nur den ersten Unterknoten mit dem angegebenen Tag aus. ````.inter()```` durchlÃ¤uft den ganzen Baum unter dem Element. Im Folgenden sind ein paar Beispiele gezeigt (Der Code wird in der Ausgabe immer mit gezeigt, man kann also die Ausgabe alleine ansehen):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "a5962a27",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ergebnisse.tag: Ergebnisse\n",
+      "\n",
+      "ergebnisse[:]: [<Element 'Kart' at 0x00000272448247C0>, <Element 'Kart' at 0x0000027244824950>, <Element 'Kart' at 0x0000027244824E00>]\n",
+      "\n",
+      "ergebnisse[0].tag: Kart\n",
+      "\n",
+      "ergebnisse[0][:]: [<Element 'Nr' at 0x0000027244824770>, <Element 'Runde_1' at 0x00000272448244A0>, <Element 'Runde_2' at 0x0000027244824900>]\n",
+      "\n",
+      "ergebnisse[0].find('Nr'): <Element 'Nr' at 0x0000027244824770>\n",
+      "\n",
+      "ergebnisse[0].find('Nr').text: 1\n",
+      "\n",
+      "ergebnisse.findall('Kart'): [<Element 'Kart' at 0x00000272448247C0>, <Element 'Kart' at 0x0000027244824950>, <Element 'Kart' at 0x0000027244824E00>]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"ergebnisse.tag: {ergebnisse.tag}\\n\") #Zugriff auf Tag\n",
+    "\n",
+    "print(f\"ergebnisse[:]: {ergebnisse[:]}\\n\") #Zugriff auf Liste mit Unterelementen\n",
+    "\n",
+    "print(f\"ergebnisse[0].tag: {ergebnisse[0].tag}\\n\") #Zugriff auf erstes Unterlement und dessen Tag\n",
+    "\n",
+    "print(f\"ergebnisse[0][:]: {ergebnisse[0][:]}\\n\") #Zugriff auf Liste mit Unterelementen des ersten Unterelements\n",
+    "\n",
+    "print(f\"ergebnisse[0].find('Nr'): {ergebnisse[0].find('Nr')}\\n\") #Zugriff auf das Unterlement mit Tag \"Nr\" des ersten Unterelements\n",
+    "\n",
+    "print(f\"ergebnisse[0].find('Nr').text: {ergebnisse[0].find('Nr').text}\\n\") # Zugriff auf den Wert des eben gefundenen Unterelements\n",
+    "\n",
+    "print(f\"ergebnisse.findall('Kart'): {ergebnisse.findall('Kart')}\\n\") # Liste aller Unterelemente mit dem tag \"Kart\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6e3880da",
+   "metadata": {},
+   "source": [
+    "Diese Beispiele wirken etwas theoretisch (obwohl man teils geziehlt auf solche einzelnen Elemente zugreift). Im Folgenden ein paar praxisnÃ¤here Beispiele fÃ¼r Zugriffe auf den Baum. Wir beginnen mit einer Schleife Ã¼ber alle gefundenen Karts und geben die Nr. und Rundenzeit aus."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "f35960a3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Kart: 1\n",
+      "Runde 1: 56.5\n",
+      "Runde 2: 55.7\n",
+      "\n",
+      "Kart: 2\n",
+      "Runde 1: 55.2\n",
+      "Runde 2: 55.1\n",
+      "\n",
+      "Kart: 3\n",
+      "Runde 1: 57.1\n",
+      "Runde 2: 56.3\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "for kart in ergebnisse.findall('Kart'):\n",
+    "    print(f\"Kart: {kart.find('Nr').text}\\nRunde 1: {kart.find('Runde_1').text}\\nRunde 2: {kart.find('Runde_2').text}\\n\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0132bac0",
+   "metadata": {},
+   "source": [
+    "Ã„hnlich kÃ¶nnen wir auch die ````iter()```` Methode nutzen. Um zu verstehen, was bei der Methode passiert, geben wir zunÃ¤chst nur alle Tags aus."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "a973ba6a",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ergebnisse\n",
+      "Kart\n",
+      "Nr\n",
+      "Runde_1\n",
+      "Runde_2\n",
+      "Kart\n",
+      "Nr\n",
+      "Runde_1\n",
+      "Runde_2\n",
+      "Kart\n",
+      "Nr\n",
+      "Runde_1\n",
+      "Runde_2\n"
+     ]
+    }
+   ],
+   "source": [
+    "for element in ergebnisse.iter():\n",
+    "    print(element.tag)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6c0aebd6",
+   "metadata": {},
+   "source": [
+    "Wir sehen also, dass der gesamte Baum von oben bis unten durchlaufen wurde. Geben wir nun auch alle Werte aus:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "80503571",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ergebnisse None\n",
+      "Kart None\n",
+      "Nr 1\n",
+      "Runde_1 56.5\n",
+      "Runde_2 55.7\n",
+      "Kart None\n",
+      "Nr 2\n",
+      "Runde_1 55.2\n",
+      "Runde_2 55.1\n",
+      "Kart None\n",
+      "Nr 3\n",
+      "Runde_1 57.1\n",
+      "Runde_2 56.3\n"
+     ]
+    }
+   ],
+   "source": [
+    "for element in ergebnisse.iter():\n",
+    "    print(element.tag, element.text)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "75a170a7",
+   "metadata": {},
+   "source": [
+    "Jetzt sind bereits alle Daten dargestellt. Allerdings kÃ¶nnte man die Formatierung verbessern und das ````None```` weglassen, wenn das Element keinen Text hat:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "72253ee5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ergebnisse:\n",
+      "Kart:\n",
+      "    Nr: 1\n",
+      "    Runde_1: 56.5\n",
+      "    Runde_2: 55.7\n",
+      "Kart:\n",
+      "    Nr: 2\n",
+      "    Runde_1: 55.2\n",
+      "    Runde_2: 55.1\n",
+      "Kart:\n",
+      "    Nr: 3\n",
+      "    Runde_1: 57.1\n",
+      "    Runde_2: 56.3\n"
+     ]
+    }
+   ],
+   "source": [
+    "for element in ergebnisse.iter():\n",
+    "    if element.text is None:\n",
+    "        print(f\"{element.tag}:\")\n",
+    "    else:\n",
+    "        print(f\"    {element.tag}: {element.text}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "696ab624",
+   "metadata": {},
+   "source": [
+    "# <font color='blue'>**\"BinÃ¤rdateien mit Pickle\"**</font>\n",
+    "\n",
+    "Als Alternative zu den ASCII-Dateien gibt es BinÃ¤rdateien. Diese sind nicht menschenlesbar, und so sind diese nur fÃ¼r bestehende Programme nutzbar, oder wenn eine Dokumentation genau aufschlÃ¼sselt, wie die Datei strukturiert ist (Indebesondere wo welcher Datentyp verwendet werden muss, um die BinÃ¤rzahl zu entschlÃ¼sseln).\n",
+    "\n",
+    "In Python gibt es mit ````pickle```` ein nÃ¼tzliches Paket zum permanenten Speichern von aktuellen Objekten in der Session. Die Verwendung ist sehr einfach, aber man muss ein bisschen etwas beachten:\n",
+    "\n",
+    "**Das Importieren von Objekten in eine neue Session ist nur dann erfolgreich, wenn eine dazu passende Klassendefinition verfÃ¼gbar ist, und die Python Version die selbe ist. Ein Weglassen oder Ã„ndern der Klassendefinition, oder ein Wechsel der Python Version kann also zur Folge haben, dass die gespeicherten Daten nicht erfolgreich eingelesen werden kÃ¶nnen.**\n",
+    "\n",
+    "Um ein Objekt auf der Festplatte zu speichern, Ã¶ffnet man konventionell eine Datei zum Schreiben (Dateiendung typischerweise .pkl) im ````mode = \"wb\"```` (Schreiben - binÃ¤r) und beschreibt sie mit der Funktion ````pickle.dump(objekt, dateiobjekt)````.\n",
+    "\n",
+    "So kÃ¶nnen wir zum Beipiel unsere Liste \"alle_karts\" (Objekt der Standard-Klasse Liste) mit pickle speichern:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "3d1ced1a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pickle\n",
+    "\n",
+    "with open(\"karts.pkl\",\"wb\") as f:\n",
+    "    pickle.dump(alle_karts, f)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0bae701b",
+   "metadata": {},
+   "source": [
+    "Wenn man die entstandene Datei versucht, im Editor zu Ã¶ffnen, kann man nur einen wilden Mix aus Zeichen und Hexadezimalzahlen erkennen, da der Editor die aneinander gereiten 0 und 1 des BinÃ¤rformats nicht richtig interpretiert. Das gleiche passiert, wenn wir es im Modus \"r\" (ohne \"b\") Ã¶ffnen:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "196f7834",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['â‚¬\\x04â€¢M\\x00\\x00\\x00\\x00\\x00\\x00\\x00]â€(]â€(K\\x01G@L@\\x00\\x00\\x00\\x00\\x00G@KÃ™â„¢â„¢â„¢â„¢Å¡e]â€(K\\x02G@Kâ„¢â„¢â„¢â„¢â„¢Å¡G@KÅ’ÃŒÃŒÃŒÃŒÃe]â€(K\\x03G@LÅ’ÃŒÃŒÃŒÃŒÃG@L&fffffee.']\n"
+     ]
+    }
+   ],
+   "source": [
+    "with open(\"karts.pkl\",\"r\") as f:\n",
+    "    print(f.readlines())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bf281b0b",
+   "metadata": {},
+   "source": [
+    "Auch mit \"rb\" wird die Situation nicht viel besser. Nun wird zwar jeder Wert (byte) als Hexadezimalzahl dargestellt, aber wir haben trotzdem noch keine Information, wie die Werte interpretiert werden mÃ¼ssen."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "994e1611",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[b'\\x80\\x04\\x95M\\x00\\x00\\x00\\x00\\x00\\x00\\x00]\\x94(]\\x94(K\\x01G@L@\\x00\\x00\\x00\\x00\\x00G@K\\xd9\\x99\\x99\\x99\\x99\\x9ae]\\x94(K\\x02G@K\\x99\\x99\\x99\\x99\\x99\\x9aG@K\\x8c\\xcc\\xcc\\xcc\\xcc\\xcde]\\x94(K\\x03G@L\\x8c\\xcc\\xcc\\xcc\\xcc\\xcdG@L&fffffee.']\n"
+     ]
+    }
+   ],
+   "source": [
+    "with open(\"karts.pkl\",\"rb\") as f:\n",
+    "    print(f.readlines())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eb0b8d31",
+   "metadata": {},
+   "source": [
+    "Die uns fehlenden Informationen hat das pickle Modul. Deshalb kÃ¶nnen wir problemlos mit ````pickle.load(dateiobjekt)```` die gespeicherte Liste einlesen, nachdem wir die Datei im Modus ````\"rb\"```` geÃ¶ffnet haben: "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "4f8ba3fc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[1, 56.5, 55.7], [2, 55.2, 55.1], [3, 57.1, 56.3]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "with open(\"karts.pkl\",\"rb\") as f:\n",
+    "    list_from_pickle = pickle.load(f)\n",
+    "    \n",
+    "print(list_from_pickle)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d5b35733",
+   "metadata": {},
+   "source": [
+    "Eigene definierte Klassen und Objekte kÃ¶nnen genau so gespeichert werden. Da im pickle Format intern auf die Klasse nur verwiesen wird (also nicht die Klassendefinition gespeichert wird), muss beim Import die entsprechende Klassendefinition gegeben sein (z.B. durch Import als Modul: Speichern wir z.B. einen np.array mit pickle, muss zunÃ¤chst auch numpy importiert werden, bevor die pickle Datei erfolgreich importiert wird). "
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.8.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Uebung10/Uebung_10.ipynb b/Uebung10/Uebung_10.ipynb
new file mode 100644
index 0000000..ebe697a
--- /dev/null
+++ b/Uebung10/Uebung_10.ipynb
@@ -0,0 +1,493 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e10b6cba",
+   "metadata": {},
+   "source": [
+    "# <font color='blue'>**Ãœbung 10 - Erweiterung der Fallmodellierung um weitere Raumdimensionen und Abspeichern und Laden von Ergebnisdaten - SciPy, csv**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ece841a5",
+   "metadata": {},
+   "source": [
+    "In dieser Ãœbung mÃ¶chten wir zunÃ¤chst noch eine Erweiterung an der Modellierung des Falls durch die Luft vornehmen. Wir haben bisher nur eine Richtung betrachtet. Ein typischer Fallschirmsprung findet aus einem Flugzeug statt, das sich Ã¼ber die ErdoberflÃ¤che bewegt. Es kÃ¶nnte daher interessant sein, nicht nur die HÃ¶he zu betrachten, sondern auch andere Raumrichtungen. Wir wollen uns dabei nur auf die Erweiterung um eine Raumrichtung konzentrieren, und vernachlÃ¤ssigen daher in dieser Ãœbung die KomplexitÃ¤t durch Ã–ffnen des Fallschirms aus der letzten Ãœbung.\n",
+    "Nachdem wir gesehen haben, wie man Simulationen erzeugt, wollen wir uns ansehen, wir man die Ergebnisse oder auch Objekte (wie das Fachwerk) in Dateien speichern und aus Dateien lesen kann. Das ermÃ¶glicht langfristiges Abspeichern, das Verwenden der Daten in anderen Programmen, und das Weitergeben an andere Personen. Dabei wollen wir uns ein paar gÃ¤ngige Formate ansehen, die fÃ¼r verschiedene Zwecke verschieden geeignet sind.\n",
+    "\n",
+    "### <font color='blue'>**Vorkenntnisse - Notebooks**\n",
+    "* Ãœbung 1\n",
+    "* Ãœbung 2\n",
+    "* Ãœbung 4\n",
+    "* Ãœbung 5\n",
+    "* Ãœbung 9\n",
+    "* Grundlagen Python\n",
+    "* Grundlagen Matplotlib\n",
+    "* Grundlagen Numpy\n",
+    "* Grundlagen SciPy\n",
+    "\n",
+    "### <font color='blue'>**Notebooks, die helfen kÃ¶nnen**\n",
+    "* Grundlagen Dateien\n",
+    "    * darin nur die Abschnitte zu allgemeinen ASCII-Dateien und CSV fÃ¼r diese Ãœbung notwendig. Json, xml und pickle kÃ¶nnen fÃ¼r diese Ãœbung noch Ã¼bersprungen werden. Achte darauf, dass im Notebook zuerst alle Formate allgemein vorgestellt werden und erst spÃ¤ter die Umsetzung in Python. Es kommt also auch im hinteren Teil noch etwas zu csv dran. Ds ist aber durch die Ãœberschriften deutlich erkennba\n",
+    "\n",
+    "### <font color='blue'>**Lernziele**\n",
+    "* Erweiterung einer Simulation um weitere Variablen\n",
+    "* Lesen und Schreiben von Daten im csv Format - Datenreihen"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eca5ef34",
+   "metadata": {},
+   "source": [
+    "## <font color='blue'>**Problemstellung 1: 2D Fall (ohne FallschirmÃ¶ffnung)**\n",
+    "\n",
+    " <font color='blue'>**Aufgabenstellung**\n",
+    "     \n",
+    "Die Berechnung mit *SciPy* aus Ãœbung 9 soll nun nicht mehr eine Raumdimension haben, sondern HÃ¶he (z) und Strecke (x), sodass beispielsweise ein Absprung aus einem Flugzeug simuliert werden kann. Um sich aufs wesentliche zu konzentrieren, kann in dieser Aufgabe ein VerÃ¤ndern der Parameter (also ein Ã–ffnen des Schirms) vernachlÃ¤ssigt werden. AuÃŸerdem darf davon ausgegeangen werden, dass der KÃ¶rper immer der Bewegunsrichtung nach ausgerichtet ist (das heiÃŸt A und C_W sind unabhÃ¤ngig von der Richtung). Zuletzt sollen die ermittelten Ortskoordinaten wÃ¤hrend des Falls in einem Diagramm dargestellt werden.\n",
+    "\n",
+    " <font color='blue'>**VorÃ¼berlegung**\n",
+    "\n",
+    "Wir haben nun nicht mehr je eine Komponente fÃ¼r die Geschwindigkeit und den Ort, sondern beide GrÃ¶ÃŸen haben nun zwei Komponenten. Man kÃ¶nnte sich vorstellen, das wir statt Skalaren nun Vektoren in y schreiben kÃ¶nnten. Allerdings kann ````scipy.integrate.solve_ivp()```` nur eindimensionale Vektoren verarbeiten. Das ist aber kein Problem. Wir kÃ¶nnen einfach unsere Geschwindigkeitskomponenten und Koordinaten hintereinander in y schreiben (ohne sie zu einzelnen Vektoren zusammenzufassen). Wir definieren also y als [vx, vz, x, z].\n",
+    "     \n",
+    "Das bedeutet, wir mÃ¼ssen ein neues y_0 mit 4 EintrÃ¤gen initialisieren und die DGL-Funktion so umschreiben, dass sie nun fÃ¼r jede der 4 Komponenten von y eine Ã„nderungsrate zurÃ¼ckgibt. ZurÃ¼ckgeben mÃ¼ssen wir also den Vektor [ax, az, vx, vz].\n",
+    "\n",
+    "FÃ¼r diese RÃ¼ckgabe sind vx und vz sehr leicht zu bestimmen, denn sie entsprechen den ersten beiden EintrÃ¤gen von y.\n",
+    "\n",
+    "Die Beschleunigung ist ein bisschen komplizierter:\n",
+    "Die Beschleunigung in einer Raumrichtung ist nach $F=ma$ die Summe aller KrÃ¤fte in diese Raumrichtung geteilt durch die Masse. \n",
+    "\n",
+    "Die x-Richtung erfÃ¤hrt als Kraft nur einen Anteil des Luftwiderstands.\n",
+    "     \n",
+    "Die z-Richtung setzt sich aus einem Anteil des Luftwiderstands und der Erdgravitation zusammen.\n",
+    "     \n",
+    "Eine kleine Schwierigkeit stellt die Berechnung des Anteils des Luftwiderstands dar. Dieser hÃ¤ngt nÃ¤mlich durch das Quadrat nichtlinear mit dem Geschwindigkeitsvektor zusammen. Das heiÃŸt, wir kÃ¶nnen nicht einfach die bisher benutzte Formel auf die beiden Geschwindigkeitskomponenten getrennt voneinander anwenden. Die Formel gibt uns nÃ¤mlich eigentlich den Betrag der Luftwiderstandskraft entgegen der Bewegungsrichtung in AbhÃ¤ngigkeit des Betrags der Geschwindigkeit zum Quadrat an. Wenn wir die einzelnen Komponenten quadrieren, kommt aber ein anderer Vektor heraus, als der Vektor, der in die ursprÃ¼ngliche Richtung zeigt und dessen Betrag dem Quadrat des ursprÃ¼nglichen Betrags entspricht.\n",
+    "\n",
+    "Das lÃ¤sst sich leichter an einem Beispiel zeigen (auch im Bild grafisch dargestellt): Betrachten wir den Vektor (3,4) mit dem Betrag 5 (Pythagoras). Quadrieren wir die EintrÃ¤ge erhalten wir (9,16) mit dem Betrag 18.35, der auch in eine andere Richtung zeigt. Wir suchen aber fÃ¼r das Quadrat dieses Vektors eigentlich den Vektor mit dem quadrierten Betrag (5Â²=25), der immer noch in die gleiche Richtung wie (3,4) zeigt. Diesen erhalten wir durch Skalierung des Vektors mit seinem Betrag (4,3)*|(4,3)|= (4,3) * 5 =(15,20).\n",
+    "     \n",
+    "Um sicherzustellen, dass wir diese Berechnung spÃ¤ter fÃ¼r die Berechnung der Widerstandskraft richtig verwenden, testen wir zunÃ¤chst den Code mit den Zahlen aus dem Beispiel von eben."
+   ]
+  },
+  {
+   "attachments": {
+    "Vektorquadrat.PNG": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "id": "dcb9f50b",
+   "metadata": {},
+   "source": [
+    "![Vektorquadrat.PNG](attachment:Vektorquadrat.PNG)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6602f0d2",
+   "metadata": {},
+   "source": [
+    "**Hinweis** Dieses Notebook ist wieder als eine Art LÃ¼ckentext mit ````'?'```` gestaltet, mit dem du Ã¼ben kannst. Die ErklÃ¤rungstexte und vorhandenen Codebausteine mit Kommentaren sollen Hilfestellung geben. Wenn du keinen Ansatz hast, versuche, in den Grundlagennotebooks oder alten Ãœbungen etwas zu finden, ansonsten verwende gerne das Notebook mit LÃ¶sung (\\_LSG) fÃ¼r Hilfestellungen."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eb4179de",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import scipy.integrate\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8018b4f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y = [4,3,0,0]\n",
+    "\n",
+    "#Komponenten aus y fuer v\n",
+    "yx = '?'\n",
+    "yz = '?'\n",
+    "vektor_1 = np.array('?')\n",
+    "betrag_1 = np.linalg.norm('?')\n",
+    "\n",
+    "# Achte beim quadrieren auf das oben besprochene. Quadrieren eines np.array mit **2 quadriert Komponentenweise\n",
+    "vektor_quadriert = '?'\n",
+    "\n",
+    "#Kontrollausgabe\n",
+    "print(f\"Vektor: {vektor_1}\")\n",
+    "print(f\"Betrag des Vektors: {betrag_1}\")\n",
+    "print(f\"Betrag zum Quadrat: {betrag_1**2}\")      \n",
+    "print(f\"Vektor mit dem Betrag {betrag_1**2} durch Skalierung des ursprÃ¼nglichen Vektors mit seinem (Betrag * Vektor): {vektor_quadriert}\")\n",
+    "print(f\"Probe: Betrag des erhaltenen Vektors: {np.linalg.norm(vektor_quadriert)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dd71b98b",
+   "metadata": {},
+   "source": [
+    "Dieser Code liefert uns die erwarteten Ergebnisse. Wir kÃ¶nnen also nun $\\vec{v}\\cdot|v|$ nutzen, um die korrekten Komponenten von $v^2$ in der Luftwiderstandskraft zu verwenden. Ein praktischer Nebeneffekt ist, dass nun die Vorzeichen erhalten bleiben. Das war beim skalaren quadrieren nicht der Fall und wir mussten die Richtung der Bewegung explizit berÃ¼cksichtigen. Hier mÃ¼ssen wir nur daran denken, dass die Kraft nicht in Bewegungsrichtung, sondern entgegen zeigt, also ein negatives Vorzeichen benÃ¶tigt.  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a7cca46b",
+   "metadata": {},
+   "source": [
+    " <font color='blue'>**Umsetzung**\n",
+    "    \n",
+    "Alle Ã„nderungen im Vergleich zur Ãœbung 9 sind bereits in der VorÃ¼berlegung behandelt worden. Analog zu Ãœbung 9 legen wir nun also zuerst die Konstanten, Anfangswerte (4 Komponenten) und Zeitintervall fest und schreiben dann die DGL-Funktion, die die Ã„nderungsraten von y ausgibt. Dabei beginnen wir mit vx und vz, und nutzen diese Werte, um den Geschwindigkeitsvektor analog zum eben getesteten Code zu bilden und den Betrag zu berechnen. Wir berechnen den Vektor der Widerstandskraft und verwenden deren Komponenten in den beiden KrÃ¤ftebilanzen. In der z-Komponente kommt noch die Gewichtskraft hinzu und die KrÃ¤fte werden durch die Masse m geteilt, um die Beschleunigung a zu erhalten. Zuletzt rufen wir ````scipy.integrate.solve_ivp()```` und Ã¼bergeben wie in Ãœbung 9 die vorbereiteten Parameter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fa5e2b56",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "#Konstanten (Werte wie in UE9)\n",
+    "'?'\n",
+    "A = 0.05 #Mehr Widerstand als in UE9, damit man im x,z Plot etwas davon sieht.\n",
+    "\n",
+    "#Anfangswerte und Zeitintervall (z.B. Werte Geschindigkeit horizontal: 70, vertikal: 10. Position: Strecke 0, Hoehe 500. Intervall 20s)\n",
+    "vx_0, vz_0 = '?'\n",
+    "x_0, z_0 = '?'\n",
+    "\n",
+    "y_0 = '?'\n",
+    "\n",
+    "t_span = '?'\n",
+    "\n",
+    "#In der Funktion wird nun die Gleichung fÃ¼r jede entsprechende Komponente aufgeschrieben. \n",
+    "def func_2D('?'):\n",
+    "    # Komponenten von v\n",
+    "    vx ='?'\n",
+    "    vz ='?'\n",
+    "    \n",
+    "    # Vektor und Betrag v\n",
+    "    vektor_v = '?'\n",
+    "    betrag_v = '?'\n",
+    "    \n",
+    "    # Vektor der Widerstandskraft\n",
+    "    F_W = '?'*vektor_v*'?'\n",
+    "    \n",
+    "    # Berechnen der Komponenten der Beschleunigung\n",
+    "    ax = -F_W['?']/m\n",
+    "    az = '?'\n",
+    "    \n",
+    "    return '?'\n",
+    "\n",
+    "# Aufruf der LÃ¶sungsmethode (maximale Schrittweite 0.25)\n",
+    "sol_2d = '?'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "227968fc",
+   "metadata": {},
+   "source": [
+    "Die Ergebnisse stellen wir als x,z-Plot dar. Da es sich hierbei um zwei rÃ¤umliche Koordinaten handelt, ist es sinnvoll, die beiden Achsenskalierungen gleich zu wÃ¤hlen. Das geht mit dem Befehl ````plt.gca().set_aspect('equal')````. Dabei stellt man fest, dass der Plot sehr klein wird. Wir verwenden also ````plt.figure(figsize=(3,8))````, um eine gewisse GrÃ¶ÃŸe beizubehalten. Die darin eingetragenen Werte sind dabei am leichtesten per Ausprobieren zu bestimmen, bis der Plot gut aussieht. Teste gerne ein wenig herum. Die Ergebisse von x und z werden wie bekannt als Linie dargestellt. Um ein GefÃ¼hl fÃ¼r die Entwicklung der Geschwindigkeit und ihrer Komponenten in den Plot zu integrieren stellen wir noch jedes 8. Wertepaar (auch diese Zahl ist durch probieren, was gut aussieht entschieden worden) per ````plt.scatter()```` als Punkte dar. Einmal auf der Bewegungslinie, und einmal auf Achse. Je grÃ¶ÃŸer der Abstand, desto hÃ¶her die Geschwindigkeit"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "20a9a25e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Der Plot ist etwas detaillierter erstellt, als in vorherigen Ãœbungen. Dies dient der besseren Visualisierung\n",
+    "\n",
+    "plt.'?'  #Zur Steuerung der BildgrÃ¶ÃŸe, die Werte hier sind per trial and error ermittelt.\n",
+    "plt.'?' #Normale Plotlinie\n",
+    "plt.'?'  #Gleiche Achsenskalierung. Da beide Achsen rÃ¤umliche Distanzen sind, ist das sinnvoll.\n",
+    "\n",
+    "#Die Scatter-Punkte geben eine grobe Vorstellung von der Geschwindigkeit (jeder 8. Wert). Grob, da die Zeitschrittweite nicht konstant ist.\n",
+    "#Punkte werden einmal auf der Linie dargestellt, und einmal nach Komponente getrennt (dazu wird eine der Komponenten mit 0 multipliziert)\n",
+    "\n",
+    "plt.scatter('?'['?']['?'][::8], '?'[::8])\n",
+    "\n",
+    "offset_x = 290\n",
+    "offset_z = -110\n",
+    "plt.scatter('?''[::8]'*0+offset_x, '?')\n",
+    "plt.scatter('?', '?'*0+'?')\n",
+    "\n",
+    "#Achsenbeschriftung und anzeigen\n",
+    "'?'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "efa8da00",
+   "metadata": {},
+   "source": [
+    "Wir sehen nun also, welche Flugbahn bei diesem Absprung entsteht, dass in diesem Fall die Geschwindigkeit etwa konstant bleibt, allerdings mit der Zeit die horizontale Komponente nahezu vollstÃ¤ndig in die vertikale Komponente Ã¼bertragen wird.\n",
+    "\n",
+    "Teste beliebige andere FÃ¤lle. Dabei kann es sehr gut sein, dass du die Einstellungen fÃ¼r den Plot entsprechend anpassen musst. Insbesondere das Intervall der Punkte beim Scatter und die Offsets, die bei den Komponentendarstellungen der Punkte die Position der \"Linie\" festlegen."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "93649679",
+   "metadata": {},
+   "source": [
+    "## <font color='blue'>**Problemstellung 2: Ergebnisdaten zum Archivieren und Austauschen abspeichern - csv**\n",
+    "    \n",
+    "Das Abspeichern von (Roh-)Daten ist in vielen FÃ¤llen wichtig. So kann man spÃ¤ter noch auf die Daten zugreifen, ohne die Rechnung zu wiederholen, was sich insbesondere bei langen Laufzeiten lohnt. Man kann die Daten mit verschiedenen Skripten erstellen und verarbeiten, oder die Daten mit anderen teilen.\n",
+    "\n",
+    "#### <font color='blue'>**Aufgabenstellung**\n",
+    "\n",
+    "Die Datenreihen t, vx, vz,  x und z aus der Problemstellung 1 sollen in einer Datei abgespeichert werden. AuÃŸerdem sollen die Daten aus der Datei wieder eingelesen werden.\n",
+    "    \n",
+    "#### <font color='blue'>**VorÃ¼berlegung**\n",
+    "    \n",
+    " In Python kÃ¶nnen wir ASCII-basierte Dateien schreiben, wie wir mÃ¶chten (das funktioniert nach Ã–fnnen einer zu schreibenden Datei mit ````write()```` analog zu ````print()````).\n",
+    "\n",
+    "Wir mÃ¶chten die Datenreihen fÃ¼r t, vx, vz,  x und z in einer Art Tabelle abspeichern, in der jede Zeile einem Zeitschritt und jede Spalte einer der 5 GrÃ¶ÃŸen entspricht.\n",
+    "    \n",
+    "Ein typisches Dateiformat fÃ¼r solche in Tabellen darstellbaren Daten ist csv (Comma-Separated-Value). DafÃ¼r gibt es ein Package ````csv````, das uns die Arbeit etwas erleichtert, da wir uns nicht selbst um die Formatierung innerhalb der Datei kÃ¼mmern mÃ¼ssen, wie es bei dem normalen Datei schreiben der Fall wÃ¤re."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7ad1cbf8",
+   "metadata": {},
+   "source": [
+    "#### <font color='blue'>**Umsetzung**\n",
+    "    \n",
+    "Der CSV Writer hat eine Methode ````wrtiterow()````, die ein Feld erhÃ¤lt und eine Zeile in die Datei schreibt, in der jeder Feldeintrag enthalten ist (getrennt mit dem festgelegten Trennzeichen, standard \",\"). Wenn wir jetzt also die EintrÃ¤ge des Dictionaries an den Writer Ã¼bergeben, wird eine der Datenreihen in eine Zeile geschrieben. GrundsÃ¤tzlich wÃ¤re das auch mÃ¶glich, aber wir hatten oben definiert, dass die Datenreihen in den Spalten stehen sollen. Das entspricht eher dem intuitiven VerstÃ¤ndnis einer Wertetabelle. Wir mÃ¼ssen daher dafÃ¼r sorgen, dass wir dem Writer fÃ¼r jeden Zeitschritt ein Feld mit den fÃ¼nf EintrÃ¤gen [t,  vx, vz, x, z] Ã¼bergeben. Es gibt die Methode ````writerows()````, die ein Feld von Feldern erhÃ¤lt und die in einem Zug alle in dem Ã¤uÃŸeren Feld enthaltenen inneren Felder in aufeinander folgende Zeilen schreibt. Ein solches Feld der Form [[t0,vx0,...],[t1,vx1,...],[...]] kÃ¶nnen wir erstellen, indem wir zunÃ¤chst die fÃ¼nf Datenreihen zusammen in ein np.array schreiben [t, vx, vz, ...]->[[t0,t1,t2,...],[vx0,vx1,vx2,...],...] und dieses dann transponieren. Das transponierte Array kÃ¶nnen wir dann vollstÃ¤ndig der Methode ````writerows()```` Ã¼bergeben. Wir verwenden beim Anlegen des Writer-Objects den Parameter ````quoting = csv.QUOTE_NONNUMERIC````. Dieser sorgt dafÃ¼r, dass nicht-Zahlenwerte (also text) in AnfÃ¼hrungszeichen gesetzt werden. Das ermÃ¶glicht spÃ¤ter beim Wiedereinlesen ein automatisches Erkennen der Zahlenwerte."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c5804a13",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import '?'\n",
+    "\n",
+    "# Anlegen eines Datenfeldes, das wir dann transponieren und dem csv-writer uebergeben koennen\n",
+    "data = np.array([sol_2d[\"t\"], '?', '?', '?', '?'])\n",
+    "\n",
+    "#Ausgabe zum PrÃ¼fen der Felder\n",
+    "print(data[:,:4])\n",
+    "print(\"\\n\")\n",
+    "print(data.T[:4])\n",
+    "\n",
+    "# Datei zum Schreiben oeffnen (Siehe Grundlagen NB. Dateiname ist beliebig waehlbar zb. \"simulation_2D.csv\")\n",
+    "with open('?') as '?':\n",
+    "    writer = csv.writer('?') # Writer Objekt (beachte das Statement zu \"quoting\" im Text oben)\n",
+    "    writer.'?'(['t','?']) # Ãœberschriften, damit die Datei noch nachvollzogen werden kann\n",
+    "    writer.'?'('?') # Schreiben des Datenfeldes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7a434228",
+   "metadata": {},
+   "source": [
+    "Die geschriebene Datei sieht folgendermaÃŸen aus (Wir verwenden hier nicht die csv-spezifischen Lesmethoden, da wir hier die Daten nicht verarbeiten, sondern nur 1:1 ausgeben mÃ¶chten. Allerdings entstehen beim Ausgeben hier zusaÃ¤tzliche Leerzeilen, diese stehen so nicht in der Datei). Du kannst auch die Datei ganz normal auf deinem Computer finden und Ã¶ffnen, wie jede andere Textdatei auch."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "556f7e3a",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "print(\"Inhalt der Datei:\\n\\n\")\n",
+    "\n",
+    "#Datei zum Lesen Oeffnen\n",
+    "with open('?') as f:\n",
+    "    lines = f.'?'[:5] #Lesen und Speichern der ersten 5 Zeilen\n",
+    "\n",
+    "    \n",
+    "#Alle Zeilen ausgeben. end =\"\" in print verhindert einen Zeilenumbruch beim naechsten print\n",
+    "for line in lines:\n",
+    "    print('?', end=\"\")\n",
+    "\n",
+    "print(\"[...]\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5f03cd53",
+   "metadata": {},
+   "source": [
+    "Wir kÃ¶nnten die Datei auch ohne das Paket ````csv```` schreiben. Dann mÃ¼ssten wir allerdings manuell fÃ¼r das korrekte Format sorgen. Das kÃ¶nnte zum Beispiel so aussehen (wir nutzen hier das bereits vorbereitete Datenfeld):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "34bc8829",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"simulation_2D_manual.csv\", \"w\") as f:\n",
+    "    f.write('\"t\",\"vx\", \"?\" \\n') #Ãœberschriften, alle Trennzeichen, AnfÃ¼hrungszeichen und ZeilenumbrÃ¼che manuell\n",
+    "    #Schleife Ã¼ber alle Zeilen im Datenfeld\n",
+    "    for line in '?':\n",
+    "        f.write(f\"{line[0]},{line[1]},'?'\") #Schreiben der einzelnen Spalten der Zeile. Trennzeichen und Zeilenumbruch manuell"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0e573125",
+   "metadata": {},
+   "source": [
+    "Als nÃ¤chstes sollen die Daten wieder eingelesen werden. Hier ist es zwar das selbe Notebook, aber man kÃ¶nnte diese Datei in jedem beliebigen anderen Notebook oder Programm einlesen, ohne die Rechnung wiederholen zu mÃ¼ssen.\n",
+    "\n",
+    "Zum Einlesen nutzen wir wieder das csv Paket. Mit dem Reader werden alle Zeilen nacheinander ausgelesen. Dazu iterieren wir Ã¼ber alle Elemente des readers (reader ist allerdings kein Feld. Einfach gesagt, kann man es nur genau einmal und nur von vorne bis hinten durchlaufen). Jedes Element ist ein Feld mit dem Inhalt der Zeile (getrennt durch die Trennzeichen). Dank der Option ````quoting=csv.QUOTE_NONNUMERIC```` werden alle Zahlen, die nicht mit AnfÃ¼hrungszeichen versehen sind direkt als Zahl eingelesen (standardmÃ¤ÃŸig wÃ¼rden sie als Zeichen eingelesen). Wir hÃ¤ngen jede Zeile an ein von uns angelegtes Feld  (hier ````rows````)an. So haben wir nach der Schleife ein Feld mit weiteren Feldern der Wertepaare (t, vx, vz, x, z) fÃ¼r jeden Zeitschritt.\n",
+    "\n",
+    "Dieses mÃ¶chten wir nun wieder in ein Dictionary schreiben, damit wir sie genau so behandeln kÃ¶nnen, wie die LÃ¶sungen aus der Berechnung. Dazu fÃ¼hren wir den Umformschritt wie vor dem Abspeichern durch, um in den inneren Felder nicht die Wertepaare eines Zeitschritts, sondern alle Zeitschritte einer GrÃ¶ÃŸe zu bekommen. Wir legen also ein Numpy array aus der Liste von Listen an (dabei Ãœberspringen wir die erste Zeile, die ja die Ãœberschriften enthÃ¤lt) und transponieren das Array. AnschlieÃŸend legen wir ein Dictionary an und tragen die einzelnen Arrays aus dem groÃŸen Array ein. Dann haben wir ein Dictionary, das genau so einsetzbar ist, wie die Dictionaries, die aus der Werte gekommen sind."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "10673537",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rows = '?'\n",
+    "with open('?') as f:\n",
+    "    reader = csv.reader('?')\n",
+    "    for row in reader:\n",
+    "        rows.append('?')\n",
+    "\n",
+    "# Alle Zeilen ab der zweiten als np.array formatieren und transponieren, um aus [[x1,y1],[x2,y2]] [[x1,x2],[y1,y2]] zu machen\n",
+    "data_import = np.array('?').'?' \n",
+    "\n",
+    "#Sortieren der jeweiligen Listen in das Dictionary\n",
+    "sol_imported={}\n",
+    "sol_imported[\"t\"] = data_import['?']\n",
+    "sol_imported[\"y\"] = '?' # In y wird also wie auch oben die Matrix (v,h) gespeichert."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7a2c5185",
+   "metadata": {},
+   "source": [
+    "Nun ist die LÃ¶sung importiert. Wir testen das, indem wir den oben gezeigten Plot nun noch einmal mit der importierten LÃ¶sung erstellen."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e870d961",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Diese importierte LÃ¶sung kann nun genau so dargestellt werden, wie die originale LÃ¶sung. (Zur Erstellung des Plots, siehe oben)\n",
+    "\n",
+    "'?'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a3461331",
+   "metadata": {},
+   "source": [
+    "Auch hier mÃ¶chte ich noch einmal zeigen, wie das ohne das CSV Paket aussehen kann (wir mÃ¼ssen uns also wieder manuell um die Formatierung kÃ¼mmern):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3ea9d27a",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "# Wir legen wieder ein Feld \"rows\" mit den Zeilen an. In dieses fÃ¼gen wir die Zahlendaten jeder Zeile als Liste ein\n",
+    "\n",
+    "rows = '?'\n",
+    "\n",
+    "with open('?') as f:\n",
+    "    content = '?'['?'] #wir Ã¼berspringen die erste Zeile und speichern den Rest in content ab\n",
+    "    \n",
+    "    #iteration Ã¼ber alle Zeilen, die nun immer als ein String eingelesen sind\n",
+    "    for '?' in '?':\n",
+    "        line_splitted = '?'.'?' #teilt den string an den \",\" in eine Liste aus den Teilstrings auf (siehe Grundlagennotebook Dateien)\n",
+    "        current_row = []\n",
+    "        for element in line_splitted:\n",
+    "            # Anhangen des Werts des Elements als float an die Liste der Zeile\n",
+    "            current_row.'?'('?'('?')) \n",
+    "        '?' # Anhangen der aktuellen Zeile an die Liste mit allen Zeilen\n",
+    "\n",
+    "#Weiteren koennen wir rows genau wie oben bei der Verwendung von csv weiterverarbeiten\n",
+    "data_import = '?'\n",
+    "        \n",
+    "# Zuletzt legen wir das Dictionary an und konvertieren die Listen zu np.arrays\n",
+    "sol_man_imported='?'\n",
+    "sol_man_imported[\"t\"] = '?'\n",
+    "sol_man_imported[\"y\"] = '?'\n",
+    "\n",
+    "#zum Test ein paar Werte ausgeben\n",
+    "print(\"y: \",sol_man_imported[\"t\"][:10], \"\\nvx: \", sol_man_imported[\"y\"][0][:10])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ca033fad",
+   "metadata": {},
+   "source": [
+    "## <font color='blue'> **Schlussbemerkung**\n",
+    "    \n",
+    "Wir haben gesehen, dass wir mit relativ einfachen Mitteln die SciPy LÃ¶sungsmethode fÃ¼r DGL auf weitere LÃ¶sungsvariablen, wie z.B. mehrere Raumdimensionen erweitern kÃ¶nnen. Die eigentliche Schwierigkeit in Problemstellung 1 war das Ãœbertragen des Quadrats der Geschwindigkeit fÃ¼r den Luftwiderstand als Vektor.\n",
+    "    \n",
+    "Dann haben wir eine Methode besprochen, mit der tabellarische Daten wie die Ergebnisse von Simulationen im Zeitbereich kompakt und speicherschonend und fÃ¼r andere Programme importierbar auf der Festplatte gespeichert werden kÃ¶nnen.\n",
+    "\n",
+    "## <font color='blue'> **Ausblick**\n",
+    "\n",
+    "Nicht alle Daten lassen sich so gut als Tabelle darstellen, wie die Ergebnisse dieser Ãœbung. In der nÃ¤chsten Ãœbung werden wir (auch zur Wiederholung) eine kleine objektorientierte Datenstruktur aufbauen und Funktionen entwickeln, mit denen wir diese strukturierten Daten in geeigneten Dateien auf der Festplatte speichern kÃ¶nnen.\n",
+    "    \n",
+    "## <font color='blue'> **Aufgaben zum selbst probieren**\n",
+    "\n",
+    "* Erweitere die 2D-Fallsimulation auf 3D.\n",
+    "* Erweitere die 2D/3D Fallsimulation mit der Ã–ffnung eines Fallschirms (wie in Ãœbung 9)\n",
+    "* Schreibe ein Skript, dass die Ergebnisdaten in einem csv-artigen ASCII Format abspeichert. Die Zeit soll mit drei Nachkommastellen, alle anderen Variablen nur mit je zwei Nachkommastellen eingetragen werden. Die Trennung zwischen den Werten sollen ausschlieÃŸlich Leerzeichen (mindestens 3) sein. Schreibe ebenfalls ein Skript, das diese Daten einlieÃŸt. Du kannst dazu das csv-Paket nutzen, oder das Format von Hand definieren.\n",
+    "* (Zusatz) FÃ¼ge einen hÃ¶henabhÃ¤ngigen Wind hinzu (z.B. 0 m/s am Boden 25m/s in 1000m HÃ¶he, linear interpoliert). Beachte, dass der Luftwiderstand von der Geschwindigkeit *gegenÃ¼ber der Luft* abhÃ¤ngig ist. Der Ort ist weiterhin von der absoluten Geschwindigkeit abhÃ¤ngig. Ãœberlege dir also, wie du auf den entsprechenden Geschwindigkeitsvektor fÃ¼r die Ermittlung des Widerstands und dessen Richtung kommst. \n",
+    "\n",
+    "FÃ¼ge deiner Kopie des Notebooks beliebig viele Codezellen hinzu, um die Aufgaben zu lÃ¶sen."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.8.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Uebung10/Uebung_10_LSG.ipynb b/Uebung10/Uebung_10_LSG.ipynb
new file mode 100644
index 0000000..1ccac50
--- /dev/null
+++ b/Uebung10/Uebung_10_LSG.ipynb
@@ -0,0 +1,587 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e10b6cba",
+   "metadata": {},
+   "source": [
+    "# <font color='blue'>**Ãœbung 10 - Erweiterung der Fallmodellierung um weitere Raumdimensionen und Abspeichern und Laden von Ergebnisdaten - SciPy, csv**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ece841a5",
+   "metadata": {},
+   "source": [
+    "In dieser Ãœbung mÃ¶chten wir zunÃ¤chst noch eine Erweiterung an der Modellierung des Falls durch die Luft vornehmen. Wir haben bisher nur eine Richtung betrachtet. Ein typischer Fallschirmsprung findet aus einem Flugzeug statt, das sich Ã¼ber die ErdoberflÃ¤che bewegt. Es kÃ¶nnte daher interessant sein, nicht nur die HÃ¶he zu betrachten, sondern auch andere Raumrichtungen. Wir wollen uns dabei nur auf die Erweiterung um eine Raumrichtung konzentrieren, und vernachlÃ¤ssigen daher in dieser Ãœbung die KomplexitÃ¤t durch Ã–ffnen des Fallschirms aus der letzten Ãœbung.\n",
+    "Nachdem wir gesehen haben, wie man Simulationen erzeugt, wollen wir uns ansehen, wir man die Ergebnisse oder auch Objekte (wie das Fachwerk) in Dateien speichern und aus Dateien lesen kann. Das ermÃ¶glicht langfristiges Abspeichern, das Verwenden der Daten in anderen Programmen, und das Weitergeben an andere Personen. Dabei wollen wir uns ein paar gÃ¤ngige Formate ansehen, die fÃ¼r verschiedene Zwecke verschieden geeignet sind.\n",
+    "\n",
+    "### <font color='blue'>**Vorkenntnisse - Notebooks**\n",
+    "* Ãœbung 1\n",
+    "* Ãœbung 2\n",
+    "* Ãœbung 4\n",
+    "* Ãœbung 5\n",
+    "* Ãœbung 9\n",
+    "* Grundlagen Python\n",
+    "* Grundlagen Matplotlib\n",
+    "* Grundlagen Numpy\n",
+    "* Grundlagen SciPy\n",
+    "\n",
+    "### <font color='blue'>**Notebooks, die helfen kÃ¶nnen**\n",
+    "* Grundlagen Dateien\n",
+    "    * darin nur die Abschnitte zu allgemeinen ASCII-Dateien und CSV fÃ¼r diese Ãœbung notwendig. Json, xml und pickle kÃ¶nnen fÃ¼r diese Ãœbung noch Ã¼bersprungen werden. Achte darauf, dass im Notebook zuerst alle Formate allgemein vorgestellt werden und erst spÃ¤ter die Umsetzung in Python. Es kommt also auch im hinteren Teil noch etwas zu csv dran. Ds ist aber durch die Ãœberschriften deutlich erkennba\n",
+    "\n",
+    "### <font color='blue'>**Lernziele**\n",
+    "* Erweiterung einer Simulation um weitere Variablen\n",
+    "* Lesen und Schreiben von Daten im csv Format - Datenreihen"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eca5ef34",
+   "metadata": {},
+   "source": [
+    "## <font color='blue'>**Problemstellung 1: 2D Fall (ohne FallschirmÃ¶ffnung)**\n",
+    "\n",
+    " <font color='blue'>**Aufgabenstellung**\n",
+    "     \n",
+    "Die Berechnung mit *SciPy* aus Ãœbung 9 soll nun nicht mehr eine Raumdimension haben, sondern HÃ¶he (z) und Strecke (x), sodass beispielsweise ein Absprung aus einem Flugzeug simuliert werden kann. Um sich aufs wesentliche zu konzentrieren, kann in dieser Aufgabe ein VerÃ¤ndern der Parameter (also ein Ã–ffnen des Schirms) vernachlÃ¤ssigt werden. AuÃŸerdem darf davon ausgegeangen werden, dass der KÃ¶rper immer der Bewegunsrichtung nach ausgerichtet ist (das heiÃŸt A und C_W sind unabhÃ¤ngig von der Richtung). Zuletzt sollen die ermittelten Ortskoordinaten wÃ¤hrend des Falls in einem Diagramm dargestellt werden.\n",
+    "\n",
+    " <font color='blue'>**VorÃ¼berlegung**\n",
+    "\n",
+    "Wir haben nun nicht mehr je eine Komponente fÃ¼r die Geschwindigkeit und den Ort, sondern beide GrÃ¶ÃŸen haben nun zwei Komponenten. Man kÃ¶nnte sich vorstellen, das wir statt Skalaren nun Vektoren in y schreiben kÃ¶nnten. Allerdings kann ````scipy.integrate.solve_ivp()```` nur eindimensionale Vektoren verarbeiten. Das ist aber kein Problem. Wir kÃ¶nnen einfach unsere Geschwindigkeitskomponenten und Koordinaten hintereinander in y schreiben (ohne sie zu einzelnen Vektoren zusammenzufassen). Wir definieren also y als [vx, vz, x, z].\n",
+    "     \n",
+    "Das bedeutet, wir mÃ¼ssen ein neues y_0 mit 4 EintrÃ¤gen initialisieren und die DGL-Funktion so umschreiben, dass sie nun fÃ¼r jede der 4 Komponenten von y eine Ã„nderungsrate zurÃ¼ckgibt. ZurÃ¼ckgeben mÃ¼ssen wir also den Vektor [ax, az, vx, vz].\n",
+    "\n",
+    "FÃ¼r diese RÃ¼ckgabe sind vx und vz sehr leicht zu bestimmen, denn sie entsprechen den ersten beiden EintrÃ¤gen von y.\n",
+    "\n",
+    "Die Beschleunigung ist ein bisschen komplizierter:\n",
+    "Die Beschleunigung in einer Raumrichtung ist nach $F=ma$ die Summe aller KrÃ¤fte in diese Raumrichtung geteilt durch die Masse. \n",
+    "\n",
+    "Die x-Richtung erfÃ¤hrt als Kraft nur einen Anteil des Luftwiderstands.\n",
+    "     \n",
+    "Die z-Richtung setzt sich aus einem Anteil des Luftwiderstands und der Erdgravitation zusammen.\n",
+    "     \n",
+    "Eine kleine Schwierigkeit stellt die Berechnung des Anteils des Luftwiderstands dar. Dieser hÃ¤ngt nÃ¤mlich durch das Quadrat nichtlinear mit dem Geschwindigkeitsvektor zusammen. Das heiÃŸt, wir kÃ¶nnen nicht einfach die bisher benutzte Formel auf die beiden Geschwindigkeitskomponenten getrennt voneinander anwenden. Die Formel gibt uns nÃ¤mlich eigentlich den Betrag der Luftwiderstandskraft entgegen der Bewegungsrichtung in AbhÃ¤ngigkeit des Betrags der Geschwindigkeit zum Quadrat an. Wenn wir die einzelnen Komponenten quadrieren, kommt aber ein anderer Vektor heraus, als der Vektor, der in die ursprÃ¼ngliche Richtung zeigt und dessen Betrag dem Quadrat des ursprÃ¼nglichen Betrags entspricht.\n",
+    "\n",
+    "Das lÃ¤sst sich leichter an einem Beispiel zeigen (auch im Bild grafisch dargestellt): Betrachten wir den Vektor (3,4) mit dem Betrag 5 (Pythagoras). Quadrieren wir die EintrÃ¤ge erhalten wir (9,16) mit dem Betrag 18.35, der auch in eine andere Richtung zeigt. Wir suchen aber fÃ¼r das Quadrat dieses Vektors eigentlich den Vektor mit dem quadrierten Betrag (5Â²=25), der immer noch in die gleiche Richtung wie (3,4) zeigt. Diesen erhalten wir durch Skalierung des Vektors mit seinem Betrag (4,3)*|(4,3)|= (4,3) * 5 =(15,20).\n",
+    "     \n",
+    "Um sicherzustellen, dass wir diese Berechnung spÃ¤ter fÃ¼r die Berechnung der Widerstandskraft richtig verwenden, testen wir zunÃ¤chst den Code mit den Zahlen aus dem Beispiel von eben."
+   ]
+  },
+  {
+   "attachments": {
+    "Vektorquadrat.PNG": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "id": "dcb9f50b",
+   "metadata": {},
+   "source": [
+    "![Vektorquadrat.PNG](attachment:Vektorquadrat.PNG)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "eb4179de",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import scipy.integrate\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "8018b4f2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Vektor: [4 3]\n",
+      "Betrag des Vektors: 5.0\n",
+      "Betrag zum Quadrat: 25.0\n",
+      "Vektor mit dem Betrag 25.0 durch Skalierung des ursprÃ¼nglichen Vektors mit seinem (Betrag * Vektor): [20. 15.]\n",
+      "Probe: Betrag des erhaltenen Vektors: 25.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "y = [4,3,0,0]\n",
+    "\n",
+    "yx = y[0]\n",
+    "yz = y[1]\n",
+    "vektor_1 = np.array([yx, yz])\n",
+    "betrag_1 = np.linalg.norm(vektor_1)\n",
+    "vektor_quadriert = vektor_1*betrag_1\n",
+    "\n",
+    "#Kontrollausgabe\n",
+    "print(f\"Vektor: {vektor_1}\")\n",
+    "print(f\"Betrag des Vektors: {betrag_1}\")\n",
+    "print(f\"Betrag zum Quadrat: {betrag_1**2}\")      \n",
+    "print(f\"Vektor mit dem Betrag {betrag_1**2} durch Skalierung des ursprÃ¼nglichen Vektors mit seinem (Betrag * Vektor): {vektor_quadriert}\")\n",
+    "print(f\"Probe: Betrag des erhaltenen Vektors: {np.linalg.norm(vektor_quadriert)}\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dd71b98b",
+   "metadata": {},
+   "source": [
+    "Dieser Code liefert uns die erwarteten Ergebnisse. Wir kÃ¶nnen also nun $\\vec{v}\\cdot|v|$ nutzen, um die korrekten Komponenten von $v^2$ in der Luftwiderstandskraft zu verwenden. Ein praktischer Nebeneffekt ist, dass nun die Vorzeichen erhalten bleiben. Das war beim skalaren quadrieren nicht der Fall und wir mussten die Richtung der Bewegung explizit berÃ¼cksichtigen. Hier mÃ¼ssen wir nur daran denken, dass die Kraft nicht in Bewegungsrichtung, sondern entgegen zeigt, also ein negatives Vorzeichen benÃ¶tigt.  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a7cca46b",
+   "metadata": {},
+   "source": [
+    " <font color='blue'>**Umsetzung**\n",
+    "    \n",
+    "Alle Ã„nderungen im Vergleich zur Ãœbung 9 sind bereits in der VorÃ¼berlegung behandelt worden. Analog zu Ãœbung 9 legen wir nun also zuerst die Konstanten, Anfangswerte (4 Komponenten) und Zeitintervall fest und schreiben dann die DGL-Funktion, die die Ã„nderungsraten von y ausgibt. Dabei beginnen wir mit vx und vz, und nutzen diese Werte, um den Geschwindigkeitsvektor analog zum eben getesteten Code zu bilden und den Betrag zu berechnen. Wir berechnen den Vektor der Widerstandskraft und verwenden deren Komponenten in den beiden KrÃ¤ftebilanzen. In der z-Komponente kommt noch die Gewichtskraft hinzu und die KrÃ¤fte werden durch die Masse m geteilt, um die Beschleunigung a zu erhalten. Zuletzt rufen wir ````scipy.integrate.solve_ivp()```` und Ã¼bergeben wie in Ãœbung 9 die vorbereiteten Parameter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "fa5e2b56",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "#Konstanten\n",
+    "g = 9.81\n",
+    "m = 1\n",
+    "rho = 1.225\n",
+    "C_W = 0.18\n",
+    "A = 0.05 #Mehr Widerstand als in UE9, damit man im x,z Plot etwas davon sieht.\n",
+    "\n",
+    "#Anfangswerte und Zeitintervall\n",
+    "vx_0, vz_0 = 70, 10\n",
+    "x_0, z_0 = 0, 500\n",
+    "\n",
+    "y_0 = [vx_0, vz_0, x_0, z_0]\n",
+    "\n",
+    "t_span = [0,20]\n",
+    "\n",
+    "#In der Funktion wird nun die Gleichung fÃ¼r jede entsprechende Komponente aufgeschrieben. \n",
+    "def func_2D(t,y,g,m,rho,C_W,A):\n",
+    "    # Komponenten von v\n",
+    "    vx = y[0]\n",
+    "    vz = y[1]\n",
+    "    \n",
+    "    # Vektor und Betrag v\n",
+    "    vektor_v = np.array([vx,vz])\n",
+    "    betrag_v = np.linalg.norm(vektor_v)\n",
+    "    \n",
+    "    # Vektor der W\n",
+    "    F_W = 0.5*rho*vektor_v*betrag_v*C_W*A\n",
+    "    \n",
+    "    ax = -F_W[0] /m\n",
+    "    az = (-F_W[1] - m*g)/m\n",
+    "\n",
+    "    return [ax, az, vx, vz]\n",
+    "\n",
+    "sol_2d = scipy.integrate.solve_ivp(func_2D, t_span, y_0, max_step = 0.25, args=(g, m, rho, C_W, A))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "227968fc",
+   "metadata": {},
+   "source": [
+    "Die Ergebnisse stellen wir als x,z-Plot dar. Da es sich hierbei um zwei rÃ¤umliche Koordinaten handelt, ist es sinnvoll, die beiden Achsenskalierungen gleich zu wÃ¤hlen. Das geht mit dem Befehl ````plt.gca().set_aspect('equal')````. Dabei stellt man fest, dass der PLot sehr klein wird. Wir verwenden also ````plt.figure(figsize=(3,8))````, um eine gewisse GrÃ¶ÃŸe beizubehalten. Die darin eingetragenen Werte sind dabei am leichtesten per Ausprobieren zu bestimmen, bis der Plot gut aussieht. Die Ergebisse von x und z werden wie bekannt als Linie dargestellt. Um ein GefÃ¼hl fÃ¼r die Entwicklung der Geschwindigkeit und ihrer Komponenten in den Plot zu integrieren stellen wir noch jedes 8. Wertepaar (auch diese Zahl ist durch probieren, was gut aussieht entschieden worden) per ````plt.scatter()```` als Punkte dar. Einmal auf der Bewegungslinie, und einmal auf Achse. Je grÃ¶ÃŸer der Abstand, desto hÃ¶her die Geschwindigkeit"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "20a9a25e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 216x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#Der Plot ist etwas detaillierter erstellt, als in vorherigen Ãœbungen. Dies dient der besseren Visualisierung\n",
+    "\n",
+    "plt.figure(figsize=(3,8)) #Zur Steuerung der BildgrÃ¶ÃŸe, die Werte hier sind per trial and error ermittelt.\n",
+    "plt.plot(sol_2d[\"y\"][2], sol_2d[\"y\"][3]) #Normale Plotlinie\n",
+    "plt.gca().set_aspect('equal') #Gleiche Achsenskalierung. Da beide Achsen rÃ¤umliche Distanzen sind, ist das sinnvoll.\n",
+    "\n",
+    "#Die Scatter-Punkte geben eine grobe Vorstellung von der Geschwindigkeit (jeder 8. Wert). Grob, da die Zeitschrittweite nicht konstant ist.\n",
+    "#Punkte werden einmal auf der Linie dargestellt, und einmal nach Komponente getrennt (dazu wird eine der Komponenten mit 0 multipliziert)\n",
+    "\n",
+    "plt.scatter(sol_2d[\"y\"][2][::8], sol_2d[\"y\"][3][::8])\n",
+    "\n",
+    "offset_x = 290\n",
+    "offset_z = -110\n",
+    "plt.scatter(sol_2d[\"y\"][2][::8]*0+offset_x, sol_2d[\"y\"][3][::8])\n",
+    "plt.scatter(sol_2d[\"y\"][2][::8], sol_2d[\"y\"][3][::8]*0+offset_z)\n",
+    "\n",
+    "#Achsenbeschriftung\n",
+    "plt.xlabel(\"x\")\n",
+    "plt.ylabel(\"z\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "efa8da00",
+   "metadata": {},
+   "source": [
+    "Wir sehen nun also, welche Flugbahn bei diesem Absprung entsteht, dass in diesem Fall die Geschwindigkeit etwa konstant bleibt, allerdings mit der Zeit die horizontale Komponente nahezu vollstÃ¤ndig in die vertikale Komponente Ã¼bertragen wird.\n",
+    "\n",
+    "Teste beliebige andere FÃ¤lle. Dabei kann es sehr gut sein, dass du die Einstellungen fÃ¼r den Plot entsprechend anpassen musst. Insbesondere das Intervall der Punkte beim Scatter und die Offsets, die bei den Komponentendarstellungen der Punkte die Position der \"Linie\" festlegen."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "93649679",
+   "metadata": {},
+   "source": [
+    "## <font color='blue'>**Problemstellung 2: Ergebnisdaten zum Archivieren und Austauschen abspeichern - csv**\n",
+    "    \n",
+    "Das Abspeichern von (Roh-)Daten ist in vielen FÃ¤llen wichtig. So kann man spÃ¤ter noch auf die Daten zugreifen, ohne die Rechnung zu wiederholen, was sich insbesondere bei langen Laufzeiten lohnt. Man kann die Daten mit verschiedenen Skripten erstellen und verarbeiten, oder die Daten mit anderen teilen.\n",
+    "\n",
+    "#### <font color='blue'>**Aufgabenstellung**\n",
+    "\n",
+    "Die Datenreihen t, vx, vz,  x und z aus der Problemstellung 1 sollen in einer Datei abgespeichert werden. AuÃŸerdem sollen die Daten aus der Datei wieder eingelesen werden.\n",
+    "    \n",
+    "#### <font color='blue'>**VorÃ¼berlegung**\n",
+    "    \n",
+    " In Python kÃ¶nnen wir ASCII-basierte Dateien schreiben, wie wir mÃ¶chten (das funktioniert nach Ã–fnnen einer zu schreibenden Datei mit ````write()```` analog zu ````print()````).\n",
+    "\n",
+    "Wir mÃ¶chten die Datenreihen fÃ¼r t, vx, vz,  x und z in einer Art Tabelle abspeichern, in der jede Zeile einem Zeitschritt und jede Spalte einer der 5 GrÃ¶ÃŸen entspricht.\n",
+    "    \n",
+    "Ein typisches Dateiformat fÃ¼r solche in Tabellen darstellbaren Daten ist csv (Comma-Separated-Value). DafÃ¼r gibt es ein Package ````csv````, das uns die Arbeit etwas erleichtert, da wir uns nicht selbst um die Formatierung innerhalb der Datei kÃ¼mmern mÃ¼ssen, wie es bei dem normalen Datei schreiben der Fall wÃ¤re."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7ad1cbf8",
+   "metadata": {},
+   "source": [
+    "#### <font color='blue'>**Umsetzung**\n",
+    "    \n",
+    "Der CSV Writer hat eine Methode ````wrtiterow()````, die ein Feld erhÃ¤lt und eine Zeile in die Datei schreibt, in der jeder Feldeintrag enthalten ist (getrennt mit dem festgelegten Trennzeichen, standard \",\"). Wenn wir jetzt also die EintrÃ¤ge des Dictionaries an den Writer Ã¼bergeben, wird eine der Datenreihen in eine Zeile geschrieben. GrundsÃ¤tzlich wÃ¤re das auch mÃ¶glich, aber wir hatten oben definiert, dass die Datenreihen in den Spalten stehen sollen. Das entspricht eher dem intuitiven VerstÃ¤ndnis einer Wertetabelle. Wir mÃ¼ssen daher dafÃ¼r sorgen, dass wir dem Writer fÃ¼r jeden Zeitschritt ein Feld mit den fÃ¼nf EintrÃ¤gen [t,  vx, vz, x, z] Ã¼bergeben. Es gibt die Methode ````writerows()````, die ein Feld von Feldern erhÃ¤lt und die in einem Zug alle in dem Ã¤uÃŸeren Feld enthaltenen inneren Felder in aufeinander folgende Zeilen schreibt. Ein solches Feld der Form [[t0,vx0,...],[t1,vx1,...],[...]] kÃ¶nnen wir erstellen, indem wir zunÃ¤chst die fÃ¼nf Datenreihen zusammen in ein np.array schreiben [t, vx, vz, ...]->[[t0,t1,t2,...],[vx0,vx1,vx2,...],...] und dieses dann transponieren. Das transponierte Array kÃ¶nnen wir dann vollstÃ¤ndig der Methode ````writerows()```` Ã¼bergeben. Wir verwenden beim Anlegen des Writer-Objects den Parameter ````csv.QUOTE_NONNUMERIC````. Dieser sorgt dafÃ¼r, dass nicht-Zahlenwerte (also text) in AnfÃ¼hrungszeichen gesetzt werden. Das ermÃ¶glicht spÃ¤ter beim Wiedereinlesen ein automatisches Erkennen der Zahlenwerte."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "c5804a13",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[0.00000000e+00 2.47426240e-05 2.72168864e-04 2.74643126e-03]\n",
+      " [7.00000000e+01 6.99993249e+01 6.99925745e+01 6.99251444e+01]\n",
+      " [1.00000000e+01 9.99966083e+00 9.99626939e+00 9.96237826e+00]\n",
+      " [0.00000000e+00 1.73197533e-03 1.90508099e-02 1.92147358e-01]\n",
+      " [5.00000000e+02 5.00000247e+02 5.00002721e+02 5.00027413e+02]]\n",
+      "\n",
+      "\n",
+      "[[0.00000000e+00 7.00000000e+01 1.00000000e+01 0.00000000e+00\n",
+      "  5.00000000e+02]\n",
+      " [2.47426240e-05 6.99993249e+01 9.99966083e+00 1.73197533e-03\n",
+      "  5.00000247e+02]\n",
+      " [2.72168864e-04 6.99925745e+01 9.99626939e+00 1.90508099e-02\n",
+      "  5.00002721e+02]\n",
+      " [2.74643126e-03 6.99251444e+01 9.96237826e+00 1.92147358e-01\n",
+      "  5.00027413e+02]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import csv\n",
+    "\n",
+    "# Anlegen eines Datenfeldes, das wir dann transponieren und dem csv-writer uebergeben koennen\n",
+    "data = np.array([sol_2d[\"t\"], sol_2d[\"y\"][0], sol_2d[\"y\"][1], sol_2d[\"y\"][2], sol_2d[\"y\"][3]])\n",
+    "\n",
+    "#Ausgabe zum PrÃ¼fen der Felder\n",
+    "print(data[:,:4])\n",
+    "print(\"\\n\")\n",
+    "print(data.T[:4])\n",
+    "\n",
+    "# Datei zum Schreiben oeffnen\n",
+    "with open(\"simulation_2D.csv\",'w', newline='') as f:\n",
+    "    writer = csv.writer(f, quoting=csv.QUOTE_NONNUMERIC) # Writer Objekt\n",
+    "    writer.writerow(['t','vx','vz','x','z']) # Ãœberschriften, damit die Datei noch nachvollzogen werden kann\n",
+    "    writer.writerows(data.T) # Schreiben des Datenfeldes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7a434228",
+   "metadata": {},
+   "source": [
+    "Die geschriebene Datei sieht folgendermaÃŸen aus (Wir verwenden hier nicht die csv-spezifischen Lesmethoden, da wir hier die Daten nicht verarbeiten, sondern nur 1:1 ausgeben mÃ¶chten. Allerdings entstehen beim Ausgeben hier zusaÃ¤tzliche Leerzeilen, diese stehen so nicht in der Datei). Du kannst auch die Datei ganz normal auf deinem Computer finden und Ã¶ffnen, wie jede andere Textdatei auch."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "556f7e3a",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Inhalt der Datei:\n",
+      "\n",
+      "\n",
+      "\"t\",\"vx\",\"vz\",\"x\",\"z\"\n",
+      "0.0,70.0,10.0,0.0,500.0\n",
+      "2.47426239594269e-05,69.99932489223151,9.999660832062501,0.0017319753251635336,500.0002474220436\n",
+      "0.0002721688635536959,69.99257454870897,9.996269386305274,0.019050809923807782,500.00272118094546\n",
+      "0.0027464312594963854,69.92514444833192,9.96237826465535,0.19214735776814215,500.0274126378807\n",
+      "[...]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Inhalt der Datei:\\n\\n\")\n",
+    "\n",
+    "#Datei zum Lesen Oeffnen\n",
+    "with open(\"simulation_2D.csv\",\"r\") as f:\n",
+    "    lines = f.readlines()[:5] #Lesen und Speichern der ersten 5 Zeilen\n",
+    "\n",
+    "    \n",
+    "#Alle Zeilen ausgeben. end =\"\" in print verhindert einen Zeilenumbruch beim naechsten print\n",
+    "for line in lines:\n",
+    "    print(line, end=\"\")\n",
+    "\n",
+    "print(\"[...]\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5f03cd53",
+   "metadata": {},
+   "source": [
+    "Wir kÃ¶nnten die Datei auch ohne das Paket ````csv```` schreiben. Dann mÃ¼ssten wir allerdings manuell fÃ¼r das korrekte Format sorgen. Das kÃ¶nnte zum Beispiel so aussehen (wir nutzen hier das bereits vorbereitete Datenfeld):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "34bc8829",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"simulation_2D_manual.csv\", \"w\") as f:\n",
+    "    f.write('\"t\",\"vx\",\"vz\",\"x\",\"y\"\\n') #Ãœberschriften, alle Trennzeichen, AnfÃ¼hrungszeichen und ZeilenumbrÃ¼che manuell\n",
+    "    #Schleife Ã¼ber alle Zeilen im Datenfeld\n",
+    "    for line in data.T:\n",
+    "        f.write(f\"{line[0]},{line[1]},{line[2]},{line[3]},{line[4]}\\n\") #Schreiben der einzelnen Spalten der Zeile. Trennzeichen und Zeilenumbruch manuell"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0e573125",
+   "metadata": {},
+   "source": [
+    "Als nÃ¤chstes sollen die Daten wieder eingelesen werden. Hier ist es zwar das selbe Notebook, aber man kÃ¶nnte diese Datei in jedem beliebigen anderen Notebook oder Programm einlesen, ohne die Rechnung wiederholen zu mÃ¼ssen.\n",
+    "\n",
+    "Zum Einlesen nutzen wir wieder das csv Paket. Mit dem Reader werden alle Zeilen nacheinander ausgelesen. Dazu iterieren wir Ã¼ber alle Elemente des readers (reader ist allerdings kein Feld. Einfach gesagt, kann man es nur genau einmal und nur von vorne bis hinten durchlaufen). Jedes Element ist ein Feld mit dem Inhalt der Zeile (getrennt durch die Trennzeichen). Dank der Option ````quoting=csv.QUOTE_NONNUMERIC```` werden alle Zahlen, die nicht mit AnfÃ¼hrungszeichen versehen sind direkt als Zahl eingelesen (standardmÃ¤ÃŸig wÃ¼rden sie als Zeichen eingelesen). Wir hÃ¤ngen jede Zeile an ein von uns angelegtes Feld  (hier ````rows````)an. So haben wir nach der Schleife ein Feld mit weiteren Feldern der Wertepaare (t, vx, vz, x, z) fÃ¼r jeden Zeitschritt.\n",
+    "\n",
+    "Dieses mÃ¶chten wir nun wieder in ein Dictionary schreiben, damit wir sie genau so behandeln kÃ¶nnen, wie die LÃ¶sungen aus der Berechnung. Dazu fÃ¼hren wir den Umformschritt wie vor dem Abspeichern durch, um in den inneren Felder nicht die Wertepaare eines Zeitschritts, sondern alle Zeitschritte einer GrÃ¶ÃŸe zu bekommen. Wir legen also ein Numpy array aus der Liste von Listen an (dabei Ãœberspringen wir die erste Zeile, die ja die Ãœberschriften enthÃ¤lt) und transponieren das Array. AnschlieÃŸend legen wir ein Dictionary an und tragen die einzelnen Arrays aus dem groÃŸen Array ein. Dann haben wir ein Dictionary, das genau so einsetzbar ist, wie die Dictionaries, die aus der Werte gekommen sind."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "10673537",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rows = []\n",
+    "with open(\"simulation_2D.csv\",'r', newline='') as f:\n",
+    "    reader = csv.reader(f, quoting=csv.QUOTE_NONNUMERIC)\n",
+    "    for row in reader:\n",
+    "        rows.append(row)\n",
+    "\n",
+    "# Alle Zeilen ab der zweiten als np.array formatieren und transponieren, um aus [[x1,y1],[x2,y2]] [[x1,x2],[y1,y2]] zu machen\n",
+    "data_import = np.array(rows[1:]).T \n",
+    "\n",
+    "#Sortieren der jeweiligen Listen in das Dictionary\n",
+    "sol_imported={}\n",
+    "sol_imported[\"t\"] = data_import[0]\n",
+    "sol_imported[\"y\"]= data_import[1:] # In y wird also wie auch oben die Matrix (v,h) gespeichert."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7a2c5185",
+   "metadata": {},
+   "source": [
+    "Nun ist die LÃ¶sung importiert. Wir testen das, indem wir den oben gezeigten Plot nun noch einmal mit der importierten LÃ¶sung erstellen."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "e870d961",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 216x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#Diese importierte LÃ¶sung kann nun genau so dargestellt werden, wie die originale LÃ¶sung. (Zur Erstellung des Plots, siehe oben)\n",
+    "\n",
+    "plt.figure(figsize=(3,8)) \n",
+    "plt.plot(sol_imported[\"y\"][2], sol_imported[\"y\"][3]) \n",
+    "plt.gca().set_aspect('equal')\n",
+    "\n",
+    "\n",
+    "plt.scatter(sol_imported[\"y\"][2][::8], sol_imported[\"y\"][3][::8])\n",
+    "\n",
+    "offset_x = 290\n",
+    "offset_z = -110\n",
+    "plt.scatter(sol_imported[\"y\"][2][::8]*0+offset_x, sol_imported[\"y\"][3][::8])\n",
+    "plt.scatter(sol_imported[\"y\"][2][::8], sol_imported[\"y\"][3][::8]*0+offset_z)\n",
+    "\n",
+    "plt.xlabel(\"x\")\n",
+    "plt.ylabel(\"z\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a3461331",
+   "metadata": {},
+   "source": [
+    "Auch hier mÃ¶chte ich noch einmal zeigen, wie das ohne das CSV Paket aussehen kann (wir mÃ¼ssen uns also wieder manuell um die Formatierung kÃ¼mmern):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "3ea9d27a",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "y:  [2.47426240e-05 2.72168864e-04 2.74643126e-03 2.74890552e-02\n",
+      " 2.74915295e-01 5.24915295e-01 7.74915295e-01 1.02491529e+00\n",
+      " 1.27491529e+00 1.52491529e+00] \n",
+      "vx:  [69.99932489 69.99257455 69.92514445 69.25809643 63.24034783 58.15451792\n",
+      " 53.83605131 50.11730739 46.8746509  44.01485887]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Wir legen wieder ein Feld \"rows\" mit den Zeilen an. In dieses fÃ¼gen wir die Zahlendaten jeder Zeile als Liste ein\n",
+    "\n",
+    "rows = []\n",
+    "\n",
+    "with open(\"simulation_2D_manual.csv\", \"r\") as f:\n",
+    "    content = f.readlines()[1:] #wir Ã¼berspringen die erste Zeile und speichern den Rest in content ab\n",
+    "    \n",
+    "    #iteration Ã¼ber alle Zeilen, die nun immer als ein String eingelesen sind\n",
+    "    for line in content:\n",
+    "        line_splitted = line.split(',') #teilt den string an den \",\" in eine Liste aus den Teilstrings auf\n",
+    "        current_row = []\n",
+    "        for element in line_splitted:\n",
+    "            current_row.append(float(element))\n",
+    "        rows.append(current_row)\n",
+    "\n",
+    "#Weiteren koennen wir rows genau wie oben bei der Verwendung von csv weiterverarbeiten\n",
+    "data_import = np.array(rows[1:]).T \n",
+    "        \n",
+    "# Zuletzt legen wir das Dictionary an und konvertieren die Listen zu np.arrays\n",
+    "sol_man_imported={}\n",
+    "sol_man_imported[\"t\"] = data_import[0]\n",
+    "sol_man_imported[\"y\"] = data_import[1:]\n",
+    "\n",
+    "#zum Test ein paar Werte ausgeben\n",
+    "print(\"y: \",sol_man_imported[\"t\"][:10], \"\\nvx: \", sol_man_imported[\"y\"][0][:10])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ca033fad",
+   "metadata": {},
+   "source": [
+    "## <font color='blue'> **Schlussbemerkung**\n",
+    "    \n",
+    "Wir haben gesehen, dass wir mit relativ einfachen Mitteln die SciPy LÃ¶sungsmethode fÃ¼r DGL auf weitere LÃ¶sungsvariablen, wie z.B. mehrere Raumdimensionen erweitern kÃ¶nnen. Die eigentliche Schwierigkeit in Problemstellung 1 war das Ãœbertragen des Quadrats der Geschwindigkeit fÃ¼r den Luftwiderstand als Vektor.\n",
+    "    \n",
+    "Dann haben wir eine Methode besprochen, mit der tabellarische Daten wie die Ergebnisse von Simulationen im Zeitbereich kompakt und speicherschonend und fÃ¼r andere Programme importierbar auf der Festplatte gespeichert werden kÃ¶nnen.\n",
+    "\n",
+    "## <font color='blue'> **Ausblick**\n",
+    "\n",
+    "Nicht alle Daten lassen sich so gut als Tabelle darstellen, wie die Ergebnisse dieser Ãœbung. In der nÃ¤chsten Ãœbung werden wir (auch zur Wiederholung) eine kleine objektorientierte Datenstruktur aufbauen und Funktionen entwickeln, mit denen wir diese strukturierten Daten in geeigneten Dateien auf der Festplatte speichern kÃ¶nnen.\n",
+    "    \n",
+    "## <font color='blue'> **Aufgaben zum selbst probieren**\n",
+    "\n",
+    "* Erweitere die 2D-Fallsimulation auf 3D.\n",
+    "* Erweitere die 2D/3D Fallsimulation mit der Ã–ffnung eines Fallschirms (wie in Ãœbung 9)\n",
+    "* Schreibe ein Skript, dass die Ergebnisdaten in einem csv-artigen ASCII Format abspeichert. Die Zeit soll mit drei Nachkommastellen, alle anderen Variablen nur mit je zwei Nachkommastellen eingetragen werden. Die Trennung zwischen den Werten sollen ausschlieÃŸlich Leerzeichen (mindestens 3) sein. Schreibe ebenfalls ein Skript, das diese Daten einlieÃŸt. Du kannst dazu das csv-Paket nutzen, oder das Format von Hand definieren.\n",
+    "* (Zusatz) FÃ¼ge einen hÃ¶henabhÃ¤ngigen Wind hinzu (z.B. 0 m/s am Boden 25m/s in 1000m HÃ¶he, linear interpoliert). Beachte, dass der Luftwiderstand von der Geschwindigkeit *gegenÃ¼ber der Luft* abhÃ¤ngig ist. Der Ort ist weiterhin von der absoluten Geschwindigkeit abhÃ¤ngig. Ãœberlege dir also, wie du auf den entsprechenden Geschwindigkeitsvektor fÃ¼r die Ermittlung des Widerstands und dessen Richtung kommst. \n",
+    "\n",
+    "FÃ¼ge deiner Kopie des Notebooks beliebig viele Codezellen hinzu, um die Aufgaben zu lÃ¶sen."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.8.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
-- 
GitLab