From 5bdb0d5495e60d43364a7b49c0f77e1b74208ff0 Mon Sep 17 00:00:00 2001
From: Michel Schwab <michel.schwab@hu-berlin.de>
Date: Wed, 14 Nov 2018 17:49:01 +0100
Subject: [PATCH] FAQ updated
---
notebooks/FAQ.ipynb | 673 ++++++++++++++++++++++++++++
notebooks/anmerkungenUndTipps.ipynb | 243 ----------
2 files changed, 673 insertions(+), 243 deletions(-)
create mode 100644 notebooks/FAQ.ipynb
delete mode 100644 notebooks/anmerkungenUndTipps.ipynb
diff --git a/notebooks/FAQ.ipynb b/notebooks/FAQ.ipynb
new file mode 100644
index 0000000..678d13f
--- /dev/null
+++ b/notebooks/FAQ.ipynb
@@ -0,0 +1,673 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Zu den Jupyter-Notebooks\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- Im Exkurs **\"was mir an python gefällt\"** muss der Code nicht geändert werden. Es reicht, den Code auszuführen mit **\"Strg+Enter\"** und das Ergebnis zu verstehen. Schaut euch den Code an und versucht zu verstehen, was gemacht wird. Einige Anweisungen kennt ihr bereits, andere widerum sind neu. \n",
+ "\n",
+ " - Dieser Exkurs soll nur zeigen, zu was python alles fähig ist :)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- Markdownblöcke mit **\"Strg + enter\"** wieder in den Lesemodus bringen"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- Download: Linksklick auf das Notebook (z.B. seminar03.ipynb) -> Rechtsklick auf Feld \"Open Raw\" -> Ziel speichern unter \n",
+ "- Download von Notebooks mit Firefox!\n",
+ "- Öffnen von Jupyter-Notebook geht auch mit Internet-Explorer"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- Falls ihr einen Codeblock ausführt und ein Stern erscheint: \"In [ * ]\" , bedeutet das, dass der Code gerade ausgeführt wird. Manchmal bleibt das Notebook aber auch einfach hängen, dann benutzt folgende Möglichkeit : Kernel-> restart and clear output. Damit wird das Notebook komplett neu geladen, allerdings müsst ihr die vorherigen Codeblöcke auch neu ausführen."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Allgemein"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- Bitte in **beide Moodle Kurse** anmelden. Ankündigungen werden dort veröffentlicht! \n",
+ " - Man kann einstellen, dass man Emails bei neuen Forumbeiträgen bekommt."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- Latex-Fragen-> Tutorium oder Ãœbung. Im Seminar braucht ihr kein Latex."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- **Pair-Programming** bitte einhalten: **\"nicht gleichzeitig\"** programmieren, sondern **abwechselnd aktiv** sein. Das ist für alle Beteiligten ein Vorteil!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Beispielrechnungen"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "40/1.61 \n",
+ "#Hier rechnen wir 40km in Meilen um. Das Ergebnis, welches Python ausgibt, bitte nicht für weitere Rechnungen verwenden.\n",
+ "# Stattdessen können wir einfach den Term in Klammern benutzen (40/1.61) oder die Rechnung in einer Variable speichern (z.B. Meilen= 40/1.61)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#example\n",
+ "#Ein Mann hat eine 40km Fahrradtour in 2h absolivert. \n",
+ "#1. Wieviele Sekunden pro Meter ist er im Durchschnitt gefahren?\n",
+ "#2. Mit wieviel Meter pro Minute war er im Durchschnitt unterwegs?\n",
+ "#3. Mit wieviel Meilen pro Stunde war er im Durchschnitt unterwegs?\n",
+ "#solution:\n",
+ "\n",
+ "#Zeit in verschiedenen Einheiten\n",
+ "Stunden=2\n",
+ "Minuten=Stunde*60\n",
+ "Sekunden=Minute*60\n",
+ "#Strecken in verschiedenen Einheiten\n",
+ "Kilometer=10\n",
+ "Meter=40*1000\n",
+ "Meilen=40/1.61\n",
+ "print(\"In einer print()-Funktion kann man\",\"mehrere Zeichenketten und Variablen\", \" durch Kommata trennen und zusammen ausgeben\")\n",
+ "print(\"Sekunden pro Meter :\", Sekunden/Meter)\n",
+ "print(\"Meter pro Mintue :\", Meter/Minuten)\n",
+ "print(\"Meilen pro Stunde :\", Meilen/Stunden, \"Perfekt\")\n",
+ "print(\"Meilen pro Stunde :\", (40/1.61)/Stunden, \"Okay\")\n",
+ "print(\"Meilen pro Stunde :\", 24.844720496894407/Stunden, \"Bitte nicht gerundete Zahlen übernehmen\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(\"Division von integers \\n\")\n",
+ "#Teilen von Ganzzahlen (integers oder int) mit \"/\" (gibt den genauen Wert zurück, typ=float)\n",
+ "print(\"Hier dividieren wir mit Hilfe von /: \",2/60,3/2,8/3, sep='\\t')\n",
+ "\n",
+ "#Teilen von Ganzzahlen (integers oder int) mit \"//\" (gibt den abgerundeten Wert wieder, typ=int)\n",
+ "print(\"Hier dividieren wir mit Hilfe von //: \",2//60,3//2,8//3, sep='\\t')\n",
+ "\n",
+ "print(\"\\n Division von float und integers \\n\")\n",
+ "\n",
+ "#Teilen von Float und Ganzzahlen (integers oder int) mit \"/\" (gibt den genauen Wert zurück, typ=float)\n",
+ "print(\"Hier dividieren wir mit Hilfe von /: \",2/60.0,3.0/2,8.4/3,sep='\\t')\n",
+ "\n",
+ "#Teilen von Float und Ganzzahlen (integers oder int) mit \"//\" (gibt den abgerundeten Wert wieder, typ=float)\n",
+ "print(\"Hier dividieren wir mit Hilfe von //: \",2//60.0,3.0//2,8.4//3,sep='\\t')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Bitte diesen Codeblock einfach ausführen\n",
+ "\n",
+ "print(\"Variablen: \\n\")\n",
+ "test_variable=\"Ich gebe erstmal nichts aus, bin aber gespeichert\"\n",
+ "testVariable=\"Ich gebe auch nichts aus, bin ebenso gespeichert\"\n",
+ "\n",
+ "\n",
+ "print(\"Nur durch diese Print-Funktion erzeuge ich einen Output: \\n test_variable:\\t\",test_variable,\"! \\n testVariable: \\t\", testVariable)\n",
+ "\n",
+ "\n",
+ "#und ich bin nur eine Kommentarzeile. \n",
+ "#Ich gebe nichts aus, kann aber beschreiben, was in diesem Codeblock gemacht wird, ohne den Codeblock auszuführen.\n",
+ "#Das hilft anderen, den Code zu verstehen."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Bitte diesen Codeblock einfach ausführen\n",
+ "\n",
+ "print(\"Durch verschiedene Zeichen kann man den Output der Print-Funktion 'verschönern'. \\n\")\n",
+ "\n",
+ "print('\"\\\\n\" : erzeugt einen Zeilenabsatz \\n' )\n",
+ "print(\"Beispiel: \\n\", \"Hello \\n , \\n World \\n ! \")\n",
+ "\n",
+ "print('\"\\\\t\" : rückt den anschließenden Abstand um einen festen Abstand vor \\n' )\n",
+ "print(\"Beispiel: \\t\", \"Hello \\t , \\t World \\t ! \")\n",
+ "print(\"\\n\")\n",
+ "\n",
+ "\n",
+ "print('Bis jetzt konnten wir diese Anweisung in einer Zeichenkette ausühren.Man kann der print Funktion auch einen zusätzlichen Befehl übergeben: \"sep=\\\\n\" oder \"sep=\\\\t\"')\n",
+ "print(\"Dieser Befehl definiert den Abstand zwischen verschiedenen Anweisungen innerhalb der print-Funktion\")\n",
+ "print(\"BeispieL: \",\"Jetzt\", \"werden\", \"wir\", \"zwischen\", \"jeder\", \"Anweisung\", \"einen\", \"Abstand\", \"definieren\", sep=\"\\t\")\n",
+ "print(\"BeispieL: \",\"Jetzt\", \"werden\", \"wir\", \"zwischen\", \"jeder\", \"Anweisung\", \"einen\", \"Abstand\", \"definieren\", sep=\"\\n\")\n",
+ "\n",
+ "\n",
+ "#Macht euch den Unterschied zwischen \\t und \\n innerhalb einer Zeichenkette und sep=\"\\n\" klar."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Print - Funktion\n",
+ "\n",
+ "- Die Print-Funktion \"print()\" kann mehrere Argumente entgegennehmen. Das können ganz verschiedene Datentypen sein. Die verschiedenen Argumente müssen jeweils durch Kommata getrennt werden.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "variable1=\"Hello\"\n",
+ "variable2=\",\"\n",
+ "variable3=\"World\"\n",
+ "variable4=\"!\"\n",
+ "\n",
+ "print(variable1,variable2,\" Zwischendurch kann man auch eine Zeichenkette einbauen, solange man sie durch Kommata von den Variablen trennt\", variable3, variable4)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- Um die print-Funktion zu formatieren und dadurch übersichtlicher zu gestalten, gibt es einige Hilfsmittel:\n",
+ "- \"\\n\" : Backslash + n in einer Zeichenkette (d.h. in Anführungszeichen) ergeben eine neue Zeile\n",
+ "- \"\\t\" : Backslash + t in einer Zeichenkette (d.h. in Anführungszeichen) ergeben eine Abstand von mehreren Leerzeichen"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "variable1=\"Hello\"\n",
+ "variable2=\",\"\n",
+ "variable3=\"World\"\n",
+ "variable4=\"!\"\n",
+ "\n",
+ "print('\"\\\\n\" funktioniert folgendermaßen zwischen Variablen:')\n",
+ "print(variable1,variable2,\"\\n\",variable3, variable4)\n",
+ "print(\"oder auch innerhalb einer Zeichenkette\")\n",
+ "print(\"Hello, \\n World !\")\n",
+ "\n",
+ "\n",
+ "print('\"\\\\t\" funktioniert analog.')\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- Zu guter Letzt kann man noch einen allgemeinen Abstand zwischen den Argumenten definieren, der standardmäßig ein Leerzeichen ist. Dadurch gibt man ganz am Ende einer Print-Funktion folgende Anweisung: sep= \n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(\"Standard: ein Leerzeichen : \",variable1,variable2,variable3, variable4)\n",
+ "print(\"Variante: kein Zeichen : \",variable1,variable2,variable3, variable4, sep='')\n",
+ "print(\"Variante: tab-Abstand : \", variable1,variable2,variable3, variable4, sep='\\t')\n",
+ "print(\"Variante: neue Zeile : \", variable1,variable2,variable3, variable4, sep='\\n')\n",
+ "print(\"Variante: drei Punkte (man kann jegliches Zeichen angeben) : \", variable1,variable2,variable3, variable4, sep='...')\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Zahlen - float"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- WICHTIG: Bei Ankündigung von Michel: Bitte Jupyter Notebooks durcharbeiten oder wenigstens versuchen. Ich verstehe, dass man nicht immer alle Übungen alleine schafft, aber zumindest die Theorie kann man mit seinem Partner durcharbeiten. \n",
+ "- Falls Hilfe benötigt wird -> Michel: Email oder vorbeikommen | Tutorium Dienstags"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- Gleitkommazahlen (floats) immer mit \".\" statt \",\" angeben -> 29.99 statt 29,99"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Gleitkommazahl durch Punkt getrennt -> RICHTIG\n",
+ "\n",
+ "preis=29.99\n",
+ "print(preis)\n",
+ "print(type(preis))\n",
+ "# python erkennt die Zahl und gibt die Zahl wieder. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Gleitkommazahl durch Komma getrennt -> FALSCH\n",
+ "\n",
+ "preis=29,99\n",
+ "print(preis)\n",
+ "type(preis)\n",
+ "# Python erkennt zwei Zahlen, die es in einem Tupel speichert."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Importieren von Modulen und Bibliotheken"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- Stellen Datentypen oder Funktionen für alle Python-Programme bereit\n",
+ "- Syntax: `import module` \n",
+ "- Konvention: Steht **immer am Anfang des Codes**\n",
+ "- Beispiel:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "import turtle\n",
+ "import csv\n",
+ "\n",
+ "#hier steht Code"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Turtle Modul\n",
+ "\n",
+ "- Dokumentation mit allen turtle-Methoden: https://docs.python.org/3/library/turtle.html\n",
+ "- Im Idealfall sollte in jedem Codeblock die folgenden Anweisungen stehen:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Zuerst wird das Modul turtle importiert\n",
+ "import turtle\n",
+ "\n",
+ "\n",
+ "#hier steht euer Code\n",
+ "\n",
+ "\n",
+ "\n",
+ "# Um ein Arbeiten mit turtle und Jupyter-Notebook zu ermöglichen, müssen wir diese beiden Befehle am Ende des Blocks schreiben\n",
+ "\n",
+ "turtle.mainloop()\n",
+ "turtle.bye()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Zuerst wird das Modul turtle importiert\n",
+ "import turtle\n",
+ "\n",
+ "#Hier lernen wir die Funktionen up(), down() und fd() kennen\n",
+ "\n",
+ "otto=turtle.Turtle()\n",
+ "\n",
+ "def line(t):\n",
+ " t.fd(50)\n",
+ " t.up()\n",
+ " t.fd(50)\n",
+ " t.down()\n",
+ " t.fd(50)\n",
+ " t.fd(50)\n",
+ " t.up()\n",
+ " t.fd(50)\n",
+ " t.fd(50)\n",
+ " t.down()\n",
+ " t.fd(50)\n",
+ "# Um ein Arbeiten mit turtle und Jupyter-Notebook zu ermöglichen, müssen wir diese beiden Befehle am Ende des Blocks schreiben\n",
+ "line(otto)\n",
+ "turtle.mainloop()\n",
+ "turtle.bye()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Kommentare -> commit -> nicht zu bdeuten"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import turtle\n",
+ "\n",
+ "otto=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen otto zugewiesen\n",
+ "anna=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen anna zugewiesen\n",
+ "telmo=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen telmo zugewiesen\n",
+ "\n",
+ "#Hier lernen wir die Funktionen shape(), color(), fd() und lt() kennen\n",
+ "\n",
+ "def square(t): \n",
+ " t.shape('turtle') #wir geben der turtle t die Form einer Schildkröte\n",
+ " t.color(\"purple\",\"red\") #wir färben den zurückgelegten Weg lila (erstes Argument), die Schildkröte rot (zweites Argument)\n",
+ " for k in range(4): #schleife (4 Aufrufe): unsere turtle läuft in jedem Aufruf zuerst gerade aus und wendet sich dann um 90° nach links.\n",
+ " t.fd(100)\n",
+ " t.lt(90) \n",
+ "\n",
+ "square(otto) #wir rufen square mit der turtle namens otto auf. Wir könnten aber genauso anna oder telmo nehmen\n",
+ "\n",
+ "turtle.mainloop()\n",
+ "turtle.bye()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import turtle\n",
+ "\n",
+ "otto=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen otto zugewiesen\n",
+ "anna=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen anna zugewiesen\n",
+ "telmo=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen telmo zugewiesen\n",
+ "\n",
+ "#Hier lernen wir die Funktionen color(),begin_fill(), end_fill(), fd() und lt() kennen\n",
+ "\n",
+ "def square(t): \n",
+ " t.color(\"purple\") #Falls nur ein Argument in color()--> Schildkröte und Weg haben dieselbe Farbe. Wir färben die Schildkröte und die Fläche, die wir einfärben wollen, lila\n",
+ " \n",
+ " t.begin_fill() # wir beginnen die Fläche, die unsere turtle läuft, zu färben\n",
+ " for k in range(4): #schleife (4 Aufrufe): unsere turtle läuft in jedem Aufruf zuerst gerade aus und wendet sich dann um 90° nach links.\n",
+ " t.fd(100)\n",
+ " t.lt(90) \n",
+ " t.end_fill() # wir beenden das Einfärben der Fläche\n",
+ " \n",
+ "square(anna) #wir rufen square mit der turtle namens anna auf. Wir könnten aber genauso otto oder telmo nehmen\n",
+ "\n",
+ "turtle.mainloop()\n",
+ "turtle.bye()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import turtle\n",
+ "\n",
+ "otto=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen otto zugewiesen\n",
+ "anna=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen anna zugewiesen\n",
+ "telmo=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen telmo zugewiesen\n",
+ "\n",
+ "#Hier lernen wir die Funktionen shape(), stamp(), color(), colormode() und fd() kennen\n",
+ "\n",
+ "colors=['red','purple','blue','yellow','orange']\n",
+ "def line(t): \n",
+ " t.shape('turtle')\n",
+ " t.stamp() #wir machen einen Stempel an dieser Stelle von unserem turtle\n",
+ " t.fd(100)\n",
+ " turtle.colormode(255) # um RGB-Farben anzuwenden, muss man vorher diesen Colormode aktivieren\n",
+ " t.color(255,180,200) #Jetzt können wir Farben in RGB-Werten angeben (--> mehr Möglichkeiten)\n",
+ " t.stamp() #wir machen einen Stempel an dieser Stelle von unserem turtle\n",
+ " t.fd(100)\n",
+ " t.color(colors[1])\n",
+ " t.stamp() #wir machen einen Stempel an dieser Stelle von unserem turtle\n",
+ " t.fd(100)\n",
+ " t.color(colors[4])\n",
+ " t.stamp() #wir machen einen Stempel an dieser Stelle von unserem turtle\n",
+ " t.fd(100)\n",
+ "\n",
+ " \n",
+ "line(telmo) #wir rufen line mit der turtle namens telmo auf. Wir könnten aber genauso anna oder otto nehmen\n",
+ "\n",
+ "turtle.mainloop()\n",
+ "turtle.bye()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import turtle\n",
+ "\n",
+ "otto=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen otto zugewiesen\n",
+ "anna=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen anna zugewiesen\n",
+ "telmo=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen telmo zugewiesen\n",
+ "\n",
+ "#Hier lernen wir die Funktionen circle() und shapesize() kennen\n",
+ "\n",
+ "def circle(t,r): \n",
+ " t.shape('turtle') \n",
+ " t.shapesize(10) # wir ändern die Größe unserer turtle\n",
+ " t.circle(r) #wir malen einen Kreis mit Radius r\n",
+ " \n",
+ "circle(telmo,100) #wir rufen line mit der turtle namens telmo auf. Wir könnten aber genauso anna oder otto nehmen\n",
+ "\n",
+ "turtle.mainloop()\n",
+ "turtle.bye()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Funktionen\n",
+ "\n",
+ "Funktion funktionieren in Python wie mathematische Funktionen aus der Schule: \n",
+ "\n",
+ "Stellt euch die Funktion f(x,y)=x*y vor. In Python definieren wir sie wie folgt:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def f(x,y):\n",
+ " return x*y"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Jetzt haben wir die Funktion zwar definiert, aber sie gibt noch kein Ergebnis zurück. Das passiert nur, wenn wir die Funktion aufrufen. \n",
+ "\n",
+ "Um die Funktion aufzurufen, müssen wir die Parameter x und y explizit angeben, z.B. x=5 und y=3. \n",
+ "\n",
+ "In der Schule haben wir früher Folgendes geschrieben: f(5,3)=5*3=15. \n",
+ "\n",
+ "In Python machen wir nichts anderes, nur das Berechnen überlassen wir python:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(\"Es gibt verschiedene Wege: \\n \\n\")\n",
+ "\n",
+ "print(\"Lösung von f(x=5,y=3) : \", f(x=5,y=3)) \n",
+ "print(\"\\nAlternative 1:\")\n",
+ "print(\"Lösung von f(5,3) : \", f(5,3)) \n",
+ "print(\"\\nAlternative 2:\")\n",
+ "variable_x=5\n",
+ "variable_y=3\n",
+ "print(\"Lösung von f(variable_x, variable_y) : \", f(variable_x, variable_y)) "
+ ]
+ },
+ {
+ "cell_type": "raw",
+ "metadata": {},
+ "source": [
+ "Fazit: Um eine Funktion aufzurufen und ein Ergebnis herauszubekommen, reicht es nicht, die Funktion zu definieren. Sie muss anschließend aufgerufen werden. Die Parameter müssen explizit angegeben werden."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Browser-Einstellungen für Jupyter-Notebook\n",
+ "\n",
+ "Jupyter-Notebook wird immer in dem Browser geöffnet, der auf dem Computer als Standardbrowser festgelegt ist.\n",
+ "Im PC-Pool ist das zur Zeit der Internet-Explorer und wir können das leider nicht ändern.\n",
+ "Dadurch funktionieren manche Shortcuts leider nicht.\n",
+ "\n",
+ "Auf euren PC's zu Hause könnt ihr es aber einfach ändern: \n",
+ "\n",
+ "(Wir empfehlen Firefox als Standardbrowser)\n",
+ "\n",
+ "macOS:\n",
+ "\n",
+ " 1. Öffnen sie die Systemeinstellungen.\n",
+ " 2. Klicken Sie auf „Allgemein“.\n",
+ " 3. Wählen Sie unter „Standard-Webbrowser“ den gewünschten Browser aus.\n",
+ "\n",
+ "Ubuntu Linux:\n",
+ "\n",
+ " 1. Öffnen Sie die System Settings.\n",
+ " 2. Klicken Sie auf „Applications“.\n",
+ " 3. Wählen Sie in der linken Spalte „Default Applications“ aus.\n",
+ " 4. Klicken Sie in der Spalte rechts davon auf „Web Browser“.\n",
+ " 5. Wählen Sie „in the following browser:“ aus.\n",
+ " 6. Wählen Sie den gewünschten Browser aus.\n",
+ "\n",
+ "Windows:\n",
+ "\n",
+ " 1. Öffnen Sie die Systemsteuerung.\n",
+ " 2. Klicken Sie auf „Standardprogramme“.\n",
+ " 3. Klicken Sie auf „Standardprogramme festlegen“.\n",
+ " 4. Klicken Sie in der Liste auf den gewünschten Browser.\n",
+ " 5. Klicken Sie dann auf „Dieses Programm als Standard festlegen“.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Tipps und Tricks \n",
+ "- Einrücken durch die \"Tabulatortaste\", um die richtige Formatierung einfach zu bekommen (bei Definitionen von Funktionen, for- oder while-Schleifen, if-Bedingungen, etc.)\n",
+ "- Beispiel:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def example():\n",
+ " i=0\n",
+ " while i <= 5:\n",
+ " if i<1:\n",
+ " print(\"Mit der tab-Taste kann man immer 'eins weiter' einrücken.\")\n",
+ " elif i==5:\n",
+ " print(\"Mit 'tab' und 'shift' gleichzeitig rückt man 'eins' wieder nach hinten.\")\n",
+ " i=i+1\n",
+ " \n",
+ "example()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- Alternativer Python-Kurs für Interessierte: https://automatetheboringstuff.com/"
+ ]
+ }
+ ],
+ "metadata": {
+ "language_info": {
+ "name": "python",
+ "pygments_lexer": "ipython3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/notebooks/anmerkungenUndTipps.ipynb b/notebooks/anmerkungenUndTipps.ipynb
deleted file mode 100644
index 3979540..0000000
--- a/notebooks/anmerkungenUndTipps.ipynb
+++ /dev/null
@@ -1,243 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Woche 1"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "- Im Exkurs \"was mir an python gefällt\" muss der Code nicht geändert werden. Es reicht, den Code auszuführen mit \"Strg+Enter\" und das Ergebnis zu verstehen."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "- Bitte in beide Moodle Kurse anmelden. Ankündigungen werden dort veröffentlicht! -> Man kann einstellen, dass man Emails bei neuen Forumbeiträgen bekommt."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "- falls ihr einen Codeblock ausführt und ein Stern erscheint: \"In [ * ]\" , bedeutet das eigentlich, dass der Code gerade ausgeführt wird. Manchmal bleibt das Notebook aber auch einfach hängen, dann benutzt folgende Möglichkeit : Kernel-> restart and clear output. Damit wird das Notebook komplett neu geladen, allerdings müsst ihr die vorherigen Codeblöcke auch neu ausführen."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "- Latex-Fragen-> Tutorium oder Ãœbung. Im Seminar braucht ihr kein Latex."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "- Pair-Programming bitte einhalten: nicht \"gleichzeitig\" programmieren, sondern abwechselnd aktiv sein. Das ist für alle Beteiligten ein Vorteil!"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "- Markdownblöcke mit \"strg+ enter\" wieder in den Lesemodus bringen"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "- Download: Linksklick auf das Notebook (z.B. seminar03.ipynb) -> Rechtsklick auf Feld \"Open Raw\" -> Ziel speichern unter "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "- Download von Notebooks mit Firefox!\n",
- "- Öffnen von Jupyter-Notebook geht auch mit Internet-Explorer"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "40/1.61 \n",
- "#Hier rechnen wir 40km in Meilen um. Das Ergebnis, welches Python ausgibt, bitte nicht für weitere Rechnungen verwenden.\n",
- "# Stattdessen können wir einfach den Term in Klammern benutzen (40/1.61) oder die Rechnung in einer Variable speichern (z.B. Meilen= 40/1.61)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "#example\n",
- "#Ein Mann hat eine 40km Fahrradtour in 2h absolivert. \n",
- "#1. Wieviele Sekunden pro Meter ist er im Durchschnitt gefahren?\n",
- "#2. Mit wieviel Meter pro Minute war er im Durchschnitt unterwegs?\n",
- "#3. Mit wieviel Meilen pro Stunde war er im Durchschnitt unterwegs?\n",
- "#solution:\n",
- "\n",
- "#Zeit in verschiedenen Einheiten\n",
- "Stunden=2\n",
- "Minuten=Stunde*60\n",
- "Sekunden=Minute*60\n",
- "#Strecken in verschiedenen Einheiten\n",
- "Kilometer=10\n",
- "Meter=40*1000\n",
- "Meilen=40/1.61\n",
- "print(\"In einer print()-Funktion kann man\",\"mehrere Zeichenketten und Variablen\", \" durch Kommata trennen und zusammen ausgeben\")\n",
- "print(\"Sekunden pro Meter :\", Sekunden/Meter)\n",
- "print(\"Meter pro Mintue :\", Meter/Minuten)\n",
- "print(\"Meilen pro Stunde :\", Meilen/Stunden, \"Perfekt\")\n",
- "print(\"Meilen pro Stunde :\", (40/1.61)/Stunden, \"Okay\")\n",
- "print(\"Meilen pro Stunde :\", 24.844720496894407/Stunden, \"Bitte nicht gerundete Zahlen übernehmen\")"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "print(\"Division von integers \\n\")\n",
- "#Teilen von Ganzzahlen (integers oder int) mit \"/\" (gibt den genauen Wert zurück, typ=float)\n",
- "print(\"Hier dividieren wir mit Hilfe von /: \",2/60,3/2,8/3, sep='\\t')\n",
- "\n",
- "#Teilen von Ganzzahlen (integers oder int) mit \"//\" (gibt den abgerundeten Wert wieder, typ=int)\n",
- "print(\"Hier dividieren wir mit Hilfe von //: \",2//60,3//2,8//3, sep='\\t')\n",
- "\n",
- "print(\"\\n Division von float und integers \\n\")\n",
- "\n",
- "#Teilen von Float und Ganzzahlen (integers oder int) mit \"/\" (gibt den genauen Wert zurück, typ=float)\n",
- "print(\"Hier dividieren wir mit Hilfe von /: \",2/60.0,3.0/2,8.4/3,sep='\\t')\n",
- "\n",
- "#Teilen von Float und Ganzzahlen (integers oder int) mit \"//\" (gibt den abgerundeten Wert wieder, typ=float)\n",
- "print(\"Hier dividieren wir mit Hilfe von //: \",2//60.0,3.0//2,8.4//3,sep='\\t')"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "#Bitte diesen Codeblock einfach ausführen\n",
- "\n",
- "print(\"Variablen: \\n\")\n",
- "test_variable=\"Ich gebe erstmal nichts aus, bin aber gespeichert\"\n",
- "testVariable=\"Ich gebe auch nichts aus, bin ebenso gespeichert\"\n",
- "\n",
- "\n",
- "print(\"Nur durch diese Print-Funktion erzeuge ich einen Output: \\n test_variable:\\t\",test_variable,\"! \\n testVariable: \\t\", testVariable)\n",
- "\n",
- "\n",
- "#und ich bin nur eine Kommentarzeile. \n",
- "#Ich gebe nichts aus, kann aber beschreiben, was in diesem Codeblock gemacht wird, ohne den Codeblock auszuführen.\n",
- "#Das hilft anderen, den Code zu verstehen."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "#Bitte diesen Codeblock einfach ausführen\n",
- "\n",
- "print(\"Durch verschiedene Zeichen kann man den Output der Print-Funktion 'verschönern'. \\n\")\n",
- "\n",
- "print('\"\\\\n\" : erzeugt einen Zeilenabsatz \\n' )\n",
- "print(\"Beispiel: \\n\", \"Hello \\n , \\n World \\n ! \")\n",
- "\n",
- "print('\"\\\\t\" : rückt den anschließenden Abstand um einen festen Abstand vor \\n' )\n",
- "print(\"Beispiel: \\t\", \"Hello \\t , \\t World \\t ! \")\n",
- "print(\"\\n\")\n",
- "\n",
- "\n",
- "print('Bis jetzt konnten wir diese Anweisung in einer Zeichenkette ausühren.Man kann der print Funktion auch einen zusätzlichen Befehl übergeben: \"sep=\\\\n\" oder \"sep=\\\\t\"')\n",
- "print(\"Dieser Befehl definiert den Abstand zwischen verschiedenen Anweisungen innerhalb der print-Funktion\")\n",
- "print(\"BeispieL: \",\"Jetzt\", \"werden\", \"wir\", \"zwischen\", \"jeder\", \"Anweisung\", \"einen\", \"Abstand\", \"definieren\", sep=\"\\t\")\n",
- "print(\"BeispieL: \",\"Jetzt\", \"werden\", \"wir\", \"zwischen\", \"jeder\", \"Anweisung\", \"einen\", \"Abstand\", \"definieren\", sep=\"\\n\")\n",
- "\n",
- "\n",
- "#Macht euch den Unterschied zwischen \\t und \\n innerhalb einer Zeichenkette und sep=\"\\n\" klar."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Woche 2"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "- WICHTIG: Bei Ankündigung von Michel: Bitte Jupyter Notebooks durcharbeiten oder wenigstens versuchen. Ich verstehe, dass man nicht immer alle Übungen alleine schafft, aber zumindest die Theorie kann man mit seinem Partner durcharbeiten. \n",
- "- Falls Hilfe benötigt wird -> Michel: Email oder vorbeikommen | Tutorium Dienstags"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "- Gleitkommazahlen (floats) immer mit \".\" statt \",\" angeben -> 29.99 statt 29,99"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "#Gleitkommazahl durch Punkt getrennt -> RICHTIG\n",
- "\n",
- "preis=29.99\n",
- "print(preis)\n",
- "print(type(preis))\n",
- "# python erkennt die Zahl und gibt die Zahl wieder. "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Gleitkommazahl durch Komma getrennt -> FALSCH\n",
- "\n",
- "preis=29,99\n",
- "print(preis)\n",
- "type(preis)\n",
- "# Python erkennt zwei Zahlen, die es in einem Tupel speichert."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Alternative für Interessierte: https://automatetheboringstuff.com/"
- ]
- }
- ],
- "metadata": {
- "language_info": {
- "name": "python",
- "pygments_lexer": "ipython3"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
--
GitLab