From 05f876156e598670187ab27ae17a146a640b151d Mon Sep 17 00:00:00 2001 From: Robert Jeutter <48153869+wieerwill@users.noreply.github.com> Date: Sun, 3 Mar 2019 13:27:30 +0100 Subject: [PATCH] Python Syntax im Jupyter Format Python Syntax im Jupyter Format --- Python-Syntax.ipynb | 987 +++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 924 insertions(+), 63 deletions(-) diff --git a/Python-Syntax.ipynb b/Python-Syntax.ipynb index 6ebeb57..3aff976 100644 --- a/Python-Syntax.ipynb +++ b/Python-Syntax.ipynb @@ -149,6 +149,56 @@ "print(\"Mein Name ist\" + name + \". Wie ist dein Name?\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Strings kürzen\n", + "Strings können über **[Zahl:Zahl]** gekürzt werden. Wobei die Zahlen die zu überspringenden Zeichen angeben." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Welt\n" + ] + } + ], + "source": [ + "print(\"Hallo Welt\"[6:]) #Die ersten 0-6 Zeichen werden übersprungen" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Bestimmte Zeichen eines Strings ausgeben\n", + "Einzelne String-Zeichen können mittel **[Zahl]** ausgegeben werden, wobei Zahl die gesuchte Position ist" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "o\n" + ] + } + ], + "source": [ + "print(\"Hallo Welt\"[4]) # der 5. Buchstabe wird ausgegeben" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -159,7 +209,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -185,9 +235,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello Welt\n" + ] + } + ], "source": [ "# Dies ist ein Kommentar\n", "# print(\"Hallo Welt\") Diese Zeile wird nicht ausgeführt\n", @@ -199,15 +257,23 @@ "metadata": {}, "source": [ "# 2. Listen\n", - "Listen können mehrere Elemente enthalten\n", + "Listen können mehrere Elemente enthalten und sind veränderliche Datenstruktur.
\n", "**Listenname = [\"Element1\", Element2\", ... ]**" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Alex', 'Bob', 'Cedric', 'Erika']\n" + ] + } + ], "source": [ "students = [\"Alex\", \"Bob\", \"Cedric\", \"Erika\"]\n", "print(students)" @@ -217,19 +283,82 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Element aus Liste wählen\n", - "Elemente einer Liste sind aufsteigend von 0 an nummeriert. Per Index kann ein einzelnes Element über seine Listenposition angewählt werden: **Listenname[Position]**" + "### Element aus Liste auswählen\n", + "Elemente einer Liste sind aufsteigend von 0 an nummeriert.
\n", + "Per Index kann ein einzelnes Element über seine Listenposition angewählt werden: **Listenname[Position]**" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Alex\n" + ] + } + ], "source": [ "print(students[0])" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Über eine **negative** Positionsnummer kann die Liste vom **Ende zum Anfang** ausgelesen werden. \n", + "Die Ausgabe ist wieder in Reihenfolge der orginalen Liste" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Erika\n" + ] + } + ], + "source": [ + "print(students[-1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Liste Trennen\n", + "Eine Liste kann auch aufgeteilt (gesliced) werden. Hierfür wird **Zahl:Zahl**. Wobei die Zahlen die zu überspringenden Indexe angeben." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Cedric', 'Erika']\n", + "['Bob', 'Cedric']\n", + "['Bob', 'Cedric', 'Erika']\n" + ] + } + ], + "source": [ + "print(students[2:4])\n", + "print(students[1:-1]) #auch hier können negative Positionen benutzt werden\n", + "print(students[1:]) # mit auslassen einer Zahl wird die Liste bis zum Ende ausgeführt" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -240,9 +369,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Alex', 'Bob', 'Cedric', 'Erika', 'Franz']\n" + ] + } + ], "source": [ "students.append(\"Franz\")\n", "print(students)" @@ -252,15 +389,99 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Element aus Liste entfernen\n", - "über **.pop()** kann das letzte Element aus der Liste entfernt werden" + "ebenso mit **+** können weitere Elemente hinzugefügt werden" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Alex', 'Bob', 'Cedric', 'Erika', 'Ferdinand']\n" + ] + } + ], + "source": [ + "students = [\"Alex\", \"Bob\", \"Cedric\", \"Erika\"] + [\"Ferdinand\"]\n", + "print(students)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Elemente aus Liste entfernen\n", + "mit **del** kann ein bestimmtes Element anhand der **Position** aus einer Liste entfernt werden" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Alex', 'Bob', 'Cedric', 'Ferdinand']\n" + ] + } + ], + "source": [ + "del students[3]\n", + "print(students)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "mit **remove** kann ein bestimmtes Element anhand des **Strings** aus einer Liste entfernt werden" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Bob', 'Cedric', 'Ferdinand']\n" + ] + } + ], + "source": [ + "students.remove(\"Alex\")\n", + "print(students)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "über **.pop()** kann das **letzte** Element aus der Liste entfernt werden" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Bob', 'Cedric']\n", + "Ferdinand\n" + ] + } + ], "source": [ "x = students.pop() #aus Students wird das letzte Element entfernt\n", "print(students) #restliche Liste\n", @@ -277,13 +498,129 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], "source": [ "print(len(students))" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### List Comprehension\n", + "Einfache Umwandlung bzw Neuerstellung einer Liste. Beachte, dass die Variablen ungleich der Listennamen vergeben werden müssen!" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4]\n", + "[1, 4, 9, 16]\n" + ] + } + ], + "source": [ + "xs = [1,2,3,4]\n", + "ys = [x * x for x in xs] # für jeden Wert in xs wird das Quadrat in ys gespeichert\n", + "print(xs)\n", + "print(ys)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[4, 3, 6, 5, 9]\n" + ] + } + ], + "source": [ + "students = [\"Alex\", \"Bob\", \"Cedric\", \"Erika\", \"Ferdinand\"]\n", + "lengths = [len(student) for student in students] \n", + "#für jede Länge eines Studentennames wird das Ergebnis in \"lenghts\" gespeichert\n", + "print(lengths)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n", + "[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n" + ] + } + ], + "source": [ + "#Zu viele Zeilen!\n", + "xs = []\n", + "for x in range(0,10):\n", + " xs.append(x/10)\n", + "print(xs)\n", + "\n", + "#einfacher:\n", + "xs = [x/10 for x in range(0,10)]\n", + "print(xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Listen verschachteln\n", + "Listen können ineinander verschachtelt werden um z.B. eine Matrix zu modellieren.
\n", + "**[[Liste1],[Liste2]]**
\n", + "Beachte, dass verschachtelte Listen mit einem Kommata getrennt werden." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Element3\n", + "Element5\n" + ] + } + ], + "source": [ + "liste = [\n", + " [\"Element1\", \"Element2\", \"Element3\"],\n", + " [\"Element4\", \"Element5\", \"Element6\"]\n", + "]\n", + "print(liste[0][2])\n", + "print(liste[1][1])" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -301,7 +638,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -327,7 +664,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 25, "metadata": { "scrolled": true }, @@ -355,7 +692,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -381,7 +718,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -407,7 +744,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -443,13 +780,14 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "False\n", "False\n", "True\n", "True\n", @@ -480,9 +818,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n", + "False\n", + "False\n" + ] + } + ], "source": [ "# Für and müssen beide Variablen den gleichen Wert annehmen\n", "print(True and True)\n", @@ -493,9 +842,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "True\n", + "True\n", + "False\n" + ] + } + ], "source": [ "# Für or muss eine der Variablen True annehmen\n", "print(True or True)\n", @@ -516,7 +876,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 32, "metadata": {}, "outputs": [ { @@ -543,7 +903,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -571,7 +931,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -600,7 +960,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 35, "metadata": {}, "outputs": [ { @@ -648,7 +1008,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 36, "metadata": {}, "outputs": [ { @@ -678,7 +1038,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 37, "metadata": {}, "outputs": [ { @@ -713,7 +1073,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 38, "metadata": {}, "outputs": [ { @@ -749,7 +1109,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 39, "metadata": {}, "outputs": [ { @@ -780,7 +1140,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 40, "metadata": { "scrolled": true }, @@ -812,7 +1172,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 41, "metadata": {}, "outputs": [ { @@ -834,7 +1194,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 42, "metadata": {}, "outputs": [ { @@ -869,9 +1229,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 43, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hi\n", + "there\n" + ] + } + ], "source": [ "def print_more(): # Das Definieren der Funktion\n", " print(\"hi\")\n", @@ -891,14 +1260,14 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Hallo mein Name ist Hans\n" + "Hallo mein Name ist Hans.\n" ] } ], @@ -911,7 +1280,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 45, "metadata": {}, "outputs": [ { @@ -941,7 +1310,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 46, "metadata": {}, "outputs": [ { @@ -976,9 +1345,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 47, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hi\n" + ] + } + ], "source": [ "def return_element(name):\n", " return name\n", @@ -999,30 +1376,31 @@ "metadata": {}, "source": [ "# 7. Dateien\n", - "Python kann mehrere Dateitypen mit dem **with**-Konstruktor öffnen. Diese müssen danach nicht mit der **close()** -Methode geschlossen werden.\n", + "Einfaches öffnen und schließen von Dateien kann mit **open()** und **close()** realisiert werden.
\n", + "Mit dem **with**-Konstruktor müssen geöffnete Dateien danach nicht mit der **close()** -Methode geschlossen werden.\n", + "\n", + "**open**(\"dateiname\", \"operator\")
\n", + "       **write**.CodeMitDatei
\n", + "**close()**\n", "\n", "**with** open(\"dateiname.dateiendung\", \"operator\") **as** dateiname_in_funktion:
\n", - "       Code" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ + "       Code\n", + "\n", "Mögliche Dateien sind .txt, .csv (comma seperated values), ...\n", "\n", "### Textdateien schreiben\n", - "zum schreiben einer Datei nutzen wir den Operator \"w\" (write)" + "Zum schreiben einer neuen Datei nutzt man den Operator **w** (write)
\n", + "Soll nichts überschrieben werden oder Text angehängt werden nutzt man den Operator **a** (append)" ] }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 48, "metadata": {}, "outputs": [], "source": [ "file = open(\"test.txt\", \"w\")\n", - "file.write(\"Diese Datei wurde mit Phyton geschrieben.\")\n", + "file.write(\"Diese Datei wurde mit Phyton geschrieben. \\n\")\n", "file.close()" ] }, @@ -1031,12 +1409,12 @@ "metadata": {}, "source": [ "### Textdateien lesen und Inhalt ausgeben\n", - "zum lesen einer Datei nutzen wir den Operator \"r\" (read)" + "Zum lesen einer Datei nutzen wir den Operator \"r\" (read)" ] }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 49, "metadata": {}, "outputs": [ { @@ -1050,20 +1428,205 @@ "source": [ "file = open(\"test.txt\", \"r\")\n", "for line in file: # Alle Zeilen nacheinander auslesen\n", - " print(line.strip()) #eine Zeile ohne Zeilenumbruch ausgeben" + " print(line.strip()) #eine Zeile ohne Zeilenumbruch ausgeben\n", + "file.close()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# 99.Importieren mit %\n", + "### Zeichen aus Datei entfernen\n", + "das Entfernen bestimmter Zeichen ist mit Python einfach realisierbar. Es wurde schon im oberen Beispiel gezeigt:
\n", + "**.strip** entfernt Sonderzeichen wie z.B. \\n (Zeilenumbruch)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 8. Dictionaries\n", + "Die Verknüpfung verschiedener Strings und Listen wird mit Dictionaries erfolgen. Dictionaries werden mit **{\"Schlüssel:Zuweisung}** aufgebaut" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Berlin': 'BER', 'Helsinki': 'Hel', 'Barcelona': 'BAC'}\n", + "Hel\n", + "Hel\n", + "None\n", + "dict_items([('Berlin', 'BER'), ('Helsinki', 'Hel'), ('Barcelona', 'BAC')])\n" + ] + } + ], + "source": [ + "d = {\"Berlin\":\"BER\", \"Helsinki\":\"Hel\", \"Barcelona\":\"BAC\"} # Aufbau eines Dictionaries\n", + "print(d) # Ausgabe des gesamten Dictionaries\n", + "print(d[\"Helsinki\"]) # Ausgabe der Wertzuweisung für den Schlüssel \"Helsinki\"\n", + "print(d.get(\"Helsinki\")) # vermeidet Fehler falls Schlüssel nicht im Dictionarie enthalten\n", + "print(d.get(\"Budapest\")) # Beispiel für nicht-existenz\n", + "print(d.items()) # Ausgabe des Dictionaries als Liste mit Tupel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Dictionaries kann jedem Element/Schlüssel auch eine Definition zugewiesen werden" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Berlin : BER\n", + "Helsinki : Hel\n", + "Barcelona : BAC\n" + ] + } + ], + "source": [ + "for key, wert in d.items():\n", + " print(key + \" : \" + wert) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Listen in Dictionaries" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['BER', 'Berlin']\n" + ] + } + ], + "source": [ + "staedte = {\n", + " \"München\": [\"MUC\", \"Bayern\"],\n", + " \"Berlin\": [\"BER\", \"Berlin\"]\n", + "}\n", + "print(staedte[\"Berlin\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 9. Tupel\n", + "Ähnlich zu Listen, jedoch unveränderliche Datenstruktur." + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 2, 3)\n", + "2\n" + ] + } + ], + "source": [ + "t = (1, 2, 3) # ein Tupel wird mit runden Klammern gebildet\n", + "print(t) # abrufen des gesamten Tupel\n", + "print(t[1]) # abrufen eines bestimmten Tupel-Elements" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tupel definieren\n", + "Der Inhalt eines Tupels kann durch Variablen definiert und zugewiesen werden. Erleichtert den Zugriff und das Entpacken" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Maschinenbau\n" + ] + } + ], + "source": [ + "student = (\"Max Mustermann\", 20, \"Maschinenbau\") # Tupel bilden\n", + "name, alter, fach = student # Tupel entpacken und Definition zuweisen\n", + "print(fach) # Information aus Tupel anhand der Definition entpacken" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Eine Liste mit Tupel" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max\n", + "Alex\n" + ] + } + ], + "source": [ + "students = [\n", + " (\"Max\", 20), # Komma zwischen Tupel nicht vergessen!\n", + " (\"Alex\", 30)\n", + "]\n", + "\n", + "for name, alter in students: # Definitionen zuweisen \n", + " print(name)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 10. Importieren mit %\n", "für zusätzliche Funktionen können Module in Python importiert werden" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 56, "metadata": {}, "outputs": [ { @@ -1086,6 +1649,304 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 11. Objektorientierung\n", + "Klassen sind Baupläne für Objekte. Die erzeugten Objekte nennt man Instanzen dieser Klasse." + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Erik\n" + ] + } + ], + "source": [ + "class Student(): # Klasse Student erstellen, Klassennamen beginnen gemäß Konvention mit Großbuchstaben\n", + " pass # Leere Klasse zulassen\n", + "\n", + "erik = Student() # Instanz erzeugen\n", + "erik.firstname = \"Erik\" # zwei Variablen für das Objekt,\n", + "erik.lastname = \"Mustermann\" # auf díe über das Objekt per Punktschreibweise zugegriffen werden kann\n", + "\n", + "print(erik.firstname) " + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mueller\n" + ] + } + ], + "source": [ + "class Student(): \n", + " def __init__(self, firstname, lastname): # durch Definition der Variablen mittel einer Methode\n", + " self.firstname = firstname # können Instanzen einfach hinzugefügt werden\n", + " self.lastname = lastname\n", + "\n", + "monika = Student(\"Monika\", \"Mueller\") # Kurzschreibweise für Instanz\n", + "\n", + "print(monika.lastname)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Methoden und Definitionen können innerhalb von Objekten gebildet werden um Namensübertretungen zu verhindern bzw. \n", + "innerhalb eines Objekts alle Namenskonventionen festzuhalten.
\n", + "**self** ist ein Schlüsselwort, es fungiert gewissermassen als Platzhalter für die jeweilige Instanz" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Erik Mustermann\n" + ] + } + ], + "source": [ + "class Student():\n", + " def name(self): # ein Konstruktor, der eine Funktion für das Objekt definiert\n", + " print(self.firstname + \" \" + self.lastname)\n", + "\n", + "erik = Student() \n", + "erik.firstname = \"Erik\" \n", + "erik.lastname = \"Mustermann\"\n", + "erik.name() " + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Erik Mustermann (Semester: 1)\n", + "Erik Mustermann (Semester: 2)\n" + ] + } + ], + "source": [ + "class Student():\n", + " def __init__(self, firstname, lastname):\n", + " self.firstname = firstname\n", + " self.lastname = lastname\n", + " self.term = 1 # Hier initialisiert die neue Variable term (Eigenschaft)\n", + " \n", + " def increase_term(self): # Mit dieser Methode erhöht die Variable term um 1\n", + " self.term = self.term + 1\n", + " \n", + " def name(self): # name() gibt Name und Anzahl der Semester aus\n", + " print(self.firstname + \" \" + self.lastname + \n", + " \" (Semester: \" + str(self.term) + \")\")\n", + " \n", + "erik = Student(\"Erik\", \"Mustermann\")\n", + "erik.name()\n", + "erik.increase_term() #Semester erhöhen\n", + "erik.name()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Private Eigenschaften und Methoden\n", + "Private Eigenschaften erlauben sauberes Kapseln von Eigenschaften und Methoden. Dadurch können Variablen und Methoden vor außerhalb geschützt werden. Wichtig wenn diese Variablen / Methoden noch angeüasst werden.
\n", + "Mit **zwei Unterstrichen** vor der Variable wird diese **privat**. Methoden könne auf dieselbe Weise eingeschränkt werden." + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "class Student():\n", + " def increase_term(self):\n", + " self.__term = self.__term + 1\n", + " \n", + " def get_term(self): # um von außen noch auf die Variable term zugreifen zu können\n", + " return self.__term\n", + " \n", + " def __do_something(self):\n", + " print(\"doSomething\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Vererbung\n", + "Durch Vererbung können Daten aufgeteilt und besser modelliert werden.
\n", + "Als Parameter wird die Klasse übergeben, von der neue Eigenschaften und Methoden vererbt werden sollen (Mutterklasse)." + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "class WorkingStudent(Student):\n", + " \n", + " def __init__(self, firstname, surname, company): \n", + " # mit super() wird Python gezeigt, dass die init()-Methode der Mutterklasse angewendet werden soll\n", + " super().__init__(firstname, surname)\n", + " self.company = company\n", + " \n", + " def name(self):\n", + " return super().name() + \" (\" + self.company + \")\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Die type() und isinstance() Funktionen\n", + "Mit der **type()**-Funktion kann der Typ eines Objektes festgestellt werden.
\n", + "Die Funktion **isinstance()** erhält zwei Parameter: die **Variable** und die **Klasse** bezüglich derer auf Zugehörigkeit der Variable geprüft werden soll. **isinstance()** liefert einen Bool zurück." + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "False\n" + ] + } + ], + "source": [ + "print(type(student))\n", + "print(isinstance(student, Student))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Statische Variablen\n", + "Anstatt Instanzen können auch Variablen an Klassen gebunden werden. Diese heißen statisch, weil sie nicht an einer einzelnen Instanz hängen. Werden die Variablen geändert, werden sie für alle Objekte geändert." + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "expensive\n" + ] + } + ], + "source": [ + "class Car:\n", + " price = \"expensive\" # der Preis wird auf jedes Objekt übertragen das mit der Klasse 'Car' erstellt wurde\n", + "\n", + "c = Car\n", + "print(c.price)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Styleguide für Klassen und Variablen\n", + "In Python verwendet man dazu nach Konvention:\n", + "\n", + "- PascalCase (`IchBesteheAusMehrerenWoertern`)\n", + "- sneak_case (`ich_bestehe_aus_mehreren_woertern`)\n", + "\n", + "Anders als in anderen Programmiersprachen benutzt man nicht:\n", + "\n", + "- camelCase (`ichBesteheAusMehrerenWoertern`)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Besondere Methoden\n", + "Die str-Funktion gibt für **print(objekt)** eine Definierte Form aus.
\n", + "Die repr-Methode gibt für **Objekt** eine Definierte Form aus.
\n", + "Die len-Methode gibt für **print(len(Objekt))** die Länge aus.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PhoneBook({'Mustermann': '1234', 'Mueller': '9876'})\n", + "2\n" + ] + } + ], + "source": [ + "class PhoneBook():\n", + " def __init__(self):\n", + " self.__entries = {}\n", + " def add(self, name, phone_number):\n", + " self.__entries[name] = phone_number\n", + " def get(self, name):\n", + " if name in self.__entries:\n", + " return self.__entries[name]\n", + " else:\n", + " return None\n", + " def __str__(self):\n", + " return \"PhoneBook(\" + str(self.__entries) + \")\"\n", + " def __repr__(self):\n", + " return \"PhoneBook(\" + str(self.__entries) + \")\"\n", + " def __len__(self):\n", + " return len(self.__entries)\n", + "\n", + "book = PhoneBook()\n", + "book.add(\"Mustermann\", \"1234\")\n", + "book.add(\"Mueller\", \"9876\")\n", + "\n", + "print(book) #für str-Funktion\n", + "book #für repr-Funktion\n", + "print(len(book)) # für len-Funktion" + ] + }, { "cell_type": "code", "execution_count": null,