From 77cea971a0e6fab6481bca389c4a24eb94a52f7e Mon Sep 17 00:00:00 2001 From: Robert Jeutter <48153869+wieerwill@users.noreply.github.com> Date: Sat, 2 Mar 2019 17:13:05 +0100 Subject: [PATCH] Python Syntax im Jupyter Format Python Syntax im Jupyter Format --- Python-Syntax.ipynb | 698 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 689 insertions(+), 9 deletions(-) diff --git a/Python-Syntax.ipynb b/Python-Syntax.ipynb index e2d5e6c..6ebeb57 100644 --- a/Python-Syntax.ipynb +++ b/Python-Syntax.ipynb @@ -11,7 +11,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 1.1 Zahlen" + "### Zahlen" ] }, { @@ -68,7 +68,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 1.2 Variablen" + "### Variablen" ] }, { @@ -98,7 +98,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 1.3 Strings (Zeichenketten)\n", + "### Strings (Zeichenketten)\n", "Zeichen die zwischen Anführungszeichen stehen" ] }, @@ -153,7 +153,33 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 1.4 Kommentare\n", + "### Boolean\n", + "Für Wahr oder Falsch werden die Booleans **True** und **False** ausgegeben" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n" + ] + } + ], + "source": [ + "b = False\n", + "print(b)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Kommentare\n", "Kommentare im Code erleichtern die Lesbarkeit und werden nicht ausgeführt. Dafür nutzt man **#**" ] }, @@ -191,7 +217,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 2.1 Element aus Liste wählen\n", + "### 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]**" ] }, @@ -208,7 +234,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 2.2 Element einer Liste anhängen\n", + "### Element einer Liste anhängen\n", "über **append()** kann ein Element an das Ende einer Liste hinzugefügt werden" ] }, @@ -226,7 +252,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 2.3 Element aus Liste entfernen\n", + "### Element aus Liste entfernen\n", "über **.pop()** kann das letzte Element aus der Liste entfernt werden" ] }, @@ -245,7 +271,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 2.4 Listenlänge abfragen\n", + "### Listenlänge abfragen\n", "mit dem **len()**-Befehl kann die Länge einer Liste abgefragt werden" ] }, @@ -403,7 +429,661 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Kontrollstrukturen" + "# 4. Operatoren\n", + "### Vergleichoperatoren\n", + "Verschiedene Operatoren zum Vergleichen von Variablen/Zahlen\n", + " **a == b** Werte sind gleich\n", + " **a != b** Werte sind ungleich\n", + " **a < b** Wert b ist größer als Wert a\n", + " **a > b** Wert a ist größer als Wert b\n", + " **a <= b** Wert b ist größer-gleich Wert a\n", + " **a >= b** Wert a ist größer-gleich Wert a\n", + "Die Ausgabe über **print()** gibt die Booleans **True**(Wahr) oder **False**(Falsch) aus" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n", + "True\n", + "True\n", + "False\n", + "True\n", + "False\n" + ] + } + ], + "source": [ + "a = 5\n", + "b = 6\n", + "print(a == b)\n", + "print( \"Hallo\" == \"World\") # auch Strings können verglichen werden\n", + "print(a != b)\n", + "print(a < b) \n", + "print(a > b)\n", + "print(a <= b)\n", + "print(a >= b)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gatter" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Für and müssen beide Variablen den gleichen Wert annehmen\n", + "print(True and True)\n", + "print(True and False)\n", + "print(False and True)\n", + "print(False and False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Für or muss eine der Variablen True annehmen\n", + "print(True or True)\n", + "print(True or False)\n", + "print(False or True)\n", + "print(False or False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Der in-Operator\n", + "mit **in**-Operatoren kann man überprüfen, ob ein Element in einem anderen Element enthalten ist\n", + "\n", + "der **in**-Operator mit Listen:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n", + "True\n" + ] + } + ], + "source": [ + "students = [\"Alex\", \"Bob\", \"Cedric\", \"Erika\"]\n", + "print(\"Monika\" in students) # Monika ist nicht in der Liste\n", + "print(\"Bob\" in students) # Bob ist in der Liste" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "der **in**-Operator mit Strings" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "satz =\"Ja dieser Text ist ein String!\"\n", + "print(\"Ja\" in satz) # \"Ja\" ist in dem String enthalten " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Der not-Operator\n", + "Der **not**-Operator negiert das Ergebnis bzw. die Abfrage.\n", + "\n", + "Beachte, dass der **not**-Operator vor und nach der Variable kommen kann" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n", + "True\n" + ] + } + ], + "source": [ + "print( not 5 == 5) # Das Erbgenis von \"5 == 5\" ist wahr, \"not\" negiert das Ergebnis\n", + "\n", + "# Es können auch Listen abgefragt werden:\n", + "names = [\"Andreas\", \"Bertold\"]\n", + "print(\"Alex\" not in names)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Mehr Operatoren" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "6\n", + "5\n" + ] + } + ], + "source": [ + "i = 5\n", + "print(i)\n", + "i += 1 # Mit += kann die Variable mit den nachstehenden Wert addiert und in i gespeichert werden\n", + "print(i)\n", + "i -= 1 # Mit -= kann die Variable mit den nachstehenden Wert subtrahiert und in i gespeichert werden\n", + "print(i)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 5. Schleifen" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### if-else-Struktur\n", + "Ausführen bestimmter Abschnitte nur bei bestimmter Bedingung in **if-else-Struktur**.\n", + "**if** fordert eine Bedingung, wird diese Bedingung erfüllt wird der eingrückte nachstehende Code ausgeführt.\n", + "**else** wird ausgeführt, wenn die Bedingung nicht erfüllt wird\n", + "\n", + "Jeder Codeblock wird nur einmal ausgeführt. Beachte die Einrückung für den Codeabschnitt!\n", + "\n", + "if Bedingung:
\n", + "      Auszuführender_Code
\n", + "else:
\n", + "      Sonst-Auszuführender_Code" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x ist kleiner als 10\n", + "Ich bin nicht mehr Eingerückt\n" + ] + } + ], + "source": [ + "x = 5\n", + "if x < 10:\n", + " print(\"x ist kleiner als 10\")\n", + "else:\n", + " print(\"x ist größer als 9\")\n", + "print(\"Ich bin nicht mehr Eingerückt\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Müssen mehr als zwei **if-else** Fälle abgefragt werden, nutzt man **elif nächste_Bedinung:** als Kurzfassung." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x ist 5\n" + ] + } + ], + "source": [ + "x = 5\n", + "if x == 8:\n", + " print(\"x ist 8\")\n", + "elif x==7:\n", + " print(\"x ist 7\")\n", + "elif x==6:\n", + " print(\"x ist 6\")\n", + "elif x==5:\n", + " print(\"x ist 5\")\n", + "else:\n", + " print(\"x ist nicht zwischen 4 und 9\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### for-Schleife\n", + "Die **for**-Schleife durchläuft eine anzugebende Sequenz" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "5\n", + "Max\n", + "Mustermann\n", + "Michael\n" + ] + } + ], + "source": [ + "# Das Funktioniert sowohl mit Zahlen als auch Strings\n", + "liste = [1, 2, 5]\n", + "for i in liste:\n", + " print(i)\n", + " \n", + "liste = [\"Max\", \"Mustermann\", \"Michael\"]\n", + "for i in liste:\n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Das **range**-Objekt wird dazu genutzt, die Sequenzlänge vorzugeben. D.h. wie oft die Schleife durchlaufen werden soll." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n" + ] + } + ], + "source": [ + "for i in range(0, 5): # von 0 bis 4 werden alle Zahlen ausgegeben\n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### while-Schleife\n", + "**while**-Schleifen führen einen Code-Block mehrmals hintereinander aus, bis eine Abbruchbedingung erfüllt ist.\n", + "Innerhalb einer while-Schleife muss ein Zustand verändert werden, damit das Programm die Schleife auch wieder verlassen kann!" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n" + ] + } + ], + "source": [ + "zähler = 0\n", + "while zähler < 3:\n", + " print(zähler)\n", + " zähler += 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Continue & Break\n", + "Während eines Schleifendurchlaufs kann der man vorzeitig abbrechen und mit dem nächsten Schleifendurchlauf fortfahren (**continue**) oder die gesamte Schleife abbrechen (**break**)." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "3\n" + ] + } + ], + "source": [ + "for i in range(0, 4):\n", + " if i == 2:\n", + " continue # anstatt print(2) auszuführen wird 2 übersprungen und mit dem nächsten Durchlauf fortgesetzt\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n" + ] + } + ], + "source": [ + "for i in range(0, 4):\n", + " if i == 2:\n", + " break # an dieser Stelle wird die Schleife abgebrochen und nicht weiter ausgeführt \n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 6. Funktionen\n", + "Funktionen sind t´zusammengefasste Codeblöcke. Mittels Funktionen vermeidet man mehrmals verwendete Codeblöcke. Eine Funktion kann merhmals im Programm aufgerufen werden, nachdem sie definiert wurde.
\n", + "Beachte, der Funktion oder ihren Variablen keine Dopplungen aus deinem Code zu geben!\n", + "\n", + "### Funktionen definieren und Aufrufen\n", + "\n", + "def Funktionname():
\n", + "      Code" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def print_more(): # Das Definieren der Funktion\n", + " print(\"hi\")\n", + " print(\"there\")\n", + " \n", + "print_more() # Das Aufrufen der Funktion mit ihrem Funktionsnamen()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Funktionen können auch mit einem oder mehreren Argumenten arbeiten\n", + "def Funktionname(Argument):
\n", + "      Code" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hallo mein Name ist Hans\n" + ] + } + ], + "source": [ + "def print_name(name): # hier wird in Klammern ein Argument übergeben, ein Argument kann frei definiert werden\n", + " print(\"Hallo mein Name ist \" + name + \".\") #das Argument wird mit Argument-Namen übernommen und kann verwendet werden\n", + "\n", + "print_name(\"Hans\")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hallo!\n", + "Hallo!\n", + "Hallo!\n" + ] + } + ], + "source": [ + "def print_more(name, count):\n", + " for i in range(0, count):\n", + " print(name)\n", + " \n", + "print_more(\"Hallo!\", 3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ineinander verschachtelte Funktionen sind auch möglich" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hallo mein Name ist Hans.\n", + "Ich bin 23 Jahre alt.\n" + ] + } + ], + "source": [ + "def print_name(name):\n", + " print(\"Hallo mein Name ist \" + name + \".\")\n", + "def print_alter(alter):\n", + " print(\"Ich bin \" + str(alter) + \" Jahre alt.\")\n", + "\n", + "def NameUndAlter(name, alter):\n", + " print_name(name)\n", + " print_alter(alter)\n", + "\n", + "NameUndAlter(\"Hans\", 23)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Werte zurückgeben mit 'return'\n", + "Mit dem Befehl **return** können Werte aus einer Funktion zurückgegeben werden. Funktionen mit **return** können wie Variablen behandelt werden." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def return_element(name):\n", + " return name\n", + "\n", + "print(return_element(\"Hi\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Mehr Funktionen\n", + "Neben selbst erstellten Funktionen bietet Python selbst vordefinierte Funktionen, diese findet man [hier](https://docs.python.org/3/library/functions.html)." + ] + }, + { + "cell_type": "markdown", + "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", + "\n", + "**with** open(\"dateiname.dateiendung\", \"operator\") **as** dateiname_in_funktion:
\n", + "       Code" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Mögliche Dateien sind .txt, .csv (comma seperated values), ...\n", + "\n", + "### Textdateien schreiben\n", + "zum schreiben einer Datei nutzen wir den Operator \"w\" (write)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "file = open(\"test.txt\", \"w\")\n", + "file.write(\"Diese Datei wurde mit Phyton geschrieben.\")\n", + "file.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Textdateien lesen und Inhalt ausgeben\n", + "zum lesen einer Datei nutzen wir den Operator \"r\" (read)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Diese Datei wurde mit Phyton geschrieben.\n" + ] + } + ], + "source": [ + "file = open(\"test.txt\", \"r\")\n", + "for line in file: # Alle Zeilen nacheinander auslesen\n", + " print(line.strip()) #eine Zeile ohne Zeilenumbruch ausgeben" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 99.Importieren mit %\n", + "für zusätzliche Funktionen können Module in Python importiert werden" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline \n", + "import matplotlib.pyplot as plt # hier wird das Matplolib-Modul importiert und mit der Variable plt verknüpft\n", + "plt.scatter([1, 2], [4, 3]) # plt. kann dann für das Modul benutzt werden\n", + "plt.show()" ] }, {