{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Erste Schritte mit Jupyter und Auffrischung Ihres Programmierkönnens\n", "\n", "Jupyter ist wie ein interaktives Script, das aus Textzellen und ausführbaren Codezellen besteht. \n", "\n", "In diesem Notebook machen Sie die ersten Schritte mit Jupyter Notebooks, bekommen eine Übersicht über Markdown, damit Sie eigene Notizen erstellen können und frischen Ihre Programmierkenntnisse mit Python auf.\n", "\n", "---\n", "**Ziele**\n", "\n", "* Jupyter Notebooks\n", " * Sie können Jupyter Notebooks bedienen und zwischen Markdown- und Codezellen unterscheiden.\n", " * Sie wissen, wie Sie den Kernel unterbrechen oder ganz neu starten können, wenn Ihr Programm hängenbleibt.\n", "* Markdown\n", " * Sie haben grobe Kenntnisse von Markdown: Sie können Titel erstellen, Text hervorheben (fett und kursiv) nummerierte und unnummerierte Aufzählungen, Zeilenumbrüche einfügen. Ausserdem wissen Sie, dass Markdownzellen durch Doppelklicken in den Editiermodus gewechselt werden können und wieder schön dargestellt werden, wenn sie ausgeführt werden. Sie wissen, dass Sie in diesem Notebook, im Internet oder diesem [Cheatsheet](https://guides.github.com/pdfs/markdown-cheatsheet-online.pdf) nachsehen können.\n", "* Programmieren in Python\n", " * Sie haben Ihr bisheriges Programmierwissen wieder aufgefrischt.\n", " * Sie kennen die besprochenen Fehlermeldungen und können sie für die Fehlersuche nutzen.\n", "---\n", "\n", "Jupyter bietet verschiedenste nützliche Funktionen. Sie können über den im Bild unten blau markierten Tastatur-Button eine durchsuchbare Funktionsübersicht anzeigen.\n", "\n", "## Zellen\n", "\n", "Einerseits können Zellen **Text** enthalten, aber auch Links zu Webinhalten wie Filmen und Bilder enthalten, andererseits können Sie in **Codezellen** ausführbaren Code schreiben und direkt mittels [Shift]+[Enter] ausführen. \n", "\n", "Die Beispiele aus dem Script müssen Sie somit nicht abtippen, sondern können sie gleich ausprobieren und in Textzellen eigene Notizen hinzufügen.\n", "\n", "### Zellen erstellen\n", "\n", "\n", "\n", "Um neue Zellen zu erstellen klicken Sie auf das `+` im Menü oben und danach wählen Sie die Art der Zelle. Für diesen Kurs benötigen Sie `Markdown` für Textzellen und `Code` für Codezellen.\n", "\n", "Neue Zellen werden immer unterhalb der angewählten Zelle eingefügt und sind standardmässig vom Typ Code.\n", "\n", "Angewählte Zellen lassen sich mit den Pfeilbuttons (hellblau markiert) nach oben bzw. unten verschieben.\n", "\n", "### Zellen ausführen\n", "\n", "Eine einzelne Zelle können Sie entweder mit dem Button `Run` im grün markierten Bereich ausführen oder mit der Tastenkombination [Shift]+[Enter].\n", "\n", "### Kernel\n", "\n", "Der Kernel kümmert sich um die Ausführung des Pythoncodes im Notebook.\n", "\n", "#### Erste Hilfe: Was tun, wenn Ihr Programm hängenbleibt?\n", "\n", "Ist links der Zelle zwischen eckigen Klammern ein `[*]` zu sehen, so wird die Zelle gerade ausgeführt oder sie wartet darauf, ausgeführt zu werden. Wenn Sie die Ausführung stoppen möchten, können Sie dazu den Kernel unterbrechen (Kernelmenü oder Button ◼️).\n", "\n", "Manchmal ist es auch hilfreich, den Kernel zu stoppen und gleich wieder alle Zellen auszuführen, was mit dem Button mit den zwei Pfeilen erreicht werden kann. Über den Button mit dem runden Pfeil können Sie den Kernel neu starten. Dabei werden alle Ausgaben gelöscht und die Zellen müssen erneut ausgeführt werden. Es gibt auch ein **Menü Kernel**. Darüber kann der Kernel ebenfalls verwaltet werden.\n", "\n", "Links, ausserhalb der Codezellen Zelle sehen Sie, in welchem Zustand sich diese befinden:\n", "* `In [*]` Zellen, die ausgeführt werden oder auf die Ausführung warten\n", "* `In [ ]` noch nicht ausgeführte Zellen\n", "* `In [Zahl]`, bereits ausgeführte Zellen\n", "\n", "## Markdown in Textzellen\n", "\n", "Um Textzellen anzupassen gelangen Sie per Doppelklick in den Editormodus.\n", "\n", "Machen Sie von der Möglichkeit Gebrauch, Ihre Notizen direkt in die Jupyter Notebooks zu machen. Sie können Ihre Jupyter Notebooks am Schluss in verschiedene Formate exportieren oder drucken. Damit haben Sie am Ende Ihren Code und Ihre Notizen an einem Ort.\n", "\n", "Textzellen nutzen die **Syntax von Markdown**. \n", "\n", "Diese ist ziemlich einfach aufgebaut. Wenn Sie mehr dazu wissen möchten, klappen Sie diesen Teil aus.\n", "\n", "### Überschriften \n", "Überschriften sind jeweils durch eine oder mehrere Rauten gekennzeichnet, je weniger Rauten desto grösser der Titel. Die Anzahl der Rauten bestimmt somit die Hierarchiestufe:\n", "\n", "# Überschrift der Stufe 1\n", "\n", "Wird in der Regel nur für den Titel des Dokuments/Artikels/Buchs verwendet.\n", " \n", "## Überschrift der Stufe 2\n", " \n", "Ist schon etwas kleiner und würde dem Kapitel entsprechen oder einem Abschnitt. \n", "Nummerierung: 1.\n", " \n", "Und **mit jeder Raute** wird der Titel noch **eine Stufe kleiner**:\n", " \n", "### Überschrift der Stufe 3\n", "\n", "Ist noch etwas kleiner und würde einem Unterkapitel entsprechen oder einem Unterabschnitt. \n", "Nummerierung: 1.1.\n", "\n", "#### Überschrift der Stufe 4\n", "\n", "Nummerierung: 1.1.1.\n", " \n", "##### Überschrift der Stufe 5\n", "\n", "Nummerierung: 1.1.1.1.\n", " \n", "Sie könnten auch noch weitere Stufen machen, diese würden aber hier nicht anders formatiert.\n", " \n", "### Überschrift der Text\n", "\n", "Text schreiben Sie ganz normal, **fetten Text** markieren Sie entweder mit zwei `*` oder zwei `_`, kursiven Text mit jeweils einem `*` bzw. `_`. Fett und kursiv würde einer Kombination oder drei `*` bzw. `_` entsprechen.\n", " \n", "* Ein Sternchen oder Underscore: *kursiv*, _kursiv_ \n", "* Zwei Sternchen oder Underscores: **fett**, __fett__ \n", "* Auch mi**tt**en im Wort können Sie etwas her*vor*heben.\n", "* Auch fett-kursive Her***vor***hebungen sind möglich, zwischen `***` oder `___` oder einer Kombination aus Sternchen und Underscores: **_fettkursiv_**, __*fettkursiv*__.\n", " \n", "#### Zeilenumbrüche\n", " \n", "Für Zeilenumbrüche machen Sie entweder zwei Leerzeichen am Ende der Zeile, nach der Sie umbrechen wollen oder Sie fügen zwischen den beiden Zeilen eine Leerzeile ein. Zeilenumbrüche können auch in Aufzählungen eingefügt werden.\n", "\n", "### Aufzählungen\n", "\n", "Nummerierte Aufzählungen können Sie mit 1., 2., ... am Zeilenanfang erstellen, nicht nummerierte Aufzählungen \n", "mit `*`:\n", "\n", "1. Das\n", "2. ist\n", "3. eine\n", "4. nummerierte\n", "5. Aufzählung\n", " 1. Und\n", " 2. hier\n", " 1. wird \n", " 1. eingerückt\n", "\n", "* Das\n", "* ist\n", "* eine\n", "* nicht-\n", "* nummerierte\n", "* Aufzählung\n", " * Und\n", " * hier\n", " * wird eingerückt\n", "\n", "\n", "### Links\n", "\n", "In Markdown werden Links folgendermassen dargestellt: Eckige Klammern umgeben den angezeigten Text, gefolgt von runden Klammern, mit denen der Link gezeigt wird. `[Pythondokumentation](https://docs.python.org/3/)` erstellt den folgenden Link: [Pythondokumentation](https://docs.python.org/3/). Auf diese Weise erstellte Links gehen in einem neuen Tab auf.\n", "\n", "### Bilder\n", "\n", "Bilder könnten Sie wie Links platzieren, mit einem vorangehenden Ausrufezeichen `![Alternativtext](relativer Pfad zum Bild)` allerdings würden diese Bilder nach Möglichkeit in Originalgrösse dargestellt, was selten zielführend ist.\n", "\n", "\n", "### HTML\n", "\n", "Sie können HTML in Markdown einfügen und haben somit die Möglichkeit, fast alles darzustellen.\n", "\n", "Hier werden Bilder jeweils mit HTML eingefügt, weil dadurch mehr Flexibilität entsteht, die Bilder kleiner darzustellen.\n", "\n", "**Wichtig** ist bei Bildern, dass der Pfad stimmt! ***Speichern Sie Ihre Bilder jeweils im Ordner `bilder`im gleichen Verzeichnis wie die Jupyterfiles, dann werden sie angezeigt. Dies bedeutet, Sie müssen jeweils nicht nur das Jupyter Notebook .jpynb-File herunterladen, sondern auch die dazugehörenden Medien.\n", "\n", "\n", "\n", "\n", "### Darstellung von Code\n", "\n", "In einem Textblock können Sie `einzelne Stellen code-ähnlich darstellen`, indem Sie das oder die entsprechenden Zeichen zwischen zwei \\` setzen.\n", "\n", "Formatierten Code grenzen Sie mit drei aufeinanderfolgenden Hochkommata \\`\\`\\` ab, gefolgt von Python oder Ihrer Sprache:\n", "\n", "```Python\n", "greeting = \"Hello World!\"\n", "print(greeting)\n", "```\n", "\n", "### Formeln\n", "\n", "Formeln in der LaTeX-Schreibweise zwischen zwei Dollarzeichen: `$(a+b)^2 = a^2 + 2ab +b^2$` erstellt Ihnen $(a+b)^2 = a^2 + 2ab +b^2$ (googeln Sie nach `latex, Formel die sie suchen, z.B. Quadrat`, wenn Sie eine Formel eingeben wollen).\n", "\n", "### Weitere Elemente\n", "\n", "Markdown bietet Ihnen noch einige weitere Möglichkeiten. Oft bringen Sie eine Websuche oder dieses empfehlenswerte [Cheatsheet](https://guides.github.com/pdfs/markdown-cheatsheet-online.pdf) von den GitHub Guides schnell ans Ziel." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Codezellen\n", "\n", "Der Code steht nicht in einem zusammenhängenden Pythonscript, sondern stückweise in verschiedenen Zellen, die ausführbar ist. Was oben ausgeführt wurde, können Sie nutzen.\n", "\n", "Codezellen können Code in der angegebenen Sprache lesen und ausführen. Welche Programmiersprache verwendet wird, steht ganz rechts oben im Fenster, hier ist es **Python 3**.\n", "\n", "In der folgenden Zelle wird eine Variable `a` definiert, die gleich den Wert 5 zugewiesen bekommt.\n", "\n", "**Aufgabe 1 – Codezelle ausführen**\n", "\n", "Führen Sie die folgende Zelle aus, indem Sie bei gedrückter Umschalttaste Enter drücken (also [Shift]+[Enter]):" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = 5" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Nachdem Sie die Zelle ausgeführt haben, ist die Variable definiert und initialisiert und Sie können nun in einer anderen Zelle darauf zugreifen.\n", "\n", "**Aufgabe 2 – Was bereits ausgeführt wurde, kann genutzt werden**\n", "\n", "Schauen Sie sich die folgende Zelle an. Überlegen Sie sich, welchen Output Sie erwarten und führen Sie die Zelle aus." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Programmier-Warm-Up\n", "\n", "Nun haben Sie Jupyter etwas kennengelernt und wissen, wo Sie nachschauen können.\n", "\n", "Bevor Sie neue Programmierkonzepte kennenlernen, werden Sie nun Ihr Können etwas auffrischen.\n", "\n", "### Variablen\n", "\n", "Variablen können Sie sich als Behälter vorstellen, in dem beliebige Werte gespeichert werden können. Variablen sind nicht konstant, ihr Wert kann sich immer wieder ändern (ist *variabel*).\n", "\n", "Auf eine Variable kann erst zugegriffen werden, wenn die Variable existiert. In Python können Variablen nicht ohne Wertzuweisung deklariert werden. Sie werden also immer gleich mit einem ersten Wert initialisiert.\n", "\n", "#### Variablennamen\n", "\n", "Beachten Sie die folgenden Regeln, wenn Sie Variablennamen aussuchen:\n", "\n", "* Kleinschreibung\n", "* Sinnvolle Variablennamen tragen wesentlich zur Lesbarkeit und zum Verständnis des Codes bei.\n", "* Keine von der Sprache reservierte Ausdrücke als Variablennamen verwenden.\n", "* Sie dürfen nicht mit Zahlen oder Sonderzeichen anfangen.\n", "\n", "#### Variablenwerte verändern\n", "\n", "Häufig müssen Werte von Variablen schnell angepasst werden, wobei der neue Wert abhängig vom aktuellen Wert ist. Dazu gibt es die folgende Kurzform:\n", "\n", "```Python\n", "zahl = 10 # Variablendefinition, danach existiert die Variable und kann verändert werden.\n", "zahl += 1 # Kurzform für zahl = zahl + 1\n", "zahl -= 2 # Kurzform für zahl = zahl - 2\n", "zahl *= 3 # Kurzform für zahl = zahl * 3\n", "zahl /= 4 # Kurzform für zahl = zahl / 4\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Datentypen\n", "\n", "Sie haben die folgenden Datentypen kennengelernt:\n", "\n", "| Datentyp | Bedeutung | Beispiel | Wertebereich | \n", "| :---------- | :----------------- | :------- | :--------------------------------------------- | \n", "| **Boolean** | *Wahrheitswert* | True | {True, False} |\n", "| **Integer** | *Ganzzahl* | 5 | $\\mathbb{Z}$ |\n", "| **Float** | *Fliesskommazahl* | 1.25 | $\\mathbb{R}$ |\n", "| **String** | *Zeichenkette* | \"Hallo\" | Zeichenketten, gekennzeichnet mit \"\" oder '' |\n", "\n", "Den Datentypen abfragen können Sie mit der Funktion `type()`:\n", "\n", "```Python\n", "x = 5\n", "type(x)\n", "```\n", "liefert den Wert `int` oder mit der print-Funktion, etwas \"aufbereitet\": ``.\n", "\n", "**Aufgabe 3 – Variablen und Datentypen**\n", "\n", "Definieren Sie die Variablen `stimmts`, `jahreszahl`, `pi` und `begruessung` und weisen Sie ihnen Werte aus der Menge {3.14159265359, True, \"Guten Morgen!\", 2021} zu. Schreiben Sie dahinter je in einem Kommentar, um welchen Datentyp es sich handelt (Sie erinnern sich an die Raute `#`...).\n", "\n", "Überprüfen Sie anschliessend, ob die Variablen die erwarteten Typen aufweisen." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### EVA-Prinzip\n", "\n", "Wenn Daten verarbeitet werden, geschieht dies nach dem \"EVA-Prinzip\": Das Programm nimmt Daten entgegen (**E**ingabe, Input), verarbeitet sie (**V**erarbeitung) und gibt am Ende das Resultat, also die verarbeiteten Daten, wieder aus (**A**usgabe, Output).\n", "\n", "#### Eingabe übers Terminal\n", "\n", "Mit der Funktion `input()` können Sie Ihre Benutzerinnen und Benutzer um eine Eingabe bitten und diese einlesen. Beachten Sie dabei, dass der eingelesene Input immer als String (Zeichenkette) daherkommt. \n", "\n", "*Falls Sie einen anderen Datentypen benötigen, können Sie die Eingabe mit den Funktionen `int()` bzw. `float()` in den gewünschten Datentypen umwandeln.*\n", "\n", "Wenn Sie einen Float in einen Integer zwängen, verlieren Sie die Kommastellen:\n", "\n", "```Python\n", " zahl = int(1.9)\n", " print(zahl)\n", "```\n", "--> Ausgabe: 1\n", "\n", "Sehen Sie sich die Beispiele an:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Hier erwarten Sie einen String\n", "name = input(\"Wie heisst Du? \")\n", "print(\"Hallo\", name + \"!\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Hier erwarten Sie eine Zahl. \n", "zahl = input(\"Gib eine Zahl ein. \")\n", "# Ausgabe zum Sicherstellen, dass Sie sehen, was eingelesen wurde...\n", "print(\"Deine Zahl:\", zahl, \"ist vom Datentyp\", type(zahl))\n", "# Diese Eingabe werden Sie umwandeln müssen, denn mit einem String können Sie nicht rechnen...\n", "print(\"zahl mal 2:\", zahl * 2)\n", "\n", "# Wenn Sie Strings multiplizieren, werden diese aneinandergehängt. \n", "# Das ist hier nicht das, was Sie wollen.\n", "# Deshalb müssen Sie die Eingabe umwandeln:\n", "ganzzahl = int(input(\"Gib eine Ganzzahl ein. \"))\n", "# Ausgabe zum Sicherstellen, dass Sie sehen, was eingelesen wurde...\n", "print(\"Deine Zahl:\", ganzzahl, \"ist vom Datentyp\", type(ganzzahl))\n", "# Nun können Sie mit Ihrer Eingabe rechnen\n", "print(\"zahl mal 2 (mit Umwandlung in einen Integer):\", ganzzahl * 2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Spezialfall Boolean\n", "\n", "Es ist zwar möglich, einen Wert mit der Funktion `bool()` in einen Boolean umzuwandeln. Allerdings wird dann alles, was keinem der Werte `0`, `0.0`, `False` oder `\"\"` (kein Zeichen) entspricht, zu **True**. \n", "\n", "Da keiner dieser Werte als String eingegeben werden kann, ist es kaum möglich, eine Eingabe in einen Boolean umzuwandeln, ausser Sie wandeln die Eingabe erst in einen Integer oder Float um und dann erst in einen Boolean oder Sie bitten den User, gar nichts einzugeben und gleich mit Return zu bestätigen." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Folgende Zeilen ergeben True:\n", "print(bool(0.1))\n", "print(bool(\"Hallo\"))\n", "print(bool(75))\n", "print(bool(True))\n", "print(bool(' '))\n", "\n", "# Folgende Zeilen ergeben False:\n", "print(bool(0))\n", "print(bool(0.0))\n", "print(bool(\"\"))\n", "print(bool())\n", "print(bool(False))\n", "\n", "# Umweg über eine Umwandlung in eine Zahl\n", "print(bool(int(\"0\")))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "boolean = bool(input(\"Gib einen Boolschen Wert ein (gar nichts eingeben und gleich mit Return bestätigen für False). \"))\n", "# Ausgabe zum Sicherstellen, dass Sie sehen, was eingelesen wurde...\n", "print(\"Deine Eingabe:\", boolean, \"ist vom Datentyp\", type(boolean))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Aufgabe 4 – Ein- und Ausgabe**\n", "\n", "Fragen Sie noch nach einer Fliesskommazahl (Float) und geben Sie die erhaltenen Werte aus." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Ausgabe übers Terminal\n", "\n", "Sie erinnern sich, dass Sie mit der Funktion `print()` eine Ausgabe machen können. `print` kann beliebig viele Parameter von verschiedenen Datentypen entgegennehmen. Beim Darstellen wird jeweils ein Leerschlag zwischen zwei Ausgaben gemacht. \n", "\n", "Am Ende von `print` kommt ein Zeilenumbruch. Dieser kann mit dem Argument `end` übersteuert werden.\n", "\n", "In Python passt sich der Datentyp einer Variablen jeweils dem Wert an, der gerade in der Variablen gespeichert ist.\n", "\n", "Hier sehen Sie ein paar Beispiele, ergänzen Sie welche, wenn Sie etwas ausprobieren möchten." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": true }, "outputs": [], "source": [ "# Ein einzelner Parameter: \n", "print(\"Hallo!\")\n", "\n", "begruessung = \"Guten Morgen!\"\n", "print(begruessung)\n", "\n", "# print gibt alle möglichen Datentypen aus\n", "print(1, 2, \"drei\", True, 1.25)\n", "\n", "# Nur den Zeilenumbruch ausgeben (ergibt eine Leerzeile...)\n", "print()\n", "\n", "print (\"Hallo und\", begruessung) # beachten Sie das Leerzeichen nach und...\n", "\n", "# Zahlen von 0 bis und ohne 5 ausgeben, aber getrennt durch einen Leerschlag, statt einen Zeilenumbruch\n", "for i in range(5):\n", " print(i, end=\" \")\n", " \n", "# Warum end=\" \"? Am Ende jeder Ausgabe steht statt eines \n", "# Zeilenumbruchs ein Leerschlag. Ohne Leerschlag wäre dies:\n", "for i in range(5):\n", " print(i, end=\"\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Arithmetische Operatoren\n", "\n", "Mit Werten können Sie auch Rechnen. Python stellt Ihnen die folgenden arithmetischen Operatoren zur Verfügung:\n", "\n", "| Operator | Operation | Beispiel | Resultat | \n", "| :------: | :--------------------- | :---------- | :------------------------------------------------------- | \n", "| **+** | *Addition* | 1 + 2 = 3 | Summe |\n", "| **-** | *Subtraktion* | 4 - 3 = 1 | Differenz |\n", "| _*_ | *Multiplikation* | 2 \\* 3 = 6 | Produkt |\n", "| **/** | *Division* | 6 / 3 = 2 | Quotient |\n", "| **//** | *ganzzahlige Division* | 7 // 3 = 2 | Quotient (nur ganzzahliger Teil, keine Nachkommastellen) |\n", "| **%** | *Modulo* | 7 % 3 = 1 | Rest einer Division |\n", "| _**_ | *Potenz* | 2 ** 3 = 8 | Potenzwert |" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Funktionen\n", "\n", "Funktionen dienen dazu, eigene Befehle zu erstellen. Sie geben Ihrem Code Struktur und machen ihn auch einfacher wartbar. Sobald Sie denselben Codeblock mehrmals erstellen, lohnt es sich, diesen in einer Funktion zusammenzufassen.\n", "\n", "#### Funktionen ohne Parameter\n", "\n", "Funktionen müssen nicht zwingend Parameter entgegennehmen.\n", "\n", "##### Funktionsdefinition\n", "\n", "```Python\n", "def funktionsname(): # Funktionskopf\n", " # Funktionskörper: Abfolge der Befehle, die mit dem Befehl zusammengefasst werden\n", "```\n", "\n", "##### Funktionsaufruf\n", "\n", "```Python\n", "funktionsname()\n", "```\n", "\n", "**Aufgabe 5 – Funktion ohne Parameter**\n", "\n", "Schreiben Sie eine Funktion `sag_hallo()`, die in der Konsole 'Hallo!' ausgibt und rufen Sie diese auf." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Funktionen mit Parameter\n", "\n", "Funktionen können auch Argumente entgegennehmen. Bei der Funktionsdefinition werden diese Parameter genannt. \n", "\n", "##### Funktionsdefinition\n", "\n", "```Python\n", "def funktionsname(parameter1, parameter2): # Funktionskopf\n", " # Funktionskörper: Abfolge der Befehle, die mit dem Befehl zusammengefasst werden\n", "```\n", "\n", "##### Funktionsaufruf\n", "\n", "```Python\n", "funktionsname(wert_fuer_parameter1, wert_fuer_parameter2)\n", "```\n", "\n", "##### Optionale Parameter\n", "\n", "Optionale Parameter haben einen Defaultwert (Standardwert). Sie müssen beim Funktionsaufruf der Funktion nur übergeben werden, wenn der Wert anders ist als der Defaultwert.\n", "\n", "Damit bei einem Aufruf immer noch klar ist, welcher Parameter gemeint ist, sind optionale Parameter zuhinterst in der Reihenfolge der Parameter.\n", "```Python\n", "def funktionsname(parameter1, parameter2=\"Defaultwert\"): # Funktionskopf\n", " # Funktionskörper: Abfolge von Befehlen, die mit dem Befehl zusammengefasst werden\n", "```\n", "\n", "###### Funktionsaufruf\n", "\n", "```Python\n", "funktionsname(wert_fuer_parameter1)\n", "```\n", "oder\n", "\n", "```Python\n", "funktionsname(wert_fuer_parameter1, wert_fuer_parameter2)\n", "```\n", "\n", "Falls eine Funktion viele Parameter entgegennimmt, können diese beim Funktionsaufruf referenziert werden:\n", "\n", "```Python\n", "funktionsname(parameter1=wert_fuer_parameter1, parameter2=wert_fuer_parameter2)\n", "```\n", "\n", "**Aufgabe 6 – Funktion mit Parameter**\n", "\n", "Machen Sie eine Funktion `sag_hallo_persoenlich`, die einen Parameter `name` entgegennimmt und eine personalisierte Begrüssung ausgibt. Rufen Sie die Funktion mit Ihrem Namen auf." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Kontrollstrukturen\n", "\n", "Kontrollstrukturen steuern den Ablauf eines Programms. Die folgenden Verzweigungen und Wiederholungen (Schleifen) sollten Sie für die Bearbeitung der weiteren Teile kennen.\n", "\n", "#### Verzweigungen\n", "\n", "Mit Verzweigungen werden Entscheidungen abgebildet. \n", "\n", "Es wird eine Bedingung geprüft und abhängig vom Resultat dieser Bedingungsprüfung wird ein Block ausgeführt oder keiner oder ein anderen.\n", "\n", "Im **Flussdiagramm** werden Verzweigungen mit Rauten dargestellt, die zwei Ausgänge haben, einen für wahr und einen für falsch. Sie erinnern sich an das Beispiel vom ersten Programmierblock:\n", "\n", "\n", "\n", "Verzweigungen können\n", "\n", "* **einseitig** (nur `if`):\n", " ```Python\n", " if Bedingung:\n", " # Körper 1 (wird ausgeführt, wenn die Bedingung auf True auflöst)\n", " ```\n", " Nach erfolgter Prüfung der `Bedingung` wird der Block `Körper 1` ausgeführt, falls die `Bedingung` auf `True` auflöst.\n", "* **zweiseitig** (`if` ... `else`)\n", " :\n", " ```Python\n", " if Bedingung:\n", " # Körper 1 (wird ausgeführt, wenn die Bedingung auf True auflöst)\n", " else:\n", " # Körper 2 (wird ausgeführt, wenn die Bedingung nicht auf True auflöst)\n", " ```\n", " Nach erfolgter Prüfung der `Bedingung` wird der Block `Körper 1` ausgeführt, falls die `Bedingung` auf `True` auflöst, ansonsten wird der Block `Körper 2` ausgeführt.\n", "* oder **mehrstufig** (`if` ... `elif` ... `else`)\n", " ```Python\n", " if Bedingung1:\n", " # Körper 1 (wird ausgeführt, wenn die Bedingung1 auf True auflöst)\n", " elif Bedingung2:\n", " # Körper 2 (wird ausgeführt, wenn die Bedingung2 auf True auflöst)\n", " else:\n", " # Körper 3 (wird ausgeführt, wenn weder die Bedingung1 noch die Bedingung2 auf True auflöst)\n", " ```\n", " Nach erfolgter Prüfung der `Bedingung1` wird der Block `Körper 1` ausgeführt, falls die `Bedingung` auf `True` auflöst. Falls die `Bedingung1` auf `False` auflöst, wird die `Bedingung2` geprüft und der Block `Körper 2` ausgeführt, falls die `Bedingung2` auf `True` auflöst. Ansonsten wird der Block `Körper 3` ausgeführt.\n", "sein.\n", "\n", "Auch mehrere **elif**-Blöcke sind erlaubt sowie verschachtelte Bedingungen.\n", "\n", "```Python\n", "if Bedingung:\n", " if Bedingung1:\n", " # Körper 1 (wird ausgeführt, wenn die Bedingung1 auf True auflöst)\n", " elif Bedingung2:\n", " # Körper 2 (wird ausgeführt, wenn die Bedingung2 auf True auflöst)\n", " else:\n", " # Körper 3 (wird ausgeführt, wenn weder die Bedingung1 noch die Bedingung2 auf True auflöst)\n", "else:\n", " # Körper 4 (wird ausgeführt, wenn die Bedingung nicht auf True auflöst)\n", "```\n", "\n", "##### Bedingungsprüfung\n", "\n", "Die Bedingung ist eine logische Aussage. Sie liefert `True` oder `False` zurück. Bedingungsprüfungen enthalten relationale oder logische Operatoren:\n", "\n", "###### Relationale Operatoren\n", "\n", "Relationale Operatoren dienen dem Vergleich von Werten:\n", "\n", "| Operator | Bedeutung | Beispiel | Löst nach True auf, wenn... | \n", "| :------: | :----------------- | :------- | :-------------------------- | \n", "| **<** | *kleiner als* | a < b | a kleiner ist als b. | \n", "| **<=** | *kleiner gleich* | a <= b | a kleiner gleich b ist. |\n", "| **>** | *grösser als* | a > b | a grösser ist als b. |\n", "| **>=** | *grösser gleich* | a >= b | a grösser gleich b ist. |\n", "| **==** | *gleich* | a == b | a und b gleich sind. |\n", "| **!=** | *ungleich* | a != b | a und b nicht gleich sind. |\n", "\n", "**Aufgabe 7 – Relationale Operatoren**\n", "\n", "Definieren Sie zwei Variablen `a` und `b` und vergleichen Sie sie. Beobachten Sie, ob der Vergleich jeweils das Resultat (`True` oder `False`) liefert, das Sie erwarten." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "###### Logische Operatoren \n", "\n", "Logische Operatoren dienen der Negation bzw. der Verknüpfung von Bedingungen.\n", "\n", "| Operator | Bedeutung | Beispiel | Löst nach True auf, wenn... |\n", "| :------: | :-------------------- | :---------- | :------- |\n", "| **not** | *Negation* | **not** A | die Bedingung A auf False auflöst |\n", "| **and** | *logisches und (AND)* | A **and** B | beide Bedingungen, A *und* B, auf True auflösen |\n", "| **or** | *logisches oder (OR)* | A **or** B | mindestens eine Bedingung A oder B nach True auflöst. |\n", "\n", "**Aufgabe 8 – Logische Operatoren**\n", "\n", "Beobachten Sie, was herauskommt, wenn Sie die beiden Variablen `something_false` und `something_true` mit den logischen Operatoren **and** und **or** verknüpfen oder **not** darauf anwenden." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "something_true = True\n", "something_false = False\n", "\n", "# Beispiel And:\n", "print(something_true and something_true)\n", "print(something_true and something_false)\n", "print(something_false and something_false)\n", "\n", "# Ihr Code..." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Aufgabe 9 – Verzweigungen**\n", "\n", "Im Kontext der logischen Operatoren haben Sie auch die Funktion Modulo kennengelernt. Sie gibt den Rest einer Division zurück.\n", "\n", "Schreiben Sie ein Programm, das den Benutzer/die Benutzerin nach einer Zahl fragt und ausgibt, ob die Zahl gerade ist oder nicht." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code..." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Schleifen\n", "\n", "Mit Schleifen können Sie Programmblöcke so oft ausführen wie nötig. In Python haben Sie dabei zwei Möglichkeiten, for-Schleifen und while-Schleifen.\n", "\n", "##### While-Schleifen\n", "\n", "While-Schleifen sind *kopfgesteuerte* Schleifen. Sie werden solange ausgeführt wie die Bedingung im Schleifenkopf erfüllt ist.\n", "\n", "```Python\n", "while Bedingung: # Schleifenkopf\n", " # Schleifenkörper\n", "```\n", "\n", "Falls Sie eine Zählvariable haben, müssen Sie diese am Ende der Schleife anpassen.\n", "\n", "**Beispiel**\n", "\n", "```Python\n", "zaehler = 1\n", "while zaehler <= 3:\n", " print(\"Durchgang\", zaehler)\n", " zaehler += 1 # Kurzform für zaehler = zaehler + 1\n", "```\n", "\n", "--> Ausgabe: \n", "Durchgang 1 \n", "Durchgang 2 \n", "Durchgang 3\n", "\n", "*Passen Sie bei While-Schleifen immer auf, dass Sie **keine Endlosschleifen** machen.*\n", "\n", "Im **Flussdiagramm** werden While-Schleifen mit einer Verbindung dargestellt, die weiter oben wieder ansetzt. Sie erinnern sich an das Beispiel vom ersten Programmierblock:\n", "\n", "\n", "\n", "##### For-Schleifen\n", "\n", "For-Schleifen sind *zählergesteuerte* Schleifen. Sie verwenden eine Laufvariable, die Werte aus einem Bereich annimmt. Wenn dieser fertig durchlaufen ist, wird die Schleife wieder verlassen.\n", "\n", "* For-Schleifen sind folgendermassen aufgebaut:\n", " ```Python\n", " for i in range(a, b, c): # Schleifenkopf\n", " # Schleifenkörper\n", " ```\n", "\n", " * i: Laufvariable, nimmt ganzzahlige Werte aus dem halboffenen Bereich \\[a, b) an, d. h. von a *bis und ohne* b\n", " * c: ist die Schrittweite. \n", " Sie hat einen Defaultwert von 1. Wenn Sie nichts angeben, wird die Laufvariable bei jedem Durchgang um 1 erhöht.\n", " * Wenn Sie für den Bereich nur einen Wert angeben, z. B. `for i in range (5)`, ist der untere Rand des Bereichs 0, der Bereich geht also automatisch **von 0** bis und ohne 5.\n", "\n", "\n", "\n", "\n", "* Sie können die Laufvariable auch über eine **Liste** laufen lassen...\n", "\n", " ```Python\n", " for i in [2, 4, 6, 8, 10]:\n", " print(i, end=\" \")\n", " ```\n", " --> Ausgabe: 2 4 6 8 10 \n", "\n", "* ... oder über einen **String**:\n", "\n", " ```Python\n", " for i in \"Hallo\":\n", " print(i, end=\" \")\n", " ```\n", " --> Ausgabe: H a l l o \n", "\n", "\n", "\n", "In anderen Sprachen gibt es auch noch fussgesteuerte Schleifen, die solange ausgeführt werden wie eine Bedingung nicht erfüllt ist.\n", "\n", "\n", "##### Abbruch\n", "\n", "Blöcke können jederzeit mit `break` verlassen werden. Das Programm geht in diesem Fall nach dem Block weiter.\n", "\n", "```Python\n", "for i in range(10):\n", " if i > 5:\n", " break\n", " print(i) \n", "```\n", "\n", "**Aufgabe 10 – Schleifen**\n", "\n", "Geben Sie zweimal die Zahlen von 1 bis 10 hintereinander aus (ohne Zeilenumbruch). Verwenden Sie dazu einmal eine for-Schleife und einmal eine While-Schleife.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihr Code... " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Fehlermeldungen\n", "\n", "Sie haben den Unterschied zwischen syntaktischen und semantischen Fehlern kennengelernt. \n", "\n", "Zur Erinnerung: \n", "\n", "* Syntaktische Fehler sind *grammatikalische* Fehler, Fehler in der Syntax. Sie werden vom Compiler entdeckt.\n", "* Semantische Fehler sind *logische* Fehler: Das Programm läuft zwar, macht aber nicht das, was gewollt ist.\n", "\n", "Es gibt für einige Syntaxfehler präzisere Fehlermeldungen:\n", "die vom Compiler präzisiert werden,\n", "\n", "#### Fehlermeldungen\n", "\n", "Bisher haben Sie mit Tigerjython programmiert, wo Sie auf die Schule zugeschnittene Fehlermeldungen bekommen haben. Nun arbeiten Sie in einer Profiumgebung. Die Fehlermeldungen sind nicht mehr übersetzt und weniger verständlich.\n", "\n", "Deshalb werden Sie hier die wichtigsten Fehlermeldungen provozieren und kennenlernen.\n", "\n", "Hier schon einmal eine Übersicht:\n", "\n", "\n", "\n", "| Fehlermeldung | Art des Problems | Problem | \n", "| :-------------------- | :-------------------- | :--------------------------------------------------- | \n", "| **SyntaxError** | *Syntaxfehler* | Grammatikfehler, meistens offensichtlich |\n", "| **NameError** | *Zugriff auf ein unbekanntes Element* | Element nicht deklariert oder falsch geschrieben |\n", "| **IndentationError** | *Einrückung* | Zeile oder Block nicht oder falsch eingerückt |\n", "| **TypeError** | *Fehlerhafter Datentyp* | Wenn Sie beispielsweise mit Strings rechnen wollen | \n", "| **ZeroDivisionError** | *Division durch Null* | Keine gute Idee (verboten wie in der Mathematik) |\n", "\n", "**Aufgabe 11 – Fehlermeldungen in Python**\n", "\n", "Sie werden hier einige fehlerhafte Codestücke sehen. \n", "* Suchen Sie jeweils den Fehler,\n", "* überlegen Sie, welche der Fehlermeldungen provoziert wird,\n", "* führen Sie den fehlerhaften Code aus und schauen Sie sich die Fehlermeldung an. \n", "* Korrigieren Sie den Fehler und überprüfen Sie, ob Sie richtig lagen.\n", "\n", "a) \n", "```Python\n", " print(haerzchaeferli)\n", "```\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(haerzchaeferli)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihre Lösung" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "b)\n", "```Python\n", "a = 4\n", "b = 5\n", "\n", "if a < b\n", " print(\"a < b\")\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = 4\n", "b = 5\n", "\n", "if a < b\n", " print(\"a < b\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihre Lösung" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "c)\n", "\n", "```Python\n", "for i in range(1, 5):\n", "print(i)\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for i in range(1, 5):\n", "print(i)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihre Lösung" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "d)\n", "\n", "```Python\n", "a = 2\n", "b = \"2\"\n", "a + b\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": true }, "outputs": [], "source": [ "a = 2\n", "b = \"2\"\n", "a + b" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihre Lösung" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "e)\n", "\n", "```Python\n", "a = 1\n", "b = 0\n", "a / b\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": true }, "outputs": [], "source": [ "a = 1\n", "b = 0\n", "a / b" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Ihre Lösung" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Quiz\n", "\n", "Alles klar? \n", "\n", "Testen Sie Ihr Verständnis anhand der Fragen, die erstellt werden, wenn Sie die folgenden Zellen gemäss Ihrer Umgebung ausführen.\n", "\n", "### NUR FALLS SIE AUF GOOGLE COLAB ARBEITEN\n", "\n", "Führen Sie bitte die **beiden** folgenden Zellen aus, um die Bibliothek für das Quiz zu laden." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# NUR falls Sie AUF GOOGLE COLAB arbeiten:\n", "# Führen Sie diese Zelle aus, um das Quiz zu sehen.\n", "\n", "%%writefile quizclone.py\n", "import os\n", "from subprocess import getoutput\n", "getoutput(\"git clone -l -s https://github.com/donze-informatikunterricht/quiz.git cloned-repo\")\n", "os.chdir('cloned-repo')\n", "print('repo cloned successfully')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# NUR falls Sie AUF GOOGLE COLAB arbeiten:\n", "# Führen Sie diese Zelle aus, um das Quiz zu sehen.\n", "\n", "import quizclone" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Quiz erstellen** (unabhängig von Ihrer Arbeitsumgebung)\n", "\n", "Nun können Sie das Quiz erstellen. Führen Sie dazu bitte die folgende Zelle aus und testen Sie, ob Sie bereit sind, den nächsten Schritt in Angriff zu nehmen.\n", "\n", "Das Quiz basiert auf dem folgenden Programm (die Zahlen links entsprechen den Zeilennummern):\n", "\n", "```Python\n", "1 a = 10\n", "2 b = 0\n", "3\n", "4 while a > 0:\n", "5 if b <= 24:\n", "6 b += a\n", "7 a -= 2\n", "8 print(a+b)\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Führen Sie diese Zelle aus, um das Quiz zu sehen.\n", "\n", "from IPython.display import display\n", "import quiz\n", "\n", "display(quiz.Q1_erste_schritte)\n", "display(quiz.Q2_erste_schritte)\n", "display(quiz.Q3_erste_schritte)\n", "display(quiz.Q4_erste_schritte)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.8" } }, "nbformat": 4, "nbformat_minor": 4 }