{ "cells": [ { "cell_type": "markdown", "id": "883f329a", "metadata": {}, "source": [ "# Vorkurs Tag 4\n", "\n", "Author: Christian Reichhardt" ] }, { "cell_type": "markdown", "id": "f7420aa0", "metadata": {}, "source": [ "## 4.1 Funktionen\n", "\n", "### Was ist das? 👽\n", "\n", "Funktionen sind Codeabschnitte, die nur dann ausgeführt werden, wenn man sie aufruft.\n", "Das ist sinnvoll, wenn man bestimmte Funktionalitäten öfter benötigt.\n", "\n", "In Python kann eine Funktion mit dem Schlüsselwort `def` definiert werden. Eine Funktion besteht aus einer *Deklaration* nach dem Schlüsselwort `def` und einem *Textkörper* bzw. *Rumpf*, der mit Tabulator unter der Deklaration eingerückt ist.\n", "\n", "**Beachte:** Nach der Konvention werden Funktionsnamen in Python klein geschrieben und durch einen Unterstrich `_` getrennt: `funktions_name`.\n", "\n", "### Ein einfaches Beispiel" ] }, { "cell_type": "code", "execution_count": 1, "id": "3a49c6e8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Ich bin eine coole Funktion.\n" ] } ], "source": [ "# Funktionsdefinition\n", "def coole_funktion():\n", " \"\"\"Eine einfache Funktion, die bei Aufruf 'Ich bin eine coole Funktion.' ausgibt.\"\"\"\n", " print('Ich bin eine coole Funktion.')\n", "\n", "# Aufruf der Funktion -> Erst hier wird die Funktion ausgefuehrt!\n", "coole_funktion()" ] }, { "cell_type": "markdown", "id": "9f7ad5f8", "metadata": {}, "source": [ "Um es euren Kommilitonen oder Arbeitskollegen möglichst leicht zu machen, sollte eine Funktion immer mithilfe von sogenannten *Docstrings* beschrieben werden. Das ist ein String, der die Funktionalität einer Funktion beschreibt und mit jeweils drei Anführungszeichen `\"\"\"` beginnt und endet. Leider sind Informatiker meistens schreibfaul.😉" ] }, { "cell_type": "markdown", "id": "c1147b4d", "metadata": {}, "source": [ "### Parameter\n", "\n", "Eine Funktion kann beliebig viele Argumente (Parameter) entgegennehmen und beliebig viele Rückgabewerte besitzen.\n", "\n", "#### Eingabeparameter\n", "\n", "Werte, die eine Funktion bei Aufruf als Eingabe entgegennimmt, nennt man Eingabeparameter. Mit diesen können Funktionen dann arbeiten bzw. Berechnungen anstellen." ] }, { "cell_type": "code", "execution_count": 2, "id": "19645164", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Ich habe gestern Abend 5 Bier getrunken.\n", "Ich habe gestern Abend 2 Gin getrunken.\n" ] } ], "source": [ "def getraenke_ausgeben(anzahl, getraenk):\n", " \"\"\"Eine Funktion mit Eingabeparametern, welche die Anzahl und den Namen des Getränks von gestern Abend ausgibt.\n", " :param anzahl: Anzahl der getrunkenen Getränke\n", " :param getraenk: Name des Getränks\n", " \"\"\"\n", " print(f'Ich habe gestern Abend {anzahl} {getraenk} getrunken.')\n", "\n", "# Aufruf Beispiel 1\n", "getraenke_ausgeben(5, \"Bier\")\n", "\n", "# Aufruf Beispiel 2\n", "getraenke_ausgeben(2, \"Gin\")" ] }, { "cell_type": "markdown", "id": "3169f858", "metadata": {}, "source": [ "#### Rückgabewerte\n", "\n", "Bei einer Funktion, die beispielsweise etwas berechnet, macht es Sinn das Ergebnis der Funktion zu erhalten, um nach dem Aufruf darauf zugreifen zu können. Hierfür sind Rückgabewerte gedacht, d.h. bei Funktionsaufruf gibt die Funktion einen oder mehrere Werte zurück. Innerhalb des Funktionsrumpfes stehen diese Werte hinter dem `return` Schlüsselwort." ] }, { "cell_type": "code", "execution_count": 3, "id": "a8b77019", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "6.5\n", "12.5\n", "12.5\n" ] } ], "source": [ "# Funktionsdefinition\n", "def summe(a, b):\n", " \"\"\"Bilde die Summe aus den Werten a und b und gib diese zurück.\"\"\"\n", " return a + b\n", "\n", "# Aufruf Beispiel 1\n", "ergebnis = summe(1., 5.5)\n", "print(ergebnis)\n", "\n", "# Verschachtelter Aufruf\n", "print(summe(summe(1., 5.5), 6.))\n", "\n", "# entspricht:\n", "print(1. + 5.5 + 6.)" ] }, { "cell_type": "markdown", "id": "5b544486", "metadata": {}, "source": [ "In diesem Fall ergibt sich noch kein großer Vorteil, da der Funktionsaufruf länger ist als eine einfache Additon. Bei komplizierteren Berechnungen spart man sich jedoch eine Menge Aufwand. " ] }, { "cell_type": "markdown", "id": "4edafd82", "metadata": {}, "source": [ "#### Unbestimmte Anzahl Parameter\n", "\n", "Durch den Stern `*` vor einem Eingabeparameter können in einer Funktion eine unbestimmte Anzahl Parameter übergeben werden. Per Konvention wird für diesen Parameter der Name `args` verwendet. In dieser Variable sind dann alle Eingabeparameter die übergeben werden gespeichert.\n", "\n", "`args`ist also ein Array! Um alle einzelnen Werte auszulesen, können wir folglich mithilfe einer `for`-Schleife über das Array iterieren. \n", "\n", "Im Folgenden möchten wir die Summe von beliebig vielen Werten bilden." ] }, { "cell_type": "code", "execution_count": 4, "id": "c9103135", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Einzelne Betraege: (1.0, 2.0, 5.5, 3.3)\n", "Gesamte Rechnung: 11.8\n", "Jede Person zahlt 2.95 Euro.\n" ] } ], "source": [ "# Funktionsdefinition\n", "def summe_getraenke(*args):\n", " \"\"\"Eine Funktion, die beliebig viele Betraege entgegen nimmt und diese summiert.\n", " :param args: beliebige Betraege\n", " :return : Summe der Betraege\n", " \"\"\"\n", " print(f'Einzelne Betraege: {args}')\n", " summe = 0\n", " for arg in args:\n", " summe = summe + arg\n", " return summe\n", "\n", "# Berechne Summe aus floats\n", "x = summe_getraenke(1., 2., 5.5, 3.3)\n", "print(f'Gesamte Rechnung: {x}')\n", "\n", "# Teile Rechnung durch 4 Personen\n", "print(f'Jede Person zahlt {x/4} Euro.')" ] }, { "cell_type": "markdown", "id": "7a6fb3c9", "metadata": {}, "source": [ "**Problem:** Was passiert jedoch bei folgender Eingabe? Probere es aus: " ] }, { "cell_type": "code", "execution_count": 5, "id": "fedc2cfa", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Einzelne Betraege: (1, 'Bier')\n" ] }, { "ename": "TypeError", "evalue": "unsupported operand type(s) for +: 'int' and 'str'", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "Input \u001b[1;32mIn [5]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43msumme_getraenke\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mBier\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n", "Input \u001b[1;32mIn [4]\u001b[0m, in \u001b[0;36msumme_getraenke\u001b[1;34m(*args)\u001b[0m\n\u001b[0;32m 8\u001b[0m summe \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n\u001b[0;32m 9\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m arg \u001b[38;5;129;01min\u001b[39;00m args:\n\u001b[1;32m---> 10\u001b[0m summe \u001b[38;5;241m=\u001b[39m \u001b[43msumme\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43marg\u001b[49m\n\u001b[0;32m 11\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m summe\n", "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'" ] } ], "source": [ "summe_getraenke(1, 'Bier')" ] }, { "cell_type": "markdown", "id": "5f81841e", "metadata": {}, "source": [ "**Beachte:** Python ist eine dynamische Sprache, d.h. Datentypen werden Parametern dynamisch zur Laufzeit zugewiesen. Achte daher immer darauf, dass du Funktionen mit den richtigen Datentypen aufrufst, um unvorhergesehenes Verhalten zu verhindern." ] }, { "cell_type": "markdown", "id": "364cffd6", "metadata": {}, "source": [ "## 4.2 Klassen\n", "\n", "Die Sprache Python ist objektorientiert, daher ist fast alles in Python ist ein Objekt mit Eigenschaten (*Attributen*) und *Methoden*. Die Grundlage für ein solches Objekt nennt sich *Klasse*.\n", "\n", "Eine Klasse ist sozusagen eine Vorlage eines Objektes. Sie wird mithilfe des Schlüsselworts `class` definiert.\n", "\n", "Nehmen wir einmal ein, ein Student sei immer faul. Dann würde eine Vorlage für einen Studenten in Python folgendermaßen aussehen:" ] }, { "cell_type": "code", "execution_count": null, "id": "9cf7587c", "metadata": {}, "outputs": [], "source": [ "class Student:\n", " \"\"\"Eine Klasse Student.\"\"\"\n", " motivation='faul'\n", "\n", "# lege einen Studenten namens Alex (das Objekt) an und gib seine Motivation aus\n", "alex = Student()\n", "print(alex.motivation)" ] }, { "cell_type": "markdown", "id": "d611b94d", "metadata": {}, "source": [ "Nach Konvention werden alle Klassen in Python groß geschrieben und Klassennamen aus mehreren Wörtern werden in der sogenannten *Kamelhöckerschreibweise* geschrieben: `KlassenName`. Auf einzelne Attribute (hier `motivation`) kann über den Punktoperator `.` zugegriffen werden.\n" ] }, { "cell_type": "markdown", "id": "09e72793", "metadata": {}, "source": [ "### Die *\\_\\_init\\_\\_()*-Funktion\n", "Da nicht alle Studenten faul sind, müssen wir beim Anlegen eines neuen Studenten die Möglichkeit haben, ihm eine spezifische Motivation zuzuweisen, also seine Attribute beim Anlegen der Klasse angeben. Dies machen wir mithilfe der `__init__()`- Funktion.\n", "\n", "Wir geben dem Student zusätzlich einen Vor- und Nachname und geben seine Motivation auf einer Skala von 1-10 an: " ] }, { "cell_type": "code", "execution_count": null, "id": "46c5d1c9", "metadata": {}, "outputs": [], "source": [ "class Student:\n", " \"\"\"Eine Klasse, die einen Student mit Vorname, Nachname und Motivation beschreibt\"\"\"\n", " \n", " def __init__(self, vorname, nachname, motivation):\n", " \"\"\"Erstelle eine Instanz von Student.\n", " :param vorname: Vorname des Studenten\n", " :param nachname: Nachname des Studenten\n", " :param motivation: Motivation des Studenten von 1-10\n", " \"\"\"\n", " self.vorname = vorname\n", " self.nachname = nachname\n", " self.motivation = motivation\n", "\n", "# lege die hochmotivierte Studentin Anna Otto an -> __init__()-Funktion wird aufgerufen!\n", "anna = Student('Anna', 'Otto', 10)\n", "\n", "# gebe Klaras Motivation aus\n", "print(anna.motivation)" ] }, { "cell_type": "markdown", "id": "b7453208", "metadata": {}, "source": [ "Über das Schlüsselwort `self` können wir innerhalb einer Klasse auf unser eigenes Objekt zugreifen, z.B. unseren Vornamen.\n", "\n", "### Methoden\n", "\n", "Methoden sind Funktionen, die einer bestimmten Klasse zugeordnet sind.\n", "\n", "Wollen wir, dass sich ein Student vorstellen kann, dann fügen wir ihm eine Methode `vorstellen` hinzu." ] }, { "cell_type": "code", "execution_count": null, "id": "861e6b41", "metadata": {}, "outputs": [], "source": [ "class Student:\n", " \"\"\"Eine Klasse, die einen Student mit Vorname, Nachname und Motivation beschreibt\"\"\"\n", " \n", " def __init__(self, vorname, nachname, motivation):\n", " \"\"\"Erstelle eine Instanz von Student.\n", " :param vorname: Vorname des Studenten\n", " :param nachname: Nachname des Studenten\n", " :param motivation: Motivation des Studenten von 1-10\n", " \"\"\"\n", " self.vorname = vorname\n", " self.nachname = nachname\n", " self.motivation = motivation\n", " \n", " def vorstellen(self):\n", " \"\"\"Der Student stellt sich vor.\"\"\"\n", " print(f'Hi, mein Name ist {self.vorname} {self.nachname}.')\n", " \n", "guenther = Student('Klara', 'Fall', 3)\n", "guenther.vorstellen()" ] }, { "cell_type": "markdown", "id": "153535e3", "metadata": {}, "source": [ "Mit Methoden können wir also auf Objekten Funktionen ausführen.😎" ] }, { "cell_type": "markdown", "id": "fee0cfd9", "metadata": {}, "source": [ "## 4.3 Bibliotheken und Ausblick\n", "\n", "Python besitzt viele sehr mächtige Bibliotheken, weshalb es vor allem in den Bereichen Datenverarbeitung und Maschinelles Lernen sehr beliebt ist. Einige möchten wir euch hier ganz kurz vorstellen. Die Bibliotheken sind so vielfältig, dass wir hier nur an der Oberfläche kratzen. Ihr solltet aber mal von ihnen gehört haben, das sie euch später viel Arbeit abnehmen können.\n", "\n", "Eine Bibliothek kann in Python mithilfe eines `import`-Statements eingebunden werden. Danach könnt ihr alle Klassen und Funktionen dieser Bibliothek verwenden. Eine Bibliothek ist also auch nur ein anderes (Python) Projekt von anderen Programmierern. \n", " \n", "### NumPy\n", " \n", "Im Bereich Matritzen- und Vektorberechnungen (siehe Arrays) ist die Bibliothek *NumPy* in Python unverichtbar. Numpy steht dabei für *Numerical Python*\n", "\n", "Durch die vielen Funktionen die auf NumPy Objekten ausgeführt werden können, spart ihr euch nicht nur eine Menge Implementierungszeit, diese werden automatisch parallell auf mehreren CPU-Kernen extrem schnell ausgeführt.\n", "\n", "Um Numpy einzubinden benutzt ihr die Zeile `import numpy as np`. Dabei ist `np` das Synonym, über welches ihr auf die Bibliothek zugreifen könnt:" ] }, { "cell_type": "code", "execution_count": null, "id": "855e9515", "metadata": {}, "outputs": [], "source": [ "import numpy as np" ] }, { "cell_type": "markdown", "id": "61ad969d", "metadata": {}, "source": [ "#### Array anlegen\n", "\n", "Ein Array in NumPy nennt sich *ndarray* und ist aus Performance-Gründen praktischerweise in einem kontinuierlichem Speicherbereich abgelegt. Ihr könnt ein Array mithilfe der Funktion `np.array` anlegen." ] }, { "cell_type": "code", "execution_count": null, "id": "c5584e0e", "metadata": {}, "outputs": [], "source": [ "# 1D-Array anlegen\n", "arr = np.array([1, 2, 3, 4])\n", "print(arr)\n", "\n", "# 2D-Array anlegen\n", "arr = np.array([[1, 2], [3, 4]])\n", "print(arr)\n", "\n", "# Array mit 0en anlegen\n", "null_array = np.zeros(5)\n", "print(null_array)\n", "\n", "# Array mit 1en anlegen\n", "ones_array = np.ones(4)\n", "print(ones_array)" ] }, { "cell_type": "markdown", "id": "bcbc6b04", "metadata": {}, "source": [ "Mit **np.linspace** könnt ihr ein Array linear mit einem bestimmten Intervall füllen. Dabei wird der Startpunkt, Endpunkt und die Anzahl an Zahlen gegeben." ] }, { "cell_type": "code", "execution_count": null, "id": "99f66766", "metadata": {}, "outputs": [], "source": [ "arr = np.linspace(0, 5, 5)\n", "print(arr)\n", "\n", "arr = np.linspace(1, 10, 10)\n", "print(arr)" ] }, { "cell_type": "markdown", "id": "9178bc68", "metadata": {}, "source": [ "#### Einfache Funktionen\n", "\n", "Mit der Funktion **np.sort** könnt ihr ein Array einfach aufsteigend sortieren:" ] }, { "cell_type": "code", "execution_count": null, "id": "1d991653", "metadata": {}, "outputs": [], "source": [ "arr = np.array([7, 6, 1, 4, 5, 2, 3])\n", "print(np.sort(arr))" ] }, { "cell_type": "markdown", "id": "6fd05659", "metadata": {}, "source": [ "2 Arrays können miteinander über **np.concatenate** konkateniert werden" ] }, { "cell_type": "code", "execution_count": null, "id": "e1abf510", "metadata": {}, "outputs": [], "source": [ "x = np.array([1, 2, 3])\n", "y = np.array([4, 5, 6])\n", "print(np.concatenate((x, y)))" ] }, { "cell_type": "markdown", "id": "27142a7a", "metadata": {}, "source": [ "NumPy kann viel mehr als wir hier nur ansatzweise besprechen können. Die Dokumentation von NumPy ist extrem gut und egal was du mit Arrays machen willst, du findest es mit Sicherheit hier:\n", "\n", "https://numpy.org/doc/stable/reference/index.html#reference" ] }, { "cell_type": "markdown", "id": "7fd112b9", "metadata": {}, "source": [ "### Pandas\n", "\n", "Das was NumPy für Arrays ist, ist Pandas für Datensätze in Python. Pandas steht dabei für *Panel Data* oder *Python Data Analysis* und spielt dabei durch seine Funktionalitäten im Bereich Datenauswertung besonders im Bereich Data Science eine große Rolle.\n", "\n", "Pandas wird in Python ähnlich wie NumPy eingebunden." ] }, { "cell_type": "code", "execution_count": null, "id": "dfb50c01", "metadata": {}, "outputs": [], "source": [ "import pandas as pd" ] }, { "cell_type": "markdown", "id": "8add1bc6", "metadata": {}, "source": [ "#### DataFrames\n", "\n", "Der wichtigste Bestandteil in Pandas sind die sog. *DataFrames*, dies sind zweidimensionale Datenstrukturen, ähnlich eines Arrays." ] }, { "cell_type": "code", "execution_count": null, "id": "79b51097", "metadata": {}, "outputs": [], "source": [ "# Datensatz als dictionary, z.B. Anzahl Bier, die einzelne Fachschaftsangehörige pro Tag getrunken haben\n", "data = {\n", " \"Alex\": [1, 0, 3, 9, 0],\n", " \"Nicole\": [1, 0, 0, 2, 1]\n", "}\n", "\n", "# Dataframe erstellen und Datensatz einladen\n", "df = pd.DataFrame(data)\n", "\n", "# Dataframe ausgeben\n", "print(df)" ] }, { "cell_type": "markdown", "id": "ce06b8cb", "metadata": {}, "source": [ "Wir erhalten unseren Datensatz also in einer Art Tabellenform und können somit auf einzelne Zeilen und Spalten zugreifen:" ] }, { "cell_type": "code", "execution_count": null, "id": "2a825a76", "metadata": {}, "outputs": [], "source": [ "# Zeilenzugriff, wieviel hat wer an Tag Nummer 2 getrunken?\n", "print(df.loc[2])\n", "\n", "# multipler Zeilenzugriff, wieviel hat wer an Tag Nummer 2 und 3 getrunken?\n", "print(df.loc[[2, 3]])" ] }, { "cell_type": "markdown", "id": "a56f5155", "metadata": {}, "source": [ "Um möglichst einfach auf eine Zeilen zugreifen zu können, können wir auch *Indices* vergeben, also die einzelnen Zeilen benennen. In unserem Beispiel wären das die einzelnen Tage:" ] }, { "cell_type": "code", "execution_count": null, "id": "d3cad2b4", "metadata": {}, "outputs": [], "source": [ "df = pd.DataFrame(data, index=['05.09.22', '06.09.22','07.09.22','08.09.22', '09.09.22'])\n", "\n", "print(df)\n", "\n", "# Zugriff auf Zeile, wie viel haben alle am 05.09.22 getrunken\n", "print(df.loc['05.09.22'], '\\n')\n", "\n", "# Zugriff auf Zeile und Spalte, wie viel hat Nicole am 06.09.22 getrunken\n", "print(df.loc['06.09.22', 'Nicole'], '\\n')\n", "\n", "# Spalte Alex?\n", "print(df['Alex'], '\\n')\n", "\n", "# Zeile, in der Alex mehr als 3 Bier getrunken hat\n", "print(df[df['Alex']>3], '\\n')" ] }, { "cell_type": "markdown", "id": "69c1b0e8", "metadata": {}, "source": [ "Ein DataFrame besitzt eine Menge praktischer Funktionen. Hier paar einfache Beispiele: " ] }, { "cell_type": "code", "execution_count": null, "id": "7dbc12b0", "metadata": {}, "outputs": [], "source": [ "# Beschreibe das DataFrame mit einigen Eckdaten (sehr praktisch beim Arbeiten mit neuen DataFrames)\n", "print('\\nDescibe:')\n", "print(df.describe())" ] }, { "cell_type": "code", "execution_count": null, "id": "94e0f50c", "metadata": { "scrolled": true }, "outputs": [], "source": [ "# Summe der Zeilen, wieviel Bier wurde jeden Tag getrunken?\n", "print('\\nSumme Zeilen:')\n", "print(df.sum(axis=1))\n", "\n", "# Summe der Spalten, wieviel haben alle insgesamt getrunken?\n", "print('\\nSumme Spalten:')\n", "print(df.sum(axis=0))\n", "\n", "# Mittelwert der Spalten, wieviel hat wer im Durchschnitt pro Tag getrunken?\n", "print('\\nMittelwert:')\n", "print(df.mean())" ] }, { "cell_type": "code", "execution_count": null, "id": "b074aab3", "metadata": {}, "outputs": [], "source": [ "# Stelle den Datensatz als Plot dar\n", "df.plot()" ] }, { "cell_type": "markdown", "id": "3e04f175", "metadata": {}, "source": [ "Um Datensätze abzuspeichern, nutzt man oft sogenannte `.csv`-Dateien. Dies ist eine der einfachsten Formen einer Tabellendatei und kann auch beispielsweise von LibreOffice-Calc, Excel oder Pages eingelesen werden. Im Folgenden findet ihr Beispiele zum schreiben und einlesen von .csv Dateien." ] }, { "cell_type": "code", "execution_count": null, "id": "5f0a400a", "metadata": {}, "outputs": [], "source": [ "print(f'Aktuelles DataFrame:\\n {df}\\n')\n", "\n", "# Schreibe das Dataframe df in die Datei `trinkverhalten.csv` \n", "df.to_csv('trinkverhalten.csv')\n", "\n", "# Lese die Datei `trinkverhalten.csv` und lade sie in ein neues DataFrame df2 (mit automatischer Zeilenbenennung)\n", "df2 = pd.read_csv('trinkverhalten.csv')\n", "print(f'Eingelesenes DataFrame mit automatischer Zeilennummerierung:\\n{df2}\\n')\n", "\n", "# Um die Indices als erste Spalte zu verwenden:\n", "df2 = pd.read_csv('trinkverhalten.csv', index_col=0)\n", "print(f'Eingelesenes DataFrame mit Spalte 1 als Zeilendefinition:\\n{df2}\\n')" ] }, { "cell_type": "markdown", "id": "42cab9c8", "metadata": {}, "source": [ "Auch hier lohnt sich ein Blick in die Dokumentation: https://pandas.pydata.org/docs/" ] }, { "cell_type": "markdown", "id": "eab7d7b3", "metadata": {}, "source": [ "### Matplotlib" ] }, { "cell_type": "markdown", "id": "f7ade094", "metadata": {}, "source": [ "Matplotlib ist eine Bibliothek in Python zum Zeichnen einfacher mathematischer Graphen.\n", "\n", "Ein Modul, welches wir hier betrachten möchten nennt sich `pyplot`. Es lässt sich folgendermaßen in Python einbinden:" ] }, { "cell_type": "code", "execution_count": null, "id": "130682ad", "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "id": "15e1273c", "metadata": {}, "source": [ "Damit können wir uns endlich ein Array von vorhin einmal graphisch visualisieren:" ] }, { "cell_type": "code", "execution_count": null, "id": "c7951bff", "metadata": {}, "outputs": [], "source": [ "y_koordinaten = np.array([1, 0, 3, 9, 0])\n", "\n", "# plot berechnen\n", "plt.plot(y_koordinaten)\n", "# plot zeigen\n", "plt.show()\n", "\n", "# Zeichenstil ändern:\n", "plt.plot(y_koordinaten, 'o')\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "657a3593", "metadata": {}, "source": [ "Natürlich können wir auch x- und y-Koordinaten angeben:" ] }, { "cell_type": "code", "execution_count": null, "id": "3bde97e3", "metadata": {}, "outputs": [], "source": [ "x_koordinaten = np.array([2, 3, 8, 9, 11])\n", "y_koordinaten = np.array([1, 0, 3, 9, 0])\n", "\n", "plt.plot(x_koordinaten, y_koordinaten)\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "3af0e05b", "metadata": {}, "source": [ "Auch Achsenbeschriftungen und Titel sind möglich:" ] }, { "cell_type": "code", "execution_count": null, "id": "3e48d7f3", "metadata": {}, "outputs": [], "source": [ "x_koordinaten = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9,10])\n", "y_koordinaten = np.array([1, 0, 3, 9, 0, 0, 0, 2, 2, 1])\n", "plt.plot(x_koordinaten, y_koordinaten)\n", "plt.title('Alex Trinkverhalten')\n", "plt.xlabel(\"Tag\")\n", "plt.ylabel(\"Anzahl Bier\")\n", "plt.grid()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "79ae260c", "metadata": {}, "source": [ "Die Dokumentation von Matplotlib findet ihr hier: https://matplotlib.org/stable/index.html" ] } ], "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.9.5" } }, "nbformat": 4, "nbformat_minor": 5 }