From 6868734b92f22a26bd20960af67e1036e84dab2b Mon Sep 17 00:00:00 2001 From: paulusja Date: Thu, 10 Mar 2022 17:01:39 +0100 Subject: [PATCH] Add chapter 05. --- 05kapitel/051 Module.ipynb | 277 +++++++++++++++++++++++++++++ 05kapitel/052 Turtle.ipynb | 265 +++++++++++++++++++++++++++ 05kapitel/052a Uebung Turtle.ipynb | 220 +++++++++++++++++++++++ 05kapitel/053 Package.ipynb | 191 ++++++++++++++++++++ 05kapitel/rise.css | 22 +++ 5 files changed, 975 insertions(+) create mode 100644 05kapitel/051 Module.ipynb create mode 100644 05kapitel/052 Turtle.ipynb create mode 100644 05kapitel/052a Uebung Turtle.ipynb create mode 100644 05kapitel/053 Package.ipynb create mode 100644 05kapitel/rise.css diff --git a/05kapitel/051 Module.ipynb b/05kapitel/051 Module.ipynb new file mode 100644 index 0000000..9c69983 --- /dev/null +++ b/05kapitel/051 Module.ipynb @@ -0,0 +1,277 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Software Entwicklung \n", + "\n", + "## Kapitel 5: Module und Pakete\n", + "\n", + "Die Sichtbarkeit von programmiersprachlichen Objekten wie Funktionen oder globalen Variablen\n", + "ist bei Python auf die jeweilige Programmdatei beschränkt. Eine solche Python-Datei wird auch als\n", + "*Modul* bezeichnet. Sie spannt einen *Namensraum* auf, d.h. innerhalb des Moduls existieren (globale)\n", + "Bezeichner nur einmal; außerhalb der Datei in anderen Modulen können Funktionen etc. gleichen\n", + "Namens existieren, ohne dass es zu Konflikten kommt." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Python bietet jedoch die Möglichkeit, größere Programme auf mehrere Module aufzuteilen und\n", + "so die damit verbundene Komplexität beherrschbar zu gestalten. Typischerweise stützt sich dabei ein\n", + "*Top-Level-Modul* auf weitere nachgeordnete Module, die z.B. Funktionen oder\n", + "Datentypen definieren und bereitstellen.\n", + "\n", + "![Module](../img/module.png \"Module\")\n", + "\n", + "Python selbst liefert bereits eine Reihe von Modulen mit aus, die die Möglichkeiten der Sprache \n", + "erweitern. Die Summe aller mitgelieferten Module wird als *Standard-Bibliothek* bezeichnet.\n", + "\n", + "Die Standard-Bibliothek ist so umfangreich, dass eine vollumfängliche Behandlung bereits im Ansatz\n", + "zum Scheitern verurteilt wäre. Im Folgenden werden lediglich ausgewählte Module als Beispiel\n", + "aufgeführt. Eine vollständige Übersicht bietet die offizielle\n", + "[Dokumentation](https://docs.python.org/3/library/)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### 5.1 Import von Modulen\n", + "\n", + "Da die Sichtbarkeit von programmiersprachlichen Objekten normalerweise an der Dateigrenze endet,\n", + "müssen die nachgeordneten Module in das übergeordnete Modul *importiert* werden. Sollen\n", + "Beispielsweise Funktionen des Standard-Moduls math verwendet werden,\n", + "so können diese folgendermaßen zugänglich gemacht werden." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import math\n", + "\n", + "zahl = float(input(\"Zahl: \"))\n", + "wurzel = math.sqrt(zahl)\n", + "print(f\"Die Wurzel von {zahl} ist {wurzel}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Um Konflikte bei gleichnamigen Objekten zu vermeiden, muss für den Zugriff in diesem Fall stets der\n", + "komplette Pfad zum importierten Objekt angegeben werden. Alle im Modul definierten Funktionen\n", + "sind so zugänglich. Im Falle von math sind dies die wesentlichen mathematischen Funktionen\n", + "wie z.B.\n", + "\n", + "* Sinus sin\n", + "* Cosinus cos\n", + "* Exponentialfunktion exp\n", + "* Logarithmus log\n", + "* Wurzel sqrt" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "sowie einige mathematische Konstante wie z.B.\n", + "\n", + "* pi\n", + "* e" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + }, + "slideshow": { + "slide_type": "-" + } + }, + "outputs": [], + "source": [ + "import math\n", + "\n", + "print(math.cos(math.pi))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Beim Import kann dem Modul auch ein abweichender Name gegeben werden, um z.B. lange\n", + "Modulnamen abzukürzen. Im nachfolgenden Beispiel das Modul datetime unter dem\n", + "neuen Namen dt importiert und anschließend der im Modul definierte Datentyp\n", + "date verwendet, der die Funktion today bereitstellt." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import datetime as dt\n", + "\n", + "print(dt.date.today())\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### 5.2 Einbinden von Modulinhalten\n", + "\n", + "Neben dem Importieren von fremden Modulen können deren Inhalte auch selektiv mittels\n", + "\n", + "from \\< module \\> import \\< Bezeichner \\> \n", + "\n", + "in den eigenen Namensraum eingebunden werden. Die Angabe eines vollständigen Pfads entfällt dann." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "from math import sin, pi\n", + "\n", + "print(sin(pi))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Bei dieser Art der Einbindung können die eingebundenen Objekte umbenannt werden." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "from math import sin as sinus, pi\n", + "\n", + "print(sinus(pi))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + }, + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Bei der Einbettung in den eigenen Adressraum kann es zu Konflikten mit im eigenen Modul definierten\n", + "Funktionen o.ä. kommen. Da Python Module beim Importieren ausführt und die darin enthaltenen Definitionen \n", + "verarbeitet, können die so definierten Bezeichner durch eine erneute Definition verändert werden." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "from math import sin\n", + "\n", + "def sin(x):\n", + " return x\n", + "\n", + "#from math import sin\n", + "\n", + "print(sin(1))" + ] + } + ], + "metadata": { + "celltoolbar": "Slideshow", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.9" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/05kapitel/052 Turtle.ipynb b/05kapitel/052 Turtle.ipynb new file mode 100644 index 0000000..fc1b6c1 --- /dev/null +++ b/05kapitel/052 Turtle.ipynb @@ -0,0 +1,265 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Software Entwicklung \n", + "\n", + "## Kapitel 5: Module und Pakete\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5.2 Turtle-Grafik\n", + "\n", + "Ein im Standard enthaltenes Modul ist turtle, mit dessen Hilfe sich einfache Grafiken erzeugen lassen.\n", + "Dazu stellt das Modul einen Zeichenstift *Turtle* zur Verfügung, der mit einfachen Befehlen wie forward,\n", + "left, right, ... über den Bildschirm bewegt werden kann." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "In reduzierter Form steht ein solches Modul auch für Jupyter Notebooks zur Verfügung, das nachfolgend\n", + "Verwendung findet. Es heißt ipyturtle." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "from ipyturtle import Turtle\n", + "\n", + "turtle = Turtle(width=400, height=400)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Damit das Grafikfeld im Browser angezeigt wird, muss turtle einmal als Ergebnis einer\n", + "Zelle an das Jupyter Notebook zurückgegeben werden. Im Folienmodus \"hängt\" das Grafikfeld dann leider an der aufrufenden Folien fest." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "turtle" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Anschließend kann der Zeichenstift bewegt werden. Er erzeugt dabei eine Linie." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "turtle.forward(100)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Richtungsänderungen sind mit left und right möglich.\n", + "Die Drehung wird in Grad angegeben." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "turtle.left(90)\n", + "turtle.forward(20)\n", + "turtle.right(45)\n", + "turtle.back(50)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Mit Hilfe von reset kann die Ausgabe gelöscht und der Zeichenstift in die Mitte gesetzt\n", + "werden." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "turtle.reset()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + }, + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Durch das Heben und Senken des Stifts ist es möglich, Bewegungen auszuführen,\n", + "ohne eine Linie zu hinterlassen." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "for i in range(10):\n", + " if i%2 == 0:\n", + " turtle.pendown()\n", + " else:\n", + " turtle.penup()\n", + " turtle.forward(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Die Positon und die Ausrichtung des Stifts kann jederzeit abgefragt werden." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "turtle.reset()\n", + "print(turtle.position())\n", + "print(turtle.heading())\n", + "turtle.right(90)\n", + "print(turtle.heading())\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Und schließlich: durch Angabe eines RGB-Wertes kann die Farbe des Stifts gesetzt werden." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "turtle.reset()\n", + "r = 0\n", + "g = 0\n", + "b = 255\n", + "turtle.pencolor(r, g, b)\n", + "turtle.forward(100)" + ] + } + ], + "metadata": { + "celltoolbar": "Slideshow", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.9" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/05kapitel/052a Uebung Turtle.ipynb b/05kapitel/052a Uebung Turtle.ipynb new file mode 100644 index 0000000..0b54e59 --- /dev/null +++ b/05kapitel/052a Uebung Turtle.ipynb @@ -0,0 +1,220 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Software Entwicklung \n", + "\n", + "## Kapitel 5: Module und Pakete\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### 5.3 Beispiel für eine Turtle-Grafik\n", + "\n", + "Unsere Aufgabe ist es, ein Programm zu erstellen, das den \"Baum des Pytagoras\" ausgibt.\n", + "\n", + "![Baum des Pytagoras](../img/BaumPytagoras.png \"Baum des Pytagoras\")\n", + "\n", + "Dazu erzeugen wir uns zunächst ein Ausgabefeld der Größe 400x400 und zeigen es an." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + }, + "slideshow": { + "slide_type": "slide" + } + }, + "outputs": [], + "source": [ + "from ipyturtle import Turtle\n", + "turtle = Turtle(width=400, height=400)\n", + "turtle" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Dann ist es ganz hilfreich, eine Funktion zu definieren, die an der aktuellen Stiftposition\n", + "ein Quadrat vorgegebener Größe zeichnet." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "def quadrat(seite):\n", + " for _ in range(4):\n", + " turtle.forward(seite)\n", + " turtle.right(90)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Die Verästelung des Baums erfolgt ja immer in Form eines rechtwinkligen Dreiecks. Wir bereiten\n", + "eine Funktion vor, mit deren Hilfe sich aus der Größe des Hauptastes die Größe der Teiläste\n", + "berechnen lässt." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import math\n", + "\n", + "def teilast(hauptast):\n", + " return math.sqrt(hauptast * hauptast / 2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Nun können wir eine rekursive Funktion definieren, die den Baum zeichnet." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "def baum(seite):\n", + " if seite < 10:\n", + " return\n", + " # Stamm\n", + " quadrat(seite)\n", + " ast = teilast(seite)\n", + " # linker Ast\n", + " turtle.penup()\n", + " turtle.forward(seite)\n", + " turtle.left(45)\n", + " turtle.pendown()\n", + " baum(ast)\n", + " # rechter Ast\n", + " turtle.penup()\n", + " turtle.right(90)\n", + " turtle.forward(ast)\n", + " turtle.pendown()\n", + " baum(ast)\n", + " #zurück zum Ausgangspunkt beim Stamm\n", + " turtle.penup()\n", + " turtle.back(ast)\n", + " turtle.left(45)\n", + " turtle.back(seite)\n", + " turtle.pendown()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Jetzt können wir den Stift an den unteren Rand bewegen und den Baum zeichnen." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "turtle.reset()\n", + "turtle.penup()\n", + "turtle.back(180)\n", + "turtle.left(90)\n", + "turtle.forward(50)\n", + "turtle.right(90)\n", + "turtle.pendown()\n", + "baum(70)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Schön, oder?\n" + ] + } + ], + "metadata": { + "celltoolbar": "Slideshow", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.9" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/05kapitel/053 Package.ipynb b/05kapitel/053 Package.ipynb new file mode 100644 index 0000000..a2d4d2e --- /dev/null +++ b/05kapitel/053 Package.ipynb @@ -0,0 +1,191 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Software Entwicklung \n", + "\n", + "## Kapitel 5: Module und Pakete" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### 5.4 Eigene Module\n", + "\n", + "Natürlich ist es auch mögliche, selbst Module zu entwickeln und diese zu importieren. Genau genommen\n", + "ist jede Python-Quellcodedatei ein eigenes Modul. Die darin enthaltenen globalen Objekte\n", + "(insbesondere Funktionen) können mittels import in anderen Quellcodedateien\n", + "zugänglich gemacht werden.\n", + "\n", + "![Import eigener Module](../img/import.png \"Import eigener Module\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Der Name des Moduls beim Import entspricht dem Dateinamen der Python-Quellcodedatei. Gefunden\n", + "werden auf diese Weise Quellcodedateien, die im gleichen Verzeichnis liegen oder in einem der\n", + "beim Python-Interpreter hinterlegten Modulverzeichnisse.\n", + "\n", + "Vorsicht: Sollte das eigene Modul den gleichen Namen beitzen wie ein Standardmodul, so wird\n", + "das Standardmodul gefunden und importiert!\n", + "\n", + "\n", + "Der Name eines Moduls kann im übrigen mit der *Special Variable* \\_\\_name\\_\\_ ermittelt\n", + "werden." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "print(__name__)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Mit Hilfe der Variable \\_\\_name\\_\\_ kann festgestellt werden, ob die Quellcodedatei \n", + "gerade ausgeführt wird, \n", + "\n", + "* weil sie direkt gestartet wurde und das Top-Level-Modul ist - in diesem Fall enthält die\n", + " Variable den String \"\\_\\_main\\_\\_\"\n", + "* weil sie in ein anderes Modul importiert wird - in diesem Fall enthält die Variable \n", + " den Modulnamen, wie er beim Importstatement angegeben ist" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Durch diese Unterscheidung ist es möglich, Module mit Test- oder Beispielcode zu versehen, der\n", + "nicht ausgeführt wird, wenn die Quellcodedatei importiert wird. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# Definition einer Funktion, die von anderen importiert werden soll\n", + "def f():\n", + " return 17\n", + "\n", + "# Testcode, der nur ausgeführt werden soll, wenn das Modul direkt ausgeführt wird\n", + "if __name__ == \"__main__\":\n", + " if f() != 17:\n", + " print(\"Fehler!\")\n", + " else:\n", + " print(\"Alles ok!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### 5.5 Packages\n", + "\n", + "*Packages* dienen dazu, mehrere Module zusammenzufassen und in strukturierter Form\n", + "importieren zu können. Python enthält z.B. bereits im Standard das Package http\n", + "mit den darin enthaltenen Standardmodulen http.client, http.server\n", + "und weiteren. Auf die enthaltenen Teilmodule kann beim Import mit der *Dot-Notation* zugegriffen\n", + "werden kann, z.B.:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import http.client\n", + "\n", + "connection = http.client.HTTPConnection('www.th-nuernberg.de')\n", + "connection.request(\"GET\", \"/\")\n", + "response = connection.getresponse()\n", + "print(response.status, response.reason)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Ein Package ist ein Dateisystem-Verzeichnis mit folgendem Inhalt:\n", + "\n", + "* die Python-Dateien der beinhalteten Module\n", + "* eine optionale Initialisierungsdatei __init__.py,\n", + " die beim Importieren des Packages geladen und ausgeführt wird" + ] + } + ], + "metadata": { + "celltoolbar": "Slideshow", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.9" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/05kapitel/rise.css b/05kapitel/rise.css new file mode 100644 index 0000000..c70f5af --- /dev/null +++ b/05kapitel/rise.css @@ -0,0 +1,22 @@ +body.rise-enabled div.inner_cell>div.input_area { + font-size: 150%; +} + +body.rise-enabled div.output_subarea.output_text.output_result { + font-size: 150%; +} +body.rise-enabled div.output_subarea.output_text.output_stream.output_stdout { + font-size: 150%; +} + +body.rise-enabled div.output_subarea.output_html.rendered_html.output_result { + font-size: 150%; +} + +body.rise-enabled td { + font-size: 120%; +} + +body.rise-enabled th { + font-size: 120%; +} \ No newline at end of file