Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
No results found
Show changes
Commits on Source (345)
245 additional commits have been omitted to prevent performance issues.
Hide whitespace changes
Inline Side-by-side
Showing
with 4718 additions and 507 deletions
README.org
View file @ 9a8e896d
* Seminar Problemorientierte Programmierung
Hier finden Sie die Jupyter-Notebooks für das Seminar. Die Notebooks
sind im Wesentlichen eine Übersetzung der 2. Ausgabe des Buches [[http://greenteapress.com/wp/think-python-2e/][Think
Python]] von Allen B. Downey. Es gibt das Buch auch in einer offiziellen
deutschen Übersetzung mit dem Titel /Programmieren lernen mit Python/.
Dieses Projekt enthält Jupyter-Notebooks für einen
Python-Programmierkurs. Die Notebooks sind im Wesentlichen eine
Übersetzung der 2. Ausgabe des Buches [[http://greenteapress.com/wp/think-python-2e/][Think Python]] von
Allen B. Downey. Es gibt das Buch auch in einer offiziellen deutschen
Übersetzung mit dem Titel /Programmieren lernen mit Python/.
Sie finden die Notebooks im Ordner [[file:notebooks/][notebooks]]. Sie können sich die
Notebooks hier ansehen aber nicht ausführen. Dazu müssen Sie sie
herunterladen und in Jupyter öffnen. Klicken Sie dazu auf der Seite
mit dem jeweiligen Notebook *mit der rechten Maustaste* auf den Button
"Open Raw" und speichern Sie die geöffnete Datei, indem Sie "*Ziel
speichern unter ...*" (oder "Link speichern unter ...") wählen:
[[file:img/open_raw.png]]
Notebooks hier in GitLab ansehen aber nicht ausführen. Dazu müssen Sie
sie herunterladen und in Jupyter öffnen. Klicken Sie dazu auf der
Webseite mit dem jeweiligen Notebook auf den Button "Download" und
speichern Sie es als Datei:
/(Hinweis: dies funktioniert oft nicht im Edge-Browser, verwenden Sie
also ggf. Firefox, Chrome oder Opera.)/
[[file:img/download.png]]
Alternativ können Sie auch direkt hier die Dateien herunterladen,
Alternativ können Sie die Notebooks auch direkt hier herunterladen,
indem Sie mit der rechten Maustaste auf die Links klicken und /Ziel
speichern unter.../ wählen:
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar00.ipynb][Einführung]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar01.ipynb][1: Die ersten Programme]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar02.ipynb][2: Variablen, Ausdrücke und Anweisungen]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar01.ipynb][1: Operatoren, Ausdrücke, Typen]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar02.ipynb][2: Variablen und Anweisungen]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar03.ipynb][3: Funktionen]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar03extra.ipynb][3 extra: reguläre Ausdrücke]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar04.ipynb][4: Fallstudie: Schnittstellenentwurf]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar04.ipynb][4: Turtle: Schnittstellenentwurf]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar05.ipynb][5: Verzweigungen und Rekursion]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar06.ipynb][6: Ertragreiche Funktionen]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar07.ipynb][7: Iteration]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar08.ipynb][8: Zeichenketten]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar09.ipynb][9: Fallstudie: Wortspiele]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar10.ipynb][10: Listen]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar11.ipynb][11: Assoziative Datenfelder]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar06.ipynb][6: Ertragreiche Funktionen]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar07.ipynb][7: Iteration und Suche]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar08.ipynb][8: Reguläre Ausdrücke und Zeichenketten]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar09.ipynb][9: Listen]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar10.ipynb][10: Assoziative Datenfelder]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar11.ipynb][11: Tupel]]
Merken Sie sich, wo Sie die Dateien gespeichert haben und navigieren
Sie dann mit Jupyter zu diesem Ordner, um sie zu öffnen.
[[file:img/cc-by-nc.png]] Dieses Seminar ist als freies Werk unter der
Lizenz [[http://creativecommons.org/licenses/by-nc/3.0/][Creative Commons Attribution-NonCommercial 3.0 Unported]]
verfügbar. Sie dürfen die Inhalte kopieren, verteilen und verändern,
solange Sie die Urheber nennen und sie nicht für kommerzielle Zwecke
nutzen.
[[file:img/cc-by-nc.png]] Dieser Kurs ist als freies Werk unter der Lizenz
[[http://creativecommons.org/licenses/by-nc/3.0/][Creative Commons Attribution-NonCommercial 3.0 Unported]] verfügbar. Sie
dürfen die Inhalte kopieren, verteilen und verändern, solange Sie die
Urheber nennen und sie nicht für kommerzielle Zwecke nutzen.
** Tipps zur Einrichtung von Python und Jupyter
*** Allgemeine Hinweise
- Wir werden durchgängig Python 3 nutzen. Daher bitte darauf achten,
keine alte Python-Version (2.6, 2.7, etc.) zu installieren. Am
besten mindestens Python 3.5.3 benutzen, aktuellere Versionen sind
auch ok.
- Im Kurs wird durchgängig Python 3 benutzt. Daher bitte darauf
achten, keine alte Python-Version (2.6, 2.7, etc.) zu
installieren. Am besten mindestens Python 3.5.3 benutzen, aktuellere
Versionen sind auch ok.
- Helfen Sie sich gegenseitig bei der Installation und unterstützen
Sie sich bei Problemen. Benutzen Sie auch gerne das Forum bei einem
spezifischen Problem, um Hilfe von Ihren Kommilitonen zu
erhalten. Wenn niemand helfen kann, helfen wir Ihnen!
spezifischen Problem, um Hilfe von Ihren Kommiliton*innen zu
erhalten. Wenn niemand helfen kann, helfen wir Ihnen.
*** Windows
- [[https://www.anaconda.com/distribution/]]
- [[http://technivore.org/posts/2016/02/27/windows-jupyter-three-ways.html]]
- [[https://www.anaconda.com/download]]
- [[https://technivore.org/2016/02/27/python-jupyter-windows/]]
*** Linux
- Je nach Distribution das passende Paket installieren, z.B. in Debian mittels ~apt-get install python3-notebook~.
- Anaconda enthält sowohl Jupyter Notebooks, als auch Python 3.5 oder 3.6 Kernel und einige wichtige Python-Bibliotheken wie z.B. Numpy.
- Die Python-Version 3.6 ist hier zu finden: [[https://www.anaconda.com/download/#linux]]
- Die Python-Version 3.5 hier: [[https://docs.anaconda.com/anaconda/faq#how-do-i-get-anaconda-with-python-3-5]]
- Hier Hilfestellung zur Instalation von Conda: [[https://docs.anaconda.com/anaconda/install/linux]]
- Die aktuelle Anaconda-Distribution ist hier zu finden: [[https://www.anaconda.com/download/#linux]]
- Ältere Anaconda-Distributionen finden sich hier: [[https://docs.anaconda.com/free/anaconda/reference/packages/oldpkglists/]]
- [[https://docs.anaconda.com/anaconda/install/linux][Hilfestellungen zur Installation von Conda]]
*** Mac
- Ananconda für Mac, wählen Sie Python 3.6 aus: [[https://www.anaconda.com/download/#macos]]
- Die aktuelle Anaconda-Distributon finden sich hier: [[https://www.anaconda.com/download/#macos]]
- Mac OS X Installations-Hilfe: [[https://docs.anaconda.com/anaconda/install/mac-os#macos-graphical-install]]
** Hinweise zu GitLab
Das System, auf dem Sie diese Seite gerade lesen und in dem Sie die
Notebooks finden, nennt sich *GitLab* und ist eine professionelle
Umgebung zur kollaborativen Softwareentwicklung. Hier können
Programmierer Quellcode abspeichern, Änderungen verfolgen und
Programmierer*innen Quellcode abspeichern, Änderungen verfolgen und
rückgängig machen, Fehler melden und Code dokumentieren.
Wenn Sie *Fehler* in den Jupyter-Notebooks finden oder *Hinweise zur
......@@ -93,9 +87,10 @@ der Versionsverwaltungssoftware [[https://de.wikipedia.org/wiki/Git][Git]] vertr
** Ressourcen rund um Python
- Ein freier Python-Kurs (auf Englisch), ebenfalls basierend auf
Jupyter-Notebooks: http://introtopython.org/
- Die offizielle Dokumentation für Python 3:
https://docs.python.org/3/
- Ein [[http://introtopython.org/][freier Python-Kurs]] (auf Englisch), ebenfalls basierend auf
Jupyter-Notebooks.
- Die [[https://docs.python.org/3/][offizielle Dokumentation für Python 3]].
- Eine [[https://scm.cms.hu-berlin.de/ibi/notebooks][Sammlung interessanter Notebooks]] mit vielen Beispielen.
# https://github.com/jupyter/jupyter/wiki/A-gallery-of-interesting-Jupyter-Notebooks
img/aufrufdiagramm_fib.svg 0 → 100644
View file @ 9a8e896d
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->
<svg
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:cc="http://creativecommons.org/ns#"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:svg="http://www.w3.org/2000/svg"
xmlns="http://www.w3.org/2000/svg"
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
width="297.73431mm"
height="201.82164mm"
viewBox="0 0 297.73431 201.82164"
version="1.1"
id="svg8"
inkscape:version="0.92.2 5c3e80d, 2017-08-06"
sodipodi:docname="fibonacci.svg">
<defs
id="defs2">
<marker
inkscape:isstock="true"
style="overflow:visible"
id="marker5438"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="Arrow2Lend">
<path
transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
id="path5436"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:isstock="true"
style="overflow:visible"
id="marker5286"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="Arrow2Lend">
<path
transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
id="path5284"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:isstock="true"
style="overflow:visible"
id="marker5142"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="Arrow2Lend">
<path
transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
id="path5140"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:isstock="true"
style="overflow:visible"
id="marker5006"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="Arrow2Lend">
<path
transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
id="path5004"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:isstock="true"
style="overflow:visible"
id="marker4856"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="Arrow2Lend">
<path
transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
id="path4854"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:isstock="true"
style="overflow:visible"
id="marker4306"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="Arrow2Lend">
<path
transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
id="path4304"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:isstock="true"
style="overflow:visible"
id="marker4034"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="Arrow2Lend">
<path
transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
id="path4032"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:stockid="Arrow2Lstart"
orient="auto"
refY="0"
refX="0"
id="marker3887"
style="overflow:visible"
inkscape:isstock="true">
<path
id="path3885"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
transform="matrix(1.1,0,0,1.1,1.1,0)"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:isstock="true"
style="overflow:visible"
id="marker3519"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="Arrow2Lstart"
inkscape:collect="always">
<path
transform="matrix(1.1,0,0,1.1,1.1,0)"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
id="path3517"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:stockid="Arrow2Lstart"
orient="auto"
refY="0"
refX="0"
id="marker3257"
style="overflow:visible"
inkscape:isstock="true">
<path
id="path3255"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
transform="matrix(1.1,0,0,1.1,1.1,0)"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:isstock="true"
style="overflow:visible"
id="marker3141"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="Arrow2Lstart"
inkscape:collect="always">
<path
transform="matrix(1.1,0,0,1.1,1.1,0)"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
id="path3139"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:stockid="Arrow2Lstart"
orient="auto"
refY="0"
refX="0"
id="marker2905"
style="overflow:visible"
inkscape:isstock="true"
inkscape:collect="always">
<path
id="path2903"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
transform="matrix(1.1,0,0,1.1,1.1,0)"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:isstock="true"
style="overflow:visible"
id="marker2477"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="Arrow2Lstart"
inkscape:collect="always">
<path
transform="matrix(1.1,0,0,1.1,1.1,0)"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
id="path2475"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:stockid="Arrow2Lend"
orient="auto"
refY="0"
refX="0"
id="marker2189"
style="overflow:visible"
inkscape:isstock="true"
inkscape:collect="always">
<path
id="path2187"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:stockid="Arrow2Lend"
orient="auto"
refY="0"
refX="0"
id="marker2077"
style="overflow:visible"
inkscape:isstock="true">
<path
id="path2075"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:stockid="Arrow2Lend"
orient="auto"
refY="0"
refX="0"
id="marker1935"
style="overflow:visible"
inkscape:isstock="true"
inkscape:collect="always">
<path
id="path1933"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:stockid="Arrow1Lend"
orient="auto"
refY="0"
refX="0"
id="Arrow1Lend"
style="overflow:visible"
inkscape:isstock="true">
<path
id="path850"
d="M 0,0 5,-5 -12.5,0 5,5 Z"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1"
transform="matrix(-0.8,0,0,-0.8,-10,0)"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:isstock="true"
style="overflow:visible"
id="marker1833"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="Arrow2Lstart">
<path
transform="matrix(1.1,0,0,1.1,1.1,0)"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
id="path1831"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:stockid="Arrow2Lstart"
orient="auto"
refY="0"
refX="0"
id="marker1461"
style="overflow:visible"
inkscape:isstock="true"
inkscape:collect="always">
<path
id="path1459"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
transform="matrix(1.1,0,0,1.1,1.1,0)"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:isstock="true"
style="overflow:visible"
id="marker1197"
refX="0"
refY="0"
orient="auto"
inkscape:stockid="Arrow2Lstart"
inkscape:collect="always">
<path
transform="matrix(1.1,0,0,1.1,1.1,0)"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
id="path1195"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:stockid="Arrow2Lstart"
orient="auto"
refY="0"
refX="0"
id="Arrow2Lstart"
style="overflow:visible"
inkscape:isstock="true"
inkscape:collect="always">
<path
id="path865"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
transform="matrix(1.1,0,0,1.1,1.1,0)"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:stockid="Arrow2Lend"
orient="auto"
refY="0"
refX="0"
id="Arrow2Lend"
style="overflow:visible"
inkscape:isstock="true">
<path
id="path868"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
inkscape:connector-curvature="0" />
</marker>
</defs>
<sodipodi:namedview
id="base"
pagecolor="#ffffff"
bordercolor="#666666"
borderopacity="1.0"
inkscape:pageopacity="0.0"
inkscape:pageshadow="2"
inkscape:zoom="0.40441389"
inkscape:cx="213.88593"
inkscape:cy="337.09792"
inkscape:document-units="mm"
inkscape:current-layer="layer1"
showgrid="false"
showguides="true"
inkscape:guide-bbox="true"
inkscape:window-width="1440"
inkscape:window-height="855"
inkscape:window-x="0"
inkscape:window-y="1"
inkscape:window-maximized="1"
fit-margin-top="0"
fit-margin-left="0"
fit-margin-right="0"
fit-margin-bottom="0" />
<metadata
id="metadata5">
<rdf:RDF>
<cc:Work
rdf:about="">
<dc:format>image/svg+xml</dc:format>
<dc:type
rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
<dc:title></dc:title>
</cc:Work>
</rdf:RDF>
</metadata>
<g
inkscape:label="Ebene 1"
inkscape:groupmode="layer"
id="layer1"
transform="translate(77.937001,-33.119358)">
<path
transform="scale(1,-1)"
style="fill:#e6e6e6;stroke:#000000;stroke-width:0.65399998;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
d="m 60.326996,-66.754768 h 52.738314 v 33.30841 H 60.326996 Z"
id="rect10"
inkscape:connector-curvature="0" />
<text
xml:space="preserve"
style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
x="63.257065"
y="47.506409"
id="text14"><tspan
sodipodi:role="line"
id="tspan12"
x="63.257065"
y="47.506409"
style="stroke-width:0.26458332">fibonacci</tspan><tspan
sodipodi:role="line"
x="63.257065"
y="60.735577"
style="stroke-width:0.26458332"
id="tspan16">n 4</tspan></text>
<path
style="fill:none;stroke:#000000;stroke-width:0.57200003;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#Arrow2Lstart)"
d="M 97.851679,57.475155 H 74.607766"
id="path845"
inkscape:connector-curvature="0" />
<g
id="g2014"
transform="translate(-50.094519,-17.664453)">
<rect
style="fill:#e6e6e6;stroke:#000000;stroke-width:0.65399998;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
id="rect1179"
width="52.738316"
height="33.308411"
x="42.296612"
y="-140.31084"
transform="scale(1,-1)"
ry="0" />
<text
xml:space="preserve"
style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
x="45.215004"
y="121.06248"
id="text1185"><tspan
sodipodi:role="line"
id="tspan1181"
x="45.215004"
y="121.06248"
style="stroke-width:0.26458332">fibonacci</tspan><tspan
id="tspan1439"
sodipodi:role="line"
x="45.215004"
y="134.29164"
style="stroke-width:0.26458332">n 3</tspan></text>
<path
style="fill:none;stroke:#000000;stroke-width:0.57200003;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#marker1197)"
d="M 79.809619,131.07509 H 56.565706"
id="path1193"
inkscape:connector-curvature="0" />
</g>
<g
id="g2063"
transform="translate(10.263668,-20.281412)">
<rect
transform="scale(1,-1)"
y="-142.9278"
x="118.18833"
height="33.308411"
width="52.738316"
id="rect1443"
style="fill:#e6e6e6;stroke:#000000;stroke-width:0.65399998;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
<text
id="text1449"
y="123.02519"
x="121.10673"
style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
xml:space="preserve"><tspan
style="stroke-width:0.26458332"
y="123.02519"
x="121.10673"
id="tspan1445"
sodipodi:role="line">fibonacci</tspan><tspan
style="stroke-width:0.26458332"
y="136.25436"
x="121.10673"
sodipodi:role="line"
id="tspan1447">n 2</tspan></text>
<path
inkscape:connector-curvature="0"
id="path1457"
d="M 155.70134,132.71069 H 132.45743"
style="fill:none;stroke:#000000;stroke-width:0.57200003;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#marker1461)" />
</g>
<g
id="g3378">
<rect
style="fill:#e6e6e6;stroke:#000000;stroke-width:0.65399998;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
id="rect2065"
width="52.738316"
height="33.308411"
x="-42.703972"
y="-178.62962"
transform="scale(1,-1)" />
<text
xml:space="preserve"
style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
x="-39.78558"
y="159.38126"
id="text2399"><tspan
sodipodi:role="line"
id="tspan2395"
x="-39.78558"
y="159.38126"
style="stroke-width:0.26458332">fibonacci</tspan><tspan
sodipodi:role="line"
x="-39.78558"
y="172.61043"
style="stroke-width:0.26458332"
id="tspan2397">n 2</tspan></text>
<path
style="fill:none;stroke:#000000;stroke-width:0.57200003;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#marker2477)"
d="M -5.1909657,169.60016 H -28.434879"
id="path2473"
inkscape:connector-curvature="0" />
</g>
<g
id="g3397"
transform="translate(-4.0372213e-6)">
<rect
transform="scale(1,-1)"
y="-178.62962"
x="27.108162"
height="33.308411"
width="52.738316"
id="rect2887"
style="fill:#e6e6e6;stroke:#000000;stroke-width:0.65399998;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
<text
id="text2893"
y="159.38126"
x="30.026566"
style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
xml:space="preserve"><tspan
style="stroke-width:0.26458332"
y="159.38126"
x="30.026566"
id="tspan2889"
sodipodi:role="line">fibonacci</tspan><tspan
id="tspan2891"
style="stroke-width:0.26458332"
y="172.61043"
x="30.026566"
sodipodi:role="line">n 1</tspan></text>
<path
inkscape:connector-curvature="0"
id="path2901"
d="M 64.621188,169.60016 H 41.377278"
style="fill:none;stroke:#000000;stroke-width:0.57200003;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#marker2905)" />
</g>
<g
id="g3428"
transform="translate(-3.4070035)">
<rect
style="fill:#e6e6e6;stroke:#000000;stroke-width:0.65399998;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
id="rect3123"
width="52.738316"
height="33.308411"
x="100.327"
y="-178.62962"
transform="scale(1,-1)" />
<text
xml:space="preserve"
style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
x="103.2454"
y="159.38126"
id="text3129"><tspan
sodipodi:role="line"
id="tspan3125"
x="103.2454"
y="159.38126"
style="stroke-width:0.26458332">fibonacci</tspan><tspan
sodipodi:role="line"
x="103.2454"
y="172.61043"
style="stroke-width:0.26458332"
id="tspan3127">n 1</tspan></text>
<path
style="fill:none;stroke:#000000;stroke-width:0.57200003;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#marker3141)"
d="M 137.84001,169.60016 H 114.5961"
id="path3137"
inkscape:connector-curvature="0" />
</g>
<g
id="g3447"
transform="translate(-3.5949959)">
<rect
transform="scale(1,-1)"
y="-178.62962"
x="170.327"
height="33.308411"
width="52.738316"
id="rect3239"
style="fill:#e6e6e6;stroke:#000000;stroke-width:0.65399998;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
<text
id="text3245"
y="159.38126"
x="173.24539"
style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
xml:space="preserve"><tspan
style="stroke-width:0.26458332"
y="159.38126"
x="173.24539"
id="tspan3241"
sodipodi:role="line">fibonacci</tspan><tspan
id="tspan3243"
style="stroke-width:0.26458332"
y="172.61043"
x="173.24539"
sodipodi:role="line">n 0</tspan></text>
<path
inkscape:connector-curvature="0"
id="path3253"
d="M 207.84,169.60016 H 184.59609"
style="fill:none;stroke:#000000;stroke-width:0.57200003;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#marker3257)" />
</g>
<path
style="fill:none;stroke:#000000;stroke-width:0.565;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker1935)"
d="M 60.326994,66.754768 44.940407,89.337972"
id="path3455"
inkscape:connector-curvature="0" />
<rect
transform="scale(1,-1)"
y="-234.614"
x="-7.7979517"
height="33.308411"
width="52.738316"
id="rect3489"
style="fill:#e6e6e6;stroke:#000000;stroke-width:0.65399998;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
<text
id="text3507"
y="215.36565"
x="-4.8795586"
style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
xml:space="preserve"><tspan
style="stroke-width:0.26458332"
y="215.36565"
x="-4.8795586"
id="tspan3503"
sodipodi:role="line">fibonacci</tspan><tspan
id="tspan3505"
style="stroke-width:0.26458332"
y="228.59482"
x="-4.8795586"
sodipodi:role="line">n 0</tspan></text>
<path
inkscape:connector-curvature="0"
id="path3515"
d="M 29.715056,225.40506 H 6.4711429"
style="fill:none;stroke:#000000;stroke-width:0.57200003;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#marker3519)" />
<rect
style="fill:#e6e6e6;stroke:#000000;stroke-width:0.65399998;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
id="rect3863"
width="52.738316"
height="33.308411"
x="-77.610001"
y="-234.614"
transform="scale(1,-1)" />
<text
xml:space="preserve"
style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
x="-74.691605"
y="215.36565"
id="text3869"><tspan
sodipodi:role="line"
id="tspan3865"
x="-74.691605"
y="215.36565"
style="stroke-width:0.26458332">fibonacci</tspan><tspan
sodipodi:role="line"
x="-74.691605"
y="228.59482"
style="stroke-width:0.26458332"
id="tspan3867">n 1</tspan></text>
<path
style="fill:none;stroke:#000000;stroke-width:0.57200003;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#marker3887)"
d="M -40.096993,225.40506 H -63.340906"
id="path3883"
inkscape:connector-curvature="0" />
<path
style="fill:none;stroke:#000000;stroke-width:0.565;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker4034)"
d="M 113.06531,66.754768 128.452,89.337972"
id="path4024"
inkscape:connector-curvature="0" />
<path
style="fill:none;stroke:#000000;stroke-width:0.565;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker2077)"
d="M -7.7979071,122.64638 -16.335,144.88943"
id="path4794"
inkscape:connector-curvature="0" />
<path
style="fill:none;stroke:#000000;stroke-width:0.565;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker2189)"
d="m 44.940407,122.64638 8.536591,22.24305"
id="path4832"
inkscape:connector-curvature="0" />
<path
style="fill:none;stroke:#000000;stroke-width:0.565;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker4856)"
d="m 128.452,122.64638 -5.163,22.24305"
id="path4846"
inkscape:connector-curvature="0" />
<path
style="fill:none;stroke:#000000;stroke-width:0.565;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker5142)"
d="M 181.19032,122.64638 193.101,144.88943"
id="path4996"
inkscape:connector-curvature="0" />
<path
style="fill:none;stroke:#000000;stroke-width:0.565;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker5286)"
d="m -42.703972,178.62962 -8.536027,22.19725"
id="path5276"
inkscape:connector-curvature="0" />
<path
style="fill:none;stroke:#000000;stroke-width:0.565;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker4306)"
d="M 10.034344,178.62962 18.572,200.49975"
id="path5608"
inkscape:connector-curvature="0" />
</g>
</svg>
img/by-nc-sa.png 0 → 100644
View file @ 9a8e896d
img/by-nc-sa.png

21.9 KiB

img/download.png 0 → 100644
View file @ 9a8e896d
img/download.png

12.8 KiB

notebooks/FAQ.ipynb 0 → 100644
View file @ 9a8e896d
%% Cell type:markdown id: tags:
<h1><center> Allgemein </center></h1>
%% Cell type:markdown id: tags:
- Bitte tragt euch in **beide Moodle Kurse** ein. Ankündigungen werden dort veröffentlicht! Wer sich nicht anmeldet und nicht regelmäßig ins Forum schaut, hat Pech gehabt.
- Man kann einstellen, dass man Emails bei neuen Forumbeiträgen bekommt, um keine Neuigkeiten zu verpassen.
%% Cell type:markdown id: tags:
- **Pair-Programming** bitte einhalten: **"nicht gleichzeitig"** programmieren, sondern **abwechselnd aktiv** sein. Das ist für alle Beteiligten ein Vorteil!
%% Cell type:markdown id: tags:
- **Latex**: Tutorium oder Übung. Im Seminar benutzen wir nur Jupyter-Notebooks
%% Cell type:markdown id: tags:
- **WICHTIG** bei Ankündigungen am Ende der Stunde: Bitte Jupyter Notebooks durcharbeiten oder versuchen. Ich verstehe, dass man nicht immer alle Übungen alleine schafft, aber zumindest die Theorie kann man mit seinem Partner durcharbeiten.
%% Cell type:markdown id: tags:
- **HILFE** bei Aufgaben:
- Email
- Tutorium
- vorbeikommen (Raum 111)
%% Cell type:markdown id: tags:
- Alternativer Python-Kurs für Interessierte: https://automatetheboringstuff.com/
%% Cell type:markdown id: tags:
## Python Tutor
Eine gute Hilfe ist die Webseite: http://www.pythontutor.com.
Dort könnt ihr euren Python Code hochladen und Schritt für Schritt durchführen.
Probiert es aus *(Achtung: Sie müssen die Funktion auch dort aufrufen)*.
- Kurze Anleitung:
- Nehmt einen Browser eurer Wahl und ruft http://www.pythontutor.com auf.
- Klickt auf *Visualize your code and get live help now*
- Copy-Paste euren Code in das Textfenster
- Drückt auf Visualize Execution (jetzt solltet ihr auf eine neue Seite gelangt sein)
- Mit den Buttons (First,Back,Forward,Last) könnt ihr jetzt jeden Schritt nachvollziehen, den python macht, wenn ihr den Code im Jupyter-Notebook aufruft.
- Der Vorteil ist natürlich, dass ihr nun Schritt für Schritt nachvollziehen könnt, was euer Code macht.
- Es gibt eine print box, wo alles ausgegeben wird, was durch print() auf eurem Display auch ausgegeben werden würde
- Darunter werden Variablen, Funktionen und Methoden angezeigt.
Besonders hilfreich beim Thema **REKURSION**.
%% Cell type:markdown id: tags:
<h1><center> Zu den Jupyter-Notebooks </center></h1>
### was mir an python gefällt:
%% Cell type:markdown id: tags:
- 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.
- Dieser Exkurs soll zeigen, zu was python alles fähig ist und für was ihr Python in Zukunft benutzen könnt :)
%% Cell type:markdown id: tags:
### Jupyter-Notebooks - Tipps
%% Cell type:markdown id: tags:
- **Markdownblöcke** (das sind normalerweise die Textblöcke) kann man mit **"Strg + enter"** wieder in den Lesemodus bringen
- **Codeblöcke** (das sind normalerweise die Blöcke, indem der Pythoncode steht) kann man mit **"Strg + enter"** ausführen
%% Cell type:markdown id: tags:
- **Download**: Linksklick auf das Notebook (z.B. seminar03.ipynb) -> Rechtsklick auf Feld "Open Raw" -> Ziel speichern unter
- Download von Notebooks mit Firefox!
- Öffnen von Jupyter-Notebook geht auch mit Internet-Explorer
%% Cell type:markdown id: tags:
- 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: **Menüleiste-> 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 id: tags:
- Einrücken durch die **"Tabulatortaste" (tab)**, um die richtige Formatierung einfach zu bekommen (bei Definitionen von Funktionen, for- oder while-Schleifen, if-Bedingungen, etc.)
- Falsches Einrücken ergibt häufig den Fehler: **IndentationError**
- Beispiel:
%% Cell type:code id: tags:
```
def example():
i=0
while i <= 5:
if i<1:
print("Mit der tab-Taste kann man immer 'eins weiter' einrücken.")
elif i==5:
print("Mit 'tab' und 'shift' gleichzeitig rückt man 'eins' wieder nach hinten.")
i=i+1
example()
```
%% Cell type:markdown id: tags:
### Browser-Einstellungen für Jupyter-Notebook
Jupyter-Notebook wird immer in dem Browser geöffnet, der auf dem Computer als Standardbrowser festgelegt ist.
Im PC-Pool ist das zur Zeit der Internet-Explorer und wir können das leider nicht ändern.
Dadurch funktionieren manche Shortcuts leider nicht.
Auf euren PC's zu Hause könnt ihr es aber einfach ändern:
(Wir empfehlen Firefox als Standardbrowser)
macOS:
1. Öffnen sie die Systemeinstellungen.
2. Klicken Sie auf „Allgemein“.
3. Wählen Sie unter „Standard-Webbrowser“ den gewünschten Browser aus.
Ubuntu Linux:
1. Öffnen Sie die System Settings.
2. Klicken Sie auf „Applications“.
3. Wählen Sie in der linken Spalte „Default Applications“ aus.
4. Klicken Sie in der Spalte rechts davon auf „Web Browser“.
5. Wählen Sie „in the following browser:“ aus.
6. Wählen Sie den gewünschten Browser aus.
Windows:
1. Öffnen Sie die Systemsteuerung.
2. Klicken Sie auf „Standardprogramme“.
3. Klicken Sie auf „Standardprogramme festlegen“.
4. Klicken Sie in der Liste auf den gewünschten Browser.
5. Klicken Sie dann auf „Dieses Programm als Standard festlegen“.
%% Cell type:markdown id: tags:
<h1><center> Beispielcode</center></h1>
%% Cell type:markdown id: tags:
### Kommentare
- Kommentare in Codeblöcken kann man mit Hilfe von # schreiben
%% Cell type:code id: tags:
```
# We are inside a Code block.
# But with the help of # we can still write whatever we want to document our code. This is really helpful.
# Shortcut: Str+/ (comment and uncomment)
```
%% Cell type:markdown id: tags:
- Zusätzlich gibt es Docstrings (kurz für Documentation strings). Die Syntax sind drei Gänsefüßchen am Anfang und am Ende der Zeichenkette. Damit könnt ihr eure Funktionen und Methoden gut beschreiben, Zeilenumbrüche funktionieren.
%% Cell type:code id: tags:
```
def function():
"""
Do nothing, but document it.
No, really, it doesn't do anything.
"""
```
%% Cell type:markdown id: tags:
## Zahlen - float
%% Cell type:markdown id: tags:
- Gleitkommazahlen (floats) immer mit **Punkt** statt **Komma* angeben -> 29.99 statt 29,99
%% Cell type:code id: tags:
```
#Gleitkommazahl durch Punkt getrennt -> RICHTIG
preis=29.99
print(preis)
print(type(preis))
# python erkennt die Zahl und gibt die Zahl wieder.
```
%% Cell type:code id: tags:
```
# Gleitkommazahl durch Komma getrennt -> FALSCH
preis=29,99
print(preis)
type(preis)
# Python erkennt zwei Zahlen, die es in einem Tupel speichert.
```
%% Cell type:markdown id: tags:
### Print - Funktion
- 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.
%% Cell type:code id: tags:
```
# Beispiele:
# Der print-Befehl ist eine überaus nützliche Funktion in python.
# Wir können uns damit an jeder Stelle unseres Codes Zwischenergebnisse,
# Ergebnisse, Variablen, etc. ausgeben lassen.
#Zeichenketten:
print("\n \n Jetzt kommen wir zu den Zeichenketten \n")
print("Hallo! Schön, dass du es hierher geschafft hast :)")
#Zahlen:
print("\n \n Jetzt kommen wir zu den Zahlen \n")
print(10)
print(10,20,30)
#Variablen:
print("\n \n Jetzt kommen wir zu den Variablen \n")
a=10
print(a)
#Verkapselungen:
print("\n \n Jetzt kommen wir zu den Verkapselungen \n")
print("Die Lösung lautet:", 100, "Hier kann noch mehr Text stehen")
print("Zeichenketten kann man auch mit dem + Operator verbinden:"+" Das kann man hier sehen.")
print("Zahlen dagegen werden dadurch addiert und die Summe wird ausgegeben: ", 5+4)
a=10
b=20
c="Hier könnte alles stehen."
print("Wir können auch Variablen dazunehmen:",a,b,c)
# Jetzt kommen komplizierte Beispiele:
print("\n \n Jetzt kommen wir zu komplizierte Beispiele \n")
print("Durch verschiedene Zeichen kann man den Output der Print-Funktion 'verschönern'. \n")
print('"\\n" : erzeugt einen Zeilenabsatz \n' )
print("Beispiel: \n", "Hello \n , \n World \n ! ")
print('"\\t" : rückt den anschließenden Abstand um einen festen Abstand vor \n' )
print("Beispiel: \t", "Hello \t , \t World \t ! ")
print("\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"')
print("Dieser Befehl definiert den Abstand zwischen verschiedenen Anweisungen innerhalb der print-Funktion")
print("BeispieL: ","Jetzt", "werden", "wir", "zwischen", "jeder", "Anweisung", "einen", "Abstand", "definieren", sep="\t")
print("BeispieL: ","Jetzt", "werden", "wir", "zwischen", "jeder", "Anweisung", "einen", "Abstand", "definieren", sep="\n")
#Macht euch den Unterschied zwischen \t und \n innerhalb einer Zeichenkette und sep="\n" bzw. sep="\t" klar.
```
%% Cell type:markdown id: tags:
### Code Beispiele
%% Cell type:code id: tags:
```
40/1.61
#Hier rechnen wir 40km in Meilen um. Das Ergebnis, welches Python ausgibt, bitte nicht für weitere Rechnungen verwenden.
# 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 id: tags:
```
#example
#Ein Mann hat eine 40km Fahrradtour in 2h absolivert.
#1. Wieviele Sekunden pro Meter ist er im Durchschnitt gefahren?
#2. Mit wieviel Meter pro Minute war er im Durchschnitt unterwegs?
#3. Mit wieviel Meilen pro Stunde war er im Durchschnitt unterwegs?
#solution:
#Zeit in verschiedenen Einheiten
Stunden=2
Minuten=Stunde*60
Sekunden=Minute*60
#Strecken in verschiedenen Einheiten
Kilometer=10
Meter=40*1000
Meilen=40/1.61
print("In einer print()-Funktion kann man","mehrere Zeichenketten und Variablen", " durch Kommata trennen und zusammen ausgeben")
print("Sekunden pro Meter :", Sekunden/Meter)
print("Meter pro Mintue :", Meter/Minuten)
print("Meilen pro Stunde :", Meilen/Stunden, "Perfekt")
print("Meilen pro Stunde :", (40/1.61)/Stunden, "Okay")
print("Meilen pro Stunde :", 24.844720496894407/Stunden, "Bitte nicht gerundete Zahlen übernehmen")
```
%% Cell type:code id: tags:
```
print("Division von integers \n")
#Teilen von Ganzzahlen (integers oder int) mit "/" (gibt den genauen Wert zurück, typ=float)
print("Hier dividieren wir mit Hilfe von /: ",2/60,3/2,8/3, sep='\t')
#Teilen von Ganzzahlen (integers oder int) mit "//" (gibt den abgerundeten Wert wieder, typ=int)
print("Hier dividieren wir mit Hilfe von //: ",2//60,3//2,8//3, sep='\t')
print("\n Division von float und integers \n")
#Teilen von Float und Ganzzahlen (integers oder int) mit "/" (gibt den genauen Wert zurück, typ=float)
print("Hier dividieren wir mit Hilfe von /: ",2/60.0,3.0/2,8.4/3,sep='\t')
#Teilen von Float und Ganzzahlen (integers oder int) mit "//" (gibt den abgerundeten Wert wieder, typ=float)
print("Hier dividieren wir mit Hilfe von //: ",2//60.0,3.0//2,8.4//3,sep='\t')
```
%% Cell type:markdown id: tags:
## Importieren von Modulen und Bibliotheken
%% Cell type:markdown id: tags:
- Stellen Datentypen oder Funktionen für alle Python-Programme bereit
- Syntax: `import module`
- Konvention: Steht **immer am Anfang des Codes**
- Beispiel:
%% Cell type:code id: tags:
```
import math
import turtle
import csv
#hier steht Code
```
%% Cell type:markdown id: tags:
## Funktionen
Funktion funktionieren in Python wie mathematische Funktionen aus der Schule:
Stellt euch die Funktion f(x,y)=x*y vor. In Python definieren wir sie wie folgt:
%% Cell type:code id: tags:
```
def f(x,y):
return x*y
```
%% Cell type:markdown id: tags:
Jetzt haben wir die Funktion zwar definiert, aber sie gibt noch kein Ergebnis zurück. Das passiert nur, wenn wir die Funktion aufrufen.
Um die Funktion aufzurufen, müssen wir die Parameter x und y explizit angeben, z.B. x=5 und y=3.
In der Schule haben wir früher Folgendes geschrieben: f(5,3)=5*3=15.
In Python machen wir nichts anderes, nur das Berechnen überlassen wir python:
%% Cell type:code id: tags:
```
def f(x,y):
return x*y
print("Wenn eine Funktion einen return-Rückgabewert hat, muss man die Funktion durch print() aufrufen, um das Ergebnis angezeigt zu bekommen. \n")
f(5,3)
print("Wie man sieht, wird nichts auf das Display ausgegeben. Also verschachteln wir unser Funktionsaufruf f(5,3) in einen print()-Aufruf. \n")
print("Es gibt verschiedene Wege:")
print(f(5,3))
print("\nAlternative 1:")
print(f(x=5,y=3))
print("\nAlternative 2:")
variable_x=5
variable_y=3
print(f(variable_x, variable_y))
```
%% Cell type:code id: tags:
```
def beispiel(x):
print(x)
print("Falls die Funktion kein return hat, sondern nur print-Anweisungen, dann reicht es, die Funktion aufzufen.")
print("print() innerhalb der Funktion gibt x aus. \n")
beispiel("Das ist ein Funktionsaufruf und diese Zeichenkette ist unser Parameter x")
```
%% Cell type:markdown id: tags:
**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 id: tags:
## Turtle Modul
- Dokumentation mit allen turtle-Methoden: https://docs.python.org/3/library/turtle.html
- Im Idealfall sollte in jedem Codeblock die folgenden Anweisungen stehen:
%% Cell type:code id: tags:
```
#Zuerst wird das Modul turtle importiert
import turtle
#hier steht euer Code
# Um ein Arbeiten mit turtle und Jupyter-Notebook zu ermöglichen, müssen wir diese beiden Befehle am Ende des Blocks schreiben
turtle.mainloop()
turtle.bye()
```
%% Cell type:code id: tags:
```
#Zuerst wird das Modul turtle importiert
import turtle
#Hier lernen wir die Funktionen up(), down() und fd() kennen
otto=turtle.Turtle()
def line(t):
t.fd(50)
t.up()
t.fd(50)
t.down()
t.fd(50)
t.fd(50)
t.up()
t.fd(50)
t.fd(50)
t.down()
t.fd(50)
# Um ein Arbeiten mit turtle und Jupyter-Notebook zu ermöglichen, müssen wir diese beiden Befehle am Ende des Blocks schreiben
line(otto)
turtle.mainloop()
turtle.bye()
```
%% Cell type:markdown id: tags:
Kommentare -> commit -> nicht zu bdeuten
%% Cell type:code id: tags:
```
import turtle
otto=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen otto zugewiesen
anna=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen anna zugewiesen
telmo=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen telmo zugewiesen
#Hier lernen wir die Funktionen shape(), color(), fd() und lt() kennen
def square(t):
t.shape('turtle') #wir geben der turtle t die Form einer Schildkröte
t.color("purple","red") #wir färben den zurückgelegten Weg lila (erstes Argument), die Schildkröte rot (zweites Argument)
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.
t.fd(100)
t.lt(90)
square(otto) #wir rufen square mit der turtle namens otto auf. Wir könnten aber genauso anna oder telmo nehmen
turtle.mainloop()
turtle.bye()
```
%% Cell type:code id: tags:
```
import turtle
otto=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen otto zugewiesen
anna=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen anna zugewiesen
telmo=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen telmo zugewiesen
#Hier lernen wir die Funktionen color(),begin_fill(), end_fill(), fd() und lt() kennen
def square(t):
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
t.begin_fill() # wir beginnen die Fläche, die unsere turtle läuft, zu färben
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.
t.fd(100)
t.lt(90)
t.end_fill() # wir beenden das Einfärben der Fläche
square(anna) #wir rufen square mit der turtle namens anna auf. Wir könnten aber genauso otto oder telmo nehmen
turtle.mainloop()
turtle.bye()
```
%% Cell type:code id: tags:
```
# Diese Funktion können wir nutzen, um unsere Schildkröte mit zufälligen Farben zu färben.
# Wir können die Funktion nutzen, indem wir sie in unseren Codeblock einfügen und dann an passender Stelle aufrufen.
# Im nächsten Codeblock ist ein Beispiel gegeben.
# Varianten: setcolor(t,1) : Schildkröte und Zeichnung in derselben zufälligen Farbe
# Varianten: setcolor(t,2) : Schildkröte und Zeichnung in zwei unterschiedlichen zufälligen Farben
from random import randint
def setcolor(t,n):
turtle.colormode(255) # um RGB-Farben anzuwenden, muss man vorher diesen Colormode aktivieren
if n==1:
t.color(randint(0,255),randint(0,255),randint(0,255)) #generiert eine zufällige Farbe für die turtle
if n==2:
t.color((randint(0,255),randint(0,255),randint(0,255)),(randint(0,255),randint(0,255),randint(0,255))) #generiert eine zufällige Farbe für die turtle
```
%% Cell type:code id: tags:
```
import turtle
from random import randint
otto=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen otto zugewiesen
anna=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen anna zugewiesen
telmo=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen telmo zugewiesen
#Hier lernen wir die Funktionen shape(), stamp(), color(), colormode() und fd() kennen
# Fkt setcolor wurde hier eingefügt
def setcolor(t,n):
turtle.colormode(255) # um RGB-Farben anzuwenden, muss man vorher diesen Colormode aktivieren
if n==1:
t.color(randint(0,255),randint(0,255),randint(0,255)) #generiert eine zufällige Farbe für die turtle
if n==2:
t.color((randint(0,255),randint(0,255),randint(0,255)),(randint(0,255),randint(0,255),randint(0,255))) #generiert eine zufällige Farbe für die turtle
def line(t): #Diese Funktion malt eine einfache Linie (in verschiedenen Farben und mit Stempeln jede 100 Einheiten)
setcolor(t,1) #Hier rufen wir setcolor mit unserer turtle auf und setzen n=1, um die Linie und die Schildkröte in derselben Farbe zu färben
t.shape('turtle')
t.stamp() #wir machen einen Stempel an dieser Stelle von unserem turtle
t.fd(100)
setcolor(t,1) #nächster Aufruf von setcolor
setcolor(t,1) # wir können setcolor beliebig oft und an beliebiger Stelle aufrufen
t.stamp() #wir machen einen Stempel an dieser Stelle von unserem turtle
t.fd(100)
setcolor(t,2)
t.stamp() #wir machen einen Stempel an dieser Stelle von unserem turtle
t.fd(100)
setcolor(t,2)
t.stamp() #wir machen einen Stempel an dieser Stelle von unserem turtle
t.fd(100)
setcolor(t,2)
line(telmo) #wir rufen line mit der turtle namens telmo auf. Wir könnten aber genauso anna oder otto nehmen
turtle.mainloop()
turtle.bye()
```
%% Cell type:code id: tags:
```
import turtle
otto=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen otto zugewiesen
anna=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen anna zugewiesen
telmo=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen telmo zugewiesen
#Hier lernen wir die Funktionen circle() und shapesize() kennen
def circle(t,r):
t.shape('turtle')
t.shapesize(10) # wir ändern die Größe unserer turtle
t.circle(r) #wir malen einen Kreis mit Radius r
circle(telmo,100) #wir rufen line mit der turtle namens telmo auf. Wir könnten aber genauso anna oder otto nehmen
turtle.mainloop()
turtle.bye()
```
%% Cell type:markdown id: tags:
![CC-BY-NC](https://scm.cms.hu-berlin.de/ibi/python/-/raw/master/img/cc-by-nc.png)
Dieses Notebook ist als freies Werk unter der Lizenz [Creative Commons Attribution-NonCommercial 3.0 Unported](http://creativecommons.org/licenses/by-nc/3.0/) verfügbar. Sie dürfen die Inhalte kopieren, verteilen und verändern, solange Sie die Urheber nennen und sie nicht für kommerzielle Zwecke nutzen.
notebooks/README.org
View file @ 9a8e896d
Sie können sich die Notebooks hier ansehen aber nicht ausführen. Dazu
müssen Sie sie herunterladen und in Jupyter öffnen. Klicken Sie dazu
auf der Seite mit dem jeweiligen Notebook *mit der rechten Maustaste*
auf den Button "Open Raw" und speichern Sie die geöffnete Datei, indem
Sie "*Ziel speichern unter ...*" (oder "Link speichern unter ...")
wählen:
* Seminar Problemorientierte Programmierung
[[file:../img/open_raw.png]]
Dieses Projekt enthält Jupyter-Notebooks für einen
Python-Programmierkurs. Die Notebooks sind im Wesentlichen eine
Übersetzung der 2. Ausgabe des Buches [[http://greenteapress.com/wp/think-python-2e/][Think Python]] von
Allen B. Downey. Es gibt das Buch auch in einer offiziellen deutschen
Übersetzung mit dem Titel /Programmieren lernen mit Python/.
/(Hinweis: dies funktioniert oft nicht im Edge-Browser, verwenden Sie
also ggf. Firefox, Chrome oder Opera.)/
Sie finden die Notebooks im Ordner [[file:notebooks/][notebooks]]. Sie können sich die
Notebooks hier in GitLab ansehen aber nicht ausführen. Dazu müssen Sie
sie herunterladen und in Jupyter öffnen. Klicken Sie dazu auf der
Webseite mit dem jeweiligen Notebook auf den Button "Download" und
speichern Sie es als Datei:
Alternativ können Sie auch direkt hier die Dateien herunterladen,
[[file:img/download.png]]
Alternativ können Sie die Notebooks auch direkt hier herunterladen,
indem Sie mit der rechten Maustaste auf die Links klicken und /Ziel
speichern unter.../ wählen:
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar00.ipynb][Einführung]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar01.ipynb][1: Die ersten Programme]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar02.ipynb][2: Variablen, Ausdrücke und Anweisungen]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar01.ipynb][1: Operatoren, Ausdrücke, Typen]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar02.ipynb][2: Variablen und Anweisungen]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar03.ipynb][3: Funktionen]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar03extra.ipynb][3 extra: reguläre Ausdrücke]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar04.ipynb][4: Fallstudie: Schnittstellenentwurf]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar04.ipynb][4: Turtle: Schnittstellenentwurf]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar05.ipynb][5: Verzweigungen und Rekursion]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar06.ipynb][6: Ertragreiche Funktionen]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar07.ipynb][7: Iteration]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar08.ipynb][8: Zeichenketten]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar09.ipynb][9: Fallstudie: Wortspiele]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar10.ipynb][10: Listen]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar11.ipynb][11: Assoziative Datenfelder]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar07.ipynb][7: Iteration und Suche]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar08.ipynb][8: Reguläre Ausdrücke und Zeichenketten]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar09.ipynb][9: Listen]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar10.ipynb][10: Assoziative Datenfelder]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar11.ipynb][11: Tupel]]
Merken Sie sich, wo Sie die Dateien gespeichert haben und navigieren
Sie dann mit Jupyter zu diesem Ordner, um sie zu öffnen.
[[file:img/cc-by-nc.png]] Dieser Kurs ist als freies Werk unter der Lizenz
[[http://creativecommons.org/licenses/by-nc/3.0/][Creative Commons Attribution-NonCommercial 3.0 Unported]] verfügbar. Sie
dürfen die Inhalte kopieren, verteilen und verändern, solange Sie die
Urheber nennen und sie nicht für kommerzielle Zwecke nutzen.
** Tipps zur Einrichtung von Python und Jupyter
*** Allgemeine Hinweise
- Im Kurs wird durchgängig Python 3 benutzt. Daher bitte darauf
achten, keine alte Python-Version (2.6, 2.7, etc.) zu
installieren. Am besten mindestens Python 3.5.3 benutzen, aktuellere
Versionen sind auch ok.
- Helfen Sie sich gegenseitig bei der Installation und unterstützen
Sie sich bei Problemen. Benutzen Sie auch gerne das Forum bei einem
spezifischen Problem, um Hilfe von Ihren Kommiliton*innen zu
erhalten. Wenn niemand helfen kann, helfen wir Ihnen.
*** Windows
- [[https://www.anaconda.com/download]]
- [[https://technivore.org/2016/02/27/python-jupyter-windows/]]
*** Linux
- Je nach Distribution das passende Paket installieren, z.B. in Debian mittels ~apt-get install python3-notebook~.
- Anaconda enthält sowohl Jupyter Notebooks, als auch Python 3.5 oder 3.6 Kernel und einige wichtige Python-Bibliotheken wie z.B. Numpy.
- Die aktuelle Anaconda-Distribution ist hier zu finden: [[https://www.anaconda.com/download/#linux]]
- Ältere Anaconda-Distributionen finden sich hier: [[https://docs.anaconda.com/free/anaconda/reference/packages/oldpkglists/]]
- [[https://docs.anaconda.com/anaconda/install/linux][Hilfestellungen zur Installation von Conda]]
*** Mac
- Die aktuelle Anaconda-Distributon finden sich hier: [[https://www.anaconda.com/download/#macos]]
- Mac OS X Installations-Hilfe: [[https://docs.anaconda.com/anaconda/install/mac-os#macos-graphical-install]]
** Hinweise zu GitLab
Das System, auf dem Sie diese Seite gerade lesen und in dem Sie die
Notebooks finden, nennt sich *GitLab* und ist eine professionelle
Umgebung zur kollaborativen Softwareentwicklung. Hier können
Programmierer*innen Quellcode abspeichern, Änderungen verfolgen und
rückgängig machen, Fehler melden und Code dokumentieren.
Wenn Sie *Fehler* in den Jupyter-Notebooks finden oder *Hinweise zur
Verbesserung* haben, können Sie diese im Menü links unter [[https://scm.cms.hu-berlin.de/ibi/python/issues][Issues]]
hinzufügen.
Fortgeschrittene können sich dieses Projekt auch auf ihrem eigenen
Rechner *mittels [[https://de.wikipedia.org/wiki/Git][Git]] klonen* und dann immer die aktuellste Version der
Notebooks herunterladen.
Sie können die Möglichkeiten des Systems später auch für Ihre *Haus-
oder Abschlussarbeiten* nutzen, indem Sie [[https://scm.cms.hu-berlin.de/projects/new][ein eigenes Projekt anlegen]]
und dort Ihre Dateien sicher abspeichern. Dazu sollten Sie sich mit
der Versionsverwaltungssoftware [[https://de.wikipedia.org/wiki/Git][Git]] vertraut machen.
** Ressourcen rund um Python
- Ein [[http://introtopython.org/][freier Python-Kurs]] (auf Englisch), ebenfalls basierend auf
Jupyter-Notebooks.
- Die [[https://docs.python.org/3/][offizielle Dokumentation für Python 3]].
- Eine [[https://scm.cms.hu-berlin.de/ibi/notebooks][Sammlung interessanter Notebooks]] mit vielen Beispielen.
# https://github.com/jupyter/jupyter/wiki/A-gallery-of-interesting-Jupyter-Notebooks
notebooks/hausaufgabe1.ipynb
View file @ 9a8e896d
%% Cell type:markdown id: tags:
# 1. Hausaufgabe
Geben Sie diese Hausaufgabe gemeinsam mit Ihrem/r Partner/in ab. Füllen Sie dazu dieses Notebook aus und speichern Sie es ab (Disketten-Icon oben links). Laden Sie dann die Datei (hausaufgabe1.ipynb) in Moodle hoch. Verwenden Sie Kommentare im Python-Quellcode und Markdown-Textboxen im Jupyter-Notebook ([Syntax-Beispiele](https://de.wikipedia.org/wiki/Markdown#Auszeichnungsbeispiele)) um ihr Programm zu kommentieren.
### Bitte lesen Sie sich die nachfolgenden Hinweise zur Hausaufgabe gut durch.
Geben Sie diese Hausaufgabe gemeinsam als Pair Programming Gruppe ab. Füllen Sie dazu dieses Notebook aus und speichern Sie es ab (Disketten-Icon oben links). Laden Sie dann die Datei unter `Hausaufgabe 1` in Moodle hoch.
**Tipps und Anmerkungen**:
- Es reicht, wenn ein Gruppenmitglied die Hausaufgabe einreicht. Passen Sie auf, dass Sie in Moodle auf Abgabe drücken, damit es nicht nur ein Entwurf ist.
- Nutzen Sie das Wissen aus den bisher bearbeiteten Notebooks (1-3).
- Nutzen Sie http://pythontutor.com, um ihren Code nachvollziehen zu können und Fehler zu finden!
- Fügen Sie außerdem **kurze Kommentare** zu ihrem Code hinzu, mit denen Sie erklären, was die Funktion macht. Dies kann man durch zwei Varianten machen:
- inline-Kommentare (Code kommentieren): `#`
- Docstrings (Beschreibung der Funktion): `''' '''`
- Bitte ändern Sie den Dateinamen ihrer Hausaufgabe zu: **hausaufgabe1_nachnamePartnerIn1_nachnamePartnerIn2.ipynb**
- z.B. `hausaufgabe1_hachmeier_jaeschke.ipynb`
- Das können Sie einfach machen, indem Sie **jetzt** oben links auf `hausaufgabe1` klicken und den neuen Namen eingeben.
- Falls Sie **generative KI** in der Hausaufgabe genutzt haben wie bspw. ChatGPT: Dokumentieren Sie Ihre Nutzung. Geben Sie **alle** Eingaben an, die Sie in der jeweiligen Aufgabe verwendet haben und beschreiben Sie, welche Änderungen Sie vor Abgabe zur Anpassung an die jeweilige Aufgabe vornehmen mussten. Testen Sie Ihre Implementierung hier besonders gründlich und kommentieren Sie **jede Codezeile** sinnvoll. Bitte beachten Sie, dass sie vollständig für den generierten Code verantwortlich sind.
- Bei (Verständnis-)Fragen können Sie mich **frühzeitig** per E-Mail oder während der Sitzungen erreichen.
Wir wünschen viel Erfolg beim Lösen der Aufgaben!
%% Cell type:markdown id: tags:
## Aufgabe 1
Was gibt jede der folgenden Anweisungen aus? Erklären Sie jeweils die Ausgabe.
- Welche Funktionen werden genutzt und was machen diese Funktionen? (die `print` -Funktion muss nicht erklärt werden). Achten Sie darauf, in welcher Reihenfolge die Anweisungen ausgeführt werden.
- Was ist die Ausgabe? Geben Sie Wert und Datentyp an.
- Nutzen Sie Kommentare wie im Beispiel beschrieben.
- Nutzen Sie **mehrere Zeilen pro Anweisung, damit Ihre Antwort in die Breite des Codeblocks passt** und man nicht hin- und herscrollen muss. (Sie finden heraus, was ich meine, wenn es passiert ;) )
Beispiel
```
print("a"+"b")
# zwei Zeichenketten werden durch den Operator "+" verkettet
# Ausgabe: "ab", Datentyp: Zeichenkette/string
```
%% Cell type:code id: tags:
```
``` python
print(2 + 3)
#
#
print(2.2 + 3.3)
#
#
```
%% Cell type:code id: tags:
``` python
print('2' + '3')
#
#
print('2.2' + '3.3')
#
#
```
%% Cell type:code id: tags:
``` python
print(str(2) + str(3))
#
#
print(str(2.2) + str(3.3))
#
#
```
%% Cell type:code id: tags:
``` python
print(int('2') + int('3'))
#
#
print(int('2' + '3'))
#
#
```
%% Cell type:code id: tags:
``` python
print(float('2') + float('3'))
#
#
print(float('2' + '3'))
#
#
```
%% Cell type:code id: tags:
``` python
print(int(2.6 + 2.6))
#
#
print(int(2.6) + int(2.6))
#
#
```
%% Cell type:markdown id: tags:
## Aufgabe 2
**Tipp**: Wichtig bei den folgenden Aufgaben ist der Umgang mit Zeichenketten und der `print`-Funktion. Das haben Sie in den seminar-Notebooks schon gelernt. Gehen Sie diese zu Beginn der Hausaufgabe noch einmal durch und achten Sie, mit welchen **Operatoren** man Zeichenketten zusammenfügen und verketten kann.
### Aufgabe 2a
Ihre Aufgabe ist es, eine Funktion `boxprint` zu implementieren, die eine als Argument übergegebene Zeichenkette innerhalb einer Box ausgibt. Die horizontalen Linien der Box sollen durch `-` erzeugt werden, die vertikalen Linien durch `|` und die Ecken durch `+`. Zwischen der Zeichenkette und dem linken und rechten Rand der Box soll jeweils genau ein Leerzeichen stehen.
Beispiel: Bei Übergabe des Arguments `Hello World!` soll die Funktion folgende Ausgabe erzeugen:
%% Cell type:markdown id: tags:
```
+--------------+
| Hello World! |
+--------------+
```
%% Cell type:markdown id: tags:
Überlegen Sie zunächst, wie Sie das Problem lösen könnten und beschreiben Sie hier kurz ihre Überlegungen bzw. ihr Vorgehen:
-
-
-
%% Cell type:code id: tags:
```
# Implementieren Sie hier ihre Funktion
``` python
def boxprint(zeichenkette):
'''Die Funktion nimmt eine Zeichenkette entgegen und gibt
die Zeichenkette innerhalb einer Textbox aus.
'''
pass # Diese Zeile können Sie bei der Implementierung löschen
```
%% Cell type:code id: tags:
# Testen Sie hier ihre Funktion; fügen Sie auch eigene Tests hinzu
``` python
# Funktionsaufrufe
boxprint("Hello World!")
boxprint("Dieser Text muss auch in die Box passen.")
boxprint("Das Reh springt hoch, das Reh springt weit. Warum auch nicht, es hat ja Zeit.")
```
%% Cell type:code id: tags:
``` python
# Schreiben Sie hier zwei Funktionsaufrufe der Funktion mit eigenen Argumenten
```
%% Cell type:markdown id: tags:
### Aufgabe 2b
Mit dem Linux-Programm [cowsay](https://en.wikipedia.org/wiki/Cowsay) kann man verschiedene Tiere "Sprüche klopfen" lassen:
```
________
< Muuuh! >
--------
\ ^__^
\ (oo)\_______
(__)\ )\/\
||----w |
|| ||
```
Schreiben Sie eine Funktion `stegosay`, die einen als Argument übergebenen Text folgendermaßen ausgibt:
```
___________________________
( Wo bleibt mein Frühstück? )
---------------------------
o . .
o / `. .' '
o .---. < > < > .---.
o | \ \ - ~ ~ - / / |
_____ ..-~ ~-..-~
| | \~~~\.' `./~~~/
--------- \__/ \__/
.' O \ / / \ '
(_____, `._.' | } \/~~~/
`----. / } | / \__/
`-. | / | / `. ,~~|
~-.__| /_ - ~ ^| /- _ `..-'
| / | / ~-. `-. _ _ _
|_____| |_____| ~ - . _ _ _ _ _>
```
Nutzen Sie dazu Ihre bei der Programmierung von `boxprint` gesammelte Erfahrung.
Nutzen Sie dazu Ihre bei der Programmierung von `boxprint` gesammelte Erfahrung. Auch hier soll das Argument eine variable Länge aufweisen können, die "Sprechbox" soll sich anpassen.
**Achung**: Die Denkblase ist verschieden zu der Sprachblase auf Aufgabe 2a.
**Tipp**: Man kann den Stegosaurus im Editiermodus kopieren, Sie müssen nicht jedes Zeichen selbst abtippen.
Durch
```
'''
Dinoabbildung Zeile 1
Dinoabbildung Zeil 2
...
Dinoabbildung Zeile ...
'''
```
können Sie den Dino vollständig im Editormodus dieses Blocks herauskopieren und in Ihre Funktion einfügen.
Freiwillige Erweiterung für Fortgeschrittene: Erweitern Sie die Funktion um ein Argument, mit dem eine maximale Breite (Anzahl Zeichen) übergeben werden kann, so dass die ausgegebene Box nicht breiter ist. Implementieren Sie dann die Behandlung von Zeichenketten, die länger als die vorgegebene Breite sind. Sie haben zwei Möglichkeiten: a) die Zeichenkette abschneiden, b) die Zeichenkette umbrechen. Entscheiden Sie sich für eine der beiden Varianten. Hinweis: auf die ersten `k` Zeichen einer Zeichenkette `s` können Sie mittels `s[0:k]` zugreifen. Analog können Sie auf das 2. bis 4. Zeichen mittels `s[1:4]` zugreifen, usw.
%% Cell type:code id: tags:
```
``` python
print("""
o . .
o / `. .' '
o .---. < > < > .---.
o | \ \ - ~ ~ - / / |
_____ ..-~ ~-..-~
| | \~~~\.' `./~~~/
--------- \__/ \__/
.' O \ / / \ '
(_____, `._.' | } \/~~~/
`----. / } | / \__/
`-. | / | / `. ,~~|
~-.__| /_ - ~ ^| /- _ `..-'
| / | / ~-. `-. _ _ _
|_____| |_____| ~ - . _ _ _ _ _>
""")
```
%% Cell type:code id: tags:
``` python
def stegosay(z):
'''Diese Funktion nimmt eine Zeichenkette entgegen und gibt
die Zeichenkette innerhalb einer Denkblase eines Dinos wieder aus.
In dieser Funktion soll der Dinosaurier inklusive der Denkblase ausgegeben werden.
'''
pass # Diese Zeile können Sie bei der Implementierung löschen
```
%% Cell type:code id: tags:
``` python
# Testen Sie hier ihre Funktion; fügen Sie auch eigene Tests hinzu
stegosay("Wo bleibt mein Frühstück?")
stegosay("Auf einem Baum, da saß ein Specht. Der Baum war hoch, dem Specht war schlecht.")
```
%% Cell type:markdown id: tags:
## Aufgabe 3
### Aufgabe 3a
Schreiben Sie eine Funktion `sinprint`, die die Sinusfunktion (`math.sin`) im Bereich zwischen 0 und 2π um 90° gedreht ausgibt, also ungefähr so:
Schreiben Sie eine Funktion `sinprint`, die die Sinusfunktion (`math.sin`) im Bereich zwischen 0 und 2π um 90° gedreht ausgibt, also ungefähr so:
```
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
```
Hinweise:
- Sie können die Aufgabe auch ohne eine Schleife lösen, aber schöner ist es mit einer Schleife. Sie kennen die Syntax und Semantik der `while`-Schleife schon aus der Vorlesung. Sie funktioniert in Python genau so, wie sie für den Pseudocode definiert wurde.
- Sie müssen selbst entscheiden, wieviele Werte Sie im verlangten Intervall berechnen. Die Kurve oben wurde mit einem Rasterabstand von 0.2 berechnet (d.h., für die Werte 0, 0.2, 0.4, 0.6, ..., 6.2).
- Denken Sie daran, dass Sie mit der `int`-Funktion eine Gleitkommazahl in eine ganze Zahl umwandeln können (der Dezimalanteil wird abgeschnitten).
- Lösen Sie diese Aufgabe mit Hilfe einer Schleife. Sie kennen die Syntax und Semantik der `while`-Schleife schon aus der Vorlesung. Sie funktioniert in Python genau so, wie sie für den Pseudocode definiert wurde.
- Sie müssen selbst entscheiden, wieviele Werte Sie im verlangten Intervall berechnen. Die Kurve oben wurde z.B. mit einem Rasterabstand von 0.2 berechnet (d.h., für die Werte 0, 0.2, 0.4, 0.6, ..., 6.2). Dies können Sie übernehmen.
- Damit Sie die Funktion `math.sin` nutzen können, müssen Sie anfangs das `math`-Modul importieren.
- Folgende Probleme müssen gelöst werden:
- Umwandeln von Gleitkommazahlen in Ganzzahlen
- Umwandeln von negativen in positive Zahlen
- Nutzen Sie die `print`-Funktion, um die **Sternchen** (*) an verschiedenen Stellen zu zeichnen.
- Falls Sie das Problem nicht lösen können, fragen Sie im Seminar nach. Dort können Sie wertvolle Tipps erhalten.
%% Cell type:code id: tags:
``` python
# Beispiel einer einfachen while-Schleife
i = 0
while i < 5:
print(i)
i = i + 1
```
%% Cell type:code id: tags:
```
``` python
import math
def sinprint():
# Implementieren Sie hier die Funktion sinprint
'''Diese Funktion zeichnet eine Sinus-Kurve ohne eine plot-Bibliothek.'''
pass # Diese Zeile können Sie bei der Implementierung löschen
sinprint() # Testaufruf
```
%% Cell type:code id: tags:
``` python
# Funktionsaufruf
sinprint()
```
%% Cell type:markdown id: tags:
### Aufgabe 3b
Ändern Sie die Funktion `sinprint`, so dass eine beliebige Funktion gezeichnet werden kann. Diese Funktion sollte als Argument übergeben werden können. Also beispielsweise so:
```python
funcprint(math.sin)
```
Ändern Sie gleich auch den Namen der Funktion zu `funcprint`, da sie ja jetzt nicht nur die Sinusfunktion ausgeben kann. (In der 2. Aufgabe des 3. Jupyter-Notebooks haben wir die Funktion `do_twice` kennengelernt - dort sehen Sie, wie Sie Funktionen als Argumente übergeben und verwenden können.)
%% Cell type:code id: tags:
```
# Implementieren Sie hier die Funktion funcprint
``` python
import math
def funcprint(func):
'''Diese Funktion nimmt den Parameter `func` entgegen, der ein Funktionsobjekt repräsentiert und zeichnet
die Funktionskurve
'''
pass # Diese Zeile können Sie bei der Implementierung löschen
```
%% Cell type:code id: tags:
# Testen Sie hier die Funktion funcprint
funcprint(math.erf)
``` python
# Funktionsaufruf
funcprint(math.sin)
funcprint(math.cos)
```
%% Cell type:markdown id: tags:
### Aufgabe 3c
Wenn alles geklappt hat, enthält Ihre Funktion jetzt einige Werte, die als Literale angegeben sind, z.B.
- den Anfangs- und Endwert des Intervalls, in dem die Funktion gezeichnet werden soll
- die Schrittweite
- die Skalierung (Vergrößerung)
- die Verschiebung des Nullpunkts
- Skalierung in Richtung der x-Achse (Stauchung, Streckung)
- Skalierung in Richtung der y-Achse (Stauchung, Streckung)
Erweitern Sie die Funktion `funcprint`, so dass alle diese Werte als Argumente übergeben werden können.
Fangen Sie mit einem Parameter an und versuchen Sie nach und nach alle Parameter einzusetzen. Falls die nicht funktioniert, rufen Sie Ihre Funktion mit den Parametern auf, die funktionieren.
%% Cell type:code id: tags:
Ändern Sie die Funktion `funcprint`, so dass alle diese Werte als Argumente übergeben werden können. Testen Sie die Funktion dann mit der Funktion `math.log` als Argument. Dafür müssen Sie den Anfangswert so ändern, dass 0 nicht enthalten ist (da der Logarithmus von 0 nicht definiert ist).
``` python
import math
def funcprint_advanced(func, start, end, step, shift, scale_y):
'''Diese Funktion nimmt den Parameter `func` entgegen, der ein Funktionsobjekt repräsentiert und zeichnet
die Funktionskurve. Zudem nimmt die Funktion mehrere Parameter entgegen, die die Kurve verändern können.
'''
pass # Diese Zeile können Sie bei der Implementierung löschen
```
%% Cell type:code id: tags:
```
``` python
# Funktionsrauf
funcprint_advanced(math.cos, 2, 10, 0.1, 30, 5)
```
%% Cell type:markdown id: tags:
![Smiley](https://upload.wikimedia.org/wikipedia/commons/0/0f/Face-glasses.svg)
%% Cell type:markdown id: tags:
![CC-BY-NC](https://scm.cms.hu-berlin.de/ibi/python/-/raw/master/img/cc-by-nc.png)
Dieses Notebook ist als freies Werk unter der Lizenz [Creative Commons Attribution-NonCommercial 3.0 Unported](http://creativecommons.org/licenses/by-nc/3.0/) verfügbar. Sie dürfen die Inhalte kopieren, verteilen und verändern, solange Sie die Urheber nennen und sie nicht für kommerzielle Zwecke nutzen.
......
notebooks/hausaufgabe2.ipynb 0 → 100644
View file @ 9a8e896d
%% Cell type:markdown id: tags:
# 2. Hausaufgabe
### Bitte lesen Sie sich die nachfolgenden Hinweise zur Hausaufgabe gut durch.
Geben Sie diese Hausaufgabe gemeinsam als Pair Programming Gruppe ab. Füllen Sie dazu dieses Notebook aus und speichern Sie es ab (Disketten-Icon oben links). Laden Sie dann die Datei unter `Hausaufgabe 2` in Moodle hoch.
**Tipps und Anmerkungen**:
- Es reicht, wenn ein Gruppenmitglied die Hausaufgabe einreicht. Passen Sie auf, dass Sie in Moodle auf Abgabe drücken, damit es nicht nur ein Entwurf ist.
- Nutzen Sie http://pythontutor.com, um ihren Code nachvollziehen zu können und Fehler zu finden!
- Fügen Sie außerdem **kurze Kommentare** zu ihrem Code hinzu, mit denen Sie erklären, was die Funktion macht. Dies kann man durch zwei Varianten machen:
- inline-Kommentare (Code kommentieren): `#`
- Docstrings (Beschreibung der Funktion): `''' '''`
- für Kommentare in Markdown-Textboxen im Jupyter-Notebook: ([Syntax-Beispiele](https://de.wikipedia.org/wiki/Markdown#Auszeichnungsbeispiele))
- Bitte ändern Sie den Dateinamen ihrer Hausaufgabe zu: **hausaufgabe2_nachnamePartnerIn1_nachnamePartnerIn2.ipynb**
- z.B. `hausaufgabe2_hachmeier_jaeschke.ipynb`
- Das können Sie einfach machen, indem Sie **jetzt** oben links auf `hausaufgabe2` klicken und den neuen Namen eingeben.
- Falls Sie **generative KI** in der Hausaufgabe genutzt haben wie bspw. ChatGPT: Dokumentieren Sie Ihre Nutzung. Geben Sie **alle** Eingaben an, die Sie in der jeweiligen Aufgabe verwendet haben und beschreiben Sie, welche Änderungen Sie vor Abgabe zur Anpassung an die jeweilige Aufgabe vornehmen mussten. Testen Sie Ihre Implementierung hier besonders gründlich und kommentieren Sie **jede Codezeile** sinnvoll.
- In jedem Codeblock steht ein **Funktionsaufruf**, der die von Ihnen definierte Funktion aufruft. Dies sollte funktionieren (dort kann man auch direkt ablesen, wieviele und welche Argumente benötigt werden). Anfangs können Sie den Aufruf gerne auskommentieren, damit nicht ständig eine Fehlermeldung angezeigt wird.
- Schreiben Sie bitte zu jeder definierten Funktion **einen Funktionsaufruf mit eigens definierten *turtle-Objekten* und Parametern**.
- Nutzen Sie **Schleifen** in allen Aufgaben, in denen Sie geometrische Figuren zeichnen müssen (Sie haben diese in den Seminaren kennengelernt)!
- Verwenden Sie die von Ihnen **geschriebenen Funktionen aus vorherigen Aufgabenteilen in den Folgeaufgaben**, um Code zu sparen und Fehler zu vermeiden (zum Beispiel die Nutzung der Funktion `triangle` aus Aufgabe 1 in den Aufgaben 2-5).
- Bitte geben Sie nur **eine Lösung pro Aufgabe** ab.
- Bei (Verständnis-)Fragen können Sie mich **frühzeitig** per E-Mail oder während der Sitzungen erreichen.
Wir wünschen viel Erfolg beim Lösen der Aufgaben!
%% Cell type:markdown id: tags:
## Herunterladen des unterstützenden Codes
Die folgende Zelle lädt eine Datei herunter und führt einen Code aus, der speziell für dieses Notebook verwendet wird. Sie müssen diesen Code nicht verstehen, aber Sie sollten die Zelle vor allen weiteren Zellen in diesem Notebook ausführen.
%% Cell type:code id: tags:
``` python
from os.path import basename, exists
def download(url):
filename = basename(url)
if not exists(filename):
from urllib.request import urlretrieve
local, _ = urlretrieve(url, filename)
print("Downloaded " + str(local))
return filename
download('https://github.com/ramalho/jupyturtle/releases/download/2024-03/jupyturtle.py');
```
%% Cell type:markdown id: tags:
### Hilfsfunktion:
%% Cell type:code id: tags:
``` python
# Beispielcode
from jupyturtle import Turtle, make_turtle
caro = make_turtle(width=500, height=300, delay=0.05)
caro.jumpto(50, 250)
for i in range(4):
caro.forward(100)
caro.left(90)
```
%% Cell type:markdown id: tags:
### Tipps für die folgenden Aufgaben:
Nutzen Sie die Funktionen die wir in den Übungen verwendet haben. Das Skript für `jupyturtle` wird heruntergeladen aus einem [Github Repositorium](https://github.com/ramalho/jupyturtle/blob/main/src/jupyturtle/jupyturtle.py). Hier sind noch ein paar Tipps zur Nutzung:
- nutzen Sie die Funktion `make_turtle()` zur Instantiziierung einer Schildkröte. Sie können hierbei die Parameter `width` und `height` für die Breite und Höhe der Abbildung nutzen und den Parameter `delay` für die Geschwindigkeit der Zeichnung (tiefer entspricht schneller).
- je nach Breite und Höhe der Abbildung, können Sie mit `t.jumpto(x, y)` die Schildkröte an die Koordinate `x` und `y` setzen. Hierbei entspricht die Koordinate `x=0, y=0` der linken oberen Ecke.
- Die Farbe der Zeichnung der Schildkröte wählt man mit `t.pen_color = color`, wobei `color` ein Code in der [hexadezimalen Farbdefinition](https://de.wikipedia.org/wiki/Hexadezimale_Farbdefinition) ist.
%% Cell type:markdown id: tags:
## Aufgaben
### Aufgabe 1
Schreiben Sie eine Funktion `triangle`, die zwei Parameter `t` und `l` erwartet. `t` ist ein turtle-Objekt, `l` eine Ganzzahl. Die Funktion soll die Schildkröte nutzen, um ein gleichseitiges Dreieck mit Seitenlänge `l` zu zeichnen. Schreiben Sie einen Funktionsaufruf, der `otto` und `100` an `triangle` übergibt und rufen Sie ihr Programm auf. Färben Sie Ihr Dreieck in einer Farbe Ihrer Wahl.
%% Cell type:code id: tags:
``` python
from jupyturtle import Turtle, make_turtle
# hier kommt Ihre Lösung hin
```
%% Cell type:code id: tags:
``` python
otto = make_turtle(width=400, height=300, delay=0.05)
otto.jumpto(50, 250)
triangle(otto, 100)
```
%% Cell type:markdown id: tags:
### Aufgabe 2
Schreiben Sie eine Funktion `repeat_triangle`, die `n` gleichseitige Dreiecke nebeneinander zeichnet. Sie soll drei Argumente `t`, `n` und `l` erhalten. `t` ist ein turtle-Objekt, `l` gibt die Seitenlänge der Dreiecke an und `n` die Anzahl der Dreiecke. In der Funktion `repeat_triangle` soll die Funktion `triangle` aus Aufgabe 1 genutzt werden. *Freiwillig* : Jedes Dreieck soll eine eigene Farbe haben.
Eine mögliche Lösung könnte so aussehen (`repeat_triangle(otto, 80, 4)`):
![horizontal.png](attachment:b723de58-138f-4b0f-ad6c-4375ce79a436.png)
%% Cell type:code id: tags:
``` python
from jupyturtle import Turtle, make_turtle
# hier kommt Ihre Lösung hin
```
%% Cell type:code id: tags:
``` python
otto = make_turtle(width=800, height=300)
otto.jumpto(50, 250)
repeat_triangle(otto, 100, 4)
```
%% Cell type:markdown id: tags:
### Aufgabe 3
Schreiben Sie eine Funktion `pile_triangle`, die `m` gleichseitige Dreiecke übereinander zeichnet. Sie soll drei Argumente `t`, `l` und `m` erhalten. `t` ist ein turtle-Objekt, `l` gibt die Seitenlänge der Dreiecke an und `m` die Anzahl der Dreiecke. In der Funktion `pile_triangle` soll die Funktion `triangle` aus Aufgabe 1 genutzt werden. *Frewillig* : Jedes Dreieck soll eine eigene Farbe haben.
**Achtung**: Im gleichseitigen Dreieck ist die Höhe des Dreiecks gleich die halbe Seitenlänge multipliziert mit der Wurzel aus Drei.
Eine mögliche Lösung könnte so aussehen (`pile_triangle(otto, 80, 4)`):
![vertical.png](attachment:7eda1f67-2f97-4548-94a0-5c20693e69c8.png)
%% Cell type:code id: tags:
``` python
from jupyturtle import Turtle, make_turtle
# hier kommt Ihre Lösung hin
```
%% Cell type:code id: tags:
``` python
otto = make_turtle(width=800, height=600)
otto.jumpto(50, 550)
pile_triangle(otto, 100, 4)
```
%% Cell type:markdown id: tags:
### Aufgabe 4
Schreiben Sie eine Funktion `tiled_triangle`, die `n` gleicheitige Dreiecke nebeneinander und `m` gleichseitige Dreiecke übereinander zeichnet. Sie soll vier Argumente `t`, `l`, `n` und `m` erhalten. `t` ist ein turtle-Objekt, `l` gibt die Seitenlänge der Dreiecke an, `n` die Anzahl der nebeneinanderliegenden Dreiecke und `m` die Anzahl der übereinanderliegenden Dreiecke. Rufen Sie entweder die Funktion `repeat_triangle` aus Aufgabe 2 oder `pile_triangle` in Ihrer Funktion `tiled_triangle` auf. *Freiwillig* : Jedes Dreieck soll eine eigene Farbe haben.
Eine mögliche Lösung könnte so aussehen (`tiled_triangle(otto, 80, 3, 3)`):
![grid.png](attachment:45147eab-0f9a-4721-9760-5d23a667aed2.png)
%% Cell type:code id: tags:
``` python
from jupyturtle import Turtle, make_turtle
# hier kommt Ihre Lösung hin
```
%% Cell type:code id: tags:
``` python
otto = make_turtle(width=800, height=400)
otto.jumpto(50, 350)
tiled_triangle(otto, 100, 3, 3)
```
%% Cell type:markdown id: tags:
### Aufgabe 5
Stellen Sie sich vor, sie müssen `tiled_triangle` so verändern, dass die Funktion ein zusätzliches Argument erhält, nämlich die Anzahl der Ecken. (`tiled_triangle(t,l,n,m,ecken)`) Die geometrische Form (bis jetzt das Dreieck) soll also in Zukunft verallgemeinert werden. **Die Funktion selbst müssen Sie nicht schreiben.** An welchen Stellen könnte es aber Schwierigkeiten in Ihrer jetzigen Funktion geben?
%% Cell type:markdown id: tags:
-
-
-
%% Cell type:markdown id: tags:
### Aufgabe 6
Überraschen Sie mich. Seien Sie **kreativ** und malen Sie mit `turtle`, auf was Sie Lust haben :)
Es gibt einige Vorgaben, die im Code enthalten sein müssen:
- entweder eine **Schleife** oder eine **Rekursion**
- mindestens eine **if/elif/else-Bedingung**
- der Code muss in mindestens zwei **Funktionen** verkapselt sein.
Kommentieren Sie Ihren Code.
PS: Entweder schauen Sie in den Notebooks nach oder Sie nutzen Google, um sich zu inspirieren: `google python turtle drawings`.
%% Cell type:code id: tags:
``` python
from jupyturtle import Turtle, make_turtle
# hier kommt Ihre Lösung hin
```
%% Cell type:markdown id: tags:
![CC-BY-NC](https://scm.cms.hu-berlin.de/ibi/python/-/raw/master/img/cc-by-nc.png)
Dieses Notebook ist als freies Werk unter der Lizenz [Creative Commons Attribution-NonCommercial 3.0 Unported](http://creativecommons.org/licenses/by-nc/3.0/) verfügbar. Sie dürfen die Inhalte kopieren, verteilen und verändern, solange Sie die Urheber nennen und sie nicht für kommerzielle Zwecke nutzen.
notebooks/hausaufgabe3.ipynb
View file @ 9a8e896d
%% Cell type:markdown id: tags:
# 3. Hausaufgabe
Geben Sie diese Hausaufgabe gemeinsam mit Ihrem/r Partner/in ab. Füllen Sie dazu dieses Notebook aus und speichern Sie es ab (Disketten-Icon oben links). Laden Sie dann die Datei (`hausaufgabe3.ipynb`) in Moodle hoch. Verwenden Sie Kommentare im Python-Quellcode und Markdown-Textboxen im Jupyter-Notebook ([Syntax-Beispiele](https://de.wikipedia.org/wiki/Markdown#Auszeichnungsbeispiele)) um ihr Programm zu kommentieren. Für diese Hausaufgabe sollten Sie das 4. bis 6. Kapitel durchgearbeitet haben, da Rekursion, Verzweigungen und Funktionen mit Rückgabewert benötigt werden.
### Bitte lesen Sie sich die nachfolgenden Hinweise zur Hausaufgabe gut durch.
Geben Sie diese Hausaufgabe gemeinsam als Pair Programming Gruppe ab. Füllen Sie dazu dieses Notebook aus und speichern Sie es ab (Disketten-Icon oben links). Laden Sie dann die Datei unter `Hausaufgabe 3` in Moodle hoch. Für diese Hausaufgabe sollten Sie das 4. bis 6. Kapitel durchgearbeitet haben, da Rekursion, Verzweigungen und Funktionen mit Rückgabewert benötigt werden.
**Tipps und Anmerkungen**:
- Es reicht, wenn ein Gruppenmitglied die Hausaufgabe einreicht. Passen Sie auf, dass Sie in Moodle auf Abgabe drücken, damit es nicht nur ein Entwurf ist.
- Nutzen Sie http://pythontutor.com, um ihren Code nachvollziehen zu können und Fehler zu finden!
- Fügen Sie außerdem **kurze Kommentare** zu ihrem Code hinzu, mit denen Sie erklären, was die Funktion macht. Dies kann man durch zwei Varianten machen:
- inline-Kommentare (Code kommentieren): `#`
- Docstrings (Beschreibung der Funktion): `''' '''`
- für Kommentare in Markdown-Textboxen im Jupyter-Notebook: ([Syntax-Beispiele](https://de.wikipedia.org/wiki/Markdown#Auszeichnungsbeispiele))
- Bitte ändern Sie den Dateinamen ihrer Hausaufgabe zu: **hausaufgabe3_nachnamePartnerIn1_nachnamePartnerIn2.ipynb**
- z.B. `hausaufgabe3_hachmeier_jaeschke.ipynb`
- Das können Sie einfach machen, indem Sie **jetzt** oben links auf `hausaufgabe3` klicken und den neuen Namen eingeben.
- Falls Sie **generative KI** in der Hausaufgabe genutzt haben wie bspw. ChatGPT: Dokumentieren Sie Ihre Nutzung. Geben Sie **alle** Eingaben an, die Sie in der jeweiligen Aufgabe verwendet haben und beschreiben Sie, welche Änderungen Sie vor Abgabe zur Anpassung an die jeweilige Aufgabe vornehmen mussten. Testen Sie Ihre Implementierung hier besonders gründlich und kommentieren Sie **jede Codezeile** sinnvoll. Bitte beachten Sie, dass sie vollständig für den generierten Code verantwortlich sind.
- Bei (Verständnis-)Fragen können Sie mich **frühzeitig** per E-Mail oder während der Sitzungen erreichen.
Wir wünschen viel Erfolg beim Lösen der Aufgaben!
%% Cell type:markdown id: tags:
## Aufgabe 1
# Aufgabe 1
Stellen Sie sich vor, Sie spielen Schere-Stein-Papier mit ihrer Partner\*in.
Wer das Spiel nicht kennt:
Zwei Spieler\*innen müssen sich gleichzeitig für eins der drei Symbole (Schere, Stein oder Papier) entscheiden.
Der Gewinner wird folgendermaßen ermittelt:
- Stein schlägt Schere
- Schere schlägt Papier
- Papier schlägt Stein
Falls beide Spieler\*innen dasselbe Symbol ausgewählt haben, wird noch einmal gespielt.
*(Dies ist [Aufgabe 3 im 5. Kapitel](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar05.ipynb#aufgabe-3).)*
Ihre Aufgabe ist es, einen Durchlauf des Spiels zu implementieren.
Wenn uns drei Stöcke gegeben werden, kann es sein, dass wir sie als Dreieck anordnen können oder auch nicht. Wenn beispielsweise einer der Stöcke 12cm lang ist und die anderen beiden jeweils 1cm, dann klappt es nicht. Für jede Kombination von Längen gibt es einen einfachen Test, der uns anzeigt, ob sich daraus ein Dreieck formen lässt:
1. Schreiben Sie eine Funktion `schere_stein_papier`, die zwei Zeichenketten als Argumente erwartet und "Spieler\*in 1 gewinnt" oder "Spieler\*in 2 gewinnt" ausgibt, abhängig davon, ob Argument 1 gegen Argument 2 gewinnt oder umgedreht.
- Falls die **Argumente gleich** sind, soll eine Mitteilung gemacht werden, dass noch einmal gespielt werden muss.
- Decken Sie auch den Fall ab, dass ein Argument eine **andere Zeichenkette** sein kann, z.B. "Brunnen". Hier soll eine Warnung gezeigt werden, dass einer der Spieler\*innen versucht, zu betrügen.
*Falls eine der drei Längen größer als die Summe der anderen beiden Längen ist, dann lässt sich kein Dreieck formen. (Wenn die Summe der beiden Längen gleich der dritten Länge ist, dann bilden Sie ein sogenanntes "degeneriertes" Dreieck.)*
2. Schreiben Sie eine Funktion, die die **Nutzer\*in bittet, zwei Zeichenketten einzugeben** und dann die Funktion `schere_stein_papier` nutzt, um zu entscheiden, welche Spieler\*in gewonnen hat.
1. Schreiben Sie eine Funktion `is_triangle` die drei ganze Zahlen als Argumente erwartet und dann entweder "Ja" oder "Nein" ausgibt, abhängig davon, ob man mit den gegebenen Längen ein Dreieck formen kann oder nicht.
2. Schreiben Sie eine Funktion die die Nutzerin bittet, drei Längen einzugeben, diese in ganze Zahlen umwandelt und dann `is_triangle` nutzt, um zu prüfen, ob aus Stöcken mit den gegebenen Längen ein Dreieck geformt werden kann oder nicht.
3. **Freiwillig und zum Knobeln**: Schreiben Sie eine Funktion, die drei Durchläufe `schere-stein-papier` spielt und den Gesamtsieger ermittelt.
%% Cell type:code id: tags:
```
# Implementieren und testen Sie hier die beiden Funktionen
``` python
# Implementieren Sie hier die Funktionen
def schere_stein_papier(s1, s2):
pass # Diese Zeile können Sie bei der Implementierung der Funktion löschen
```
%% Cell type:code id: tags:
``` python
schere_stein_papier("Stein", "Papier") # Spieler*in 2 gewinnt
schere_stein_papier("Schere", "Papier") # Spieler*in 1 gewinnt
schere_stein_papier("Papier", "Papier") # Unentschieden
schere_stein_papier("Brunnen", "Papier") # Geschummelt!
# Rufen Sie hier Ihre Funktion mit allen möglichen Kombinationen auf,
# die in den vorherigen Aufrufen noch nicht abgedeckt wurden:
```
%% Cell type:markdown id: tags:
## Aufgabe 2
*(Dies ist [Aufgabe 4 im 5. Kapitel](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar05.ipynb#aufgabe-4).)*
Was gibt das folgende Programm aus? Zeichnen Sie (mit Stift und Papier) ein Stapeldiagramm (siehe [Abschnitt 3.9](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar03.ipynb#3-9-stapel-diagramme)), das den Zustand des Programms ausgibt, wenn `recurse(3, 0)` aufgerufen wird:
Was gibt das folgende Programm aus? Zeichnen Sie (entweder mit Stift und Papier oder in einem Markdown Feld, siehe ein Beispiel unten) ein Stapeldiagramm (siehe [Abschnitt 3.9](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar03.ipynb#3-9-stapel-diagramme)), das den Zustand des Programms ausgibt, wenn `recurse(3, 0)` aufgerufen wird:
*Hinweis: Laden Sie das digitalisierte Stapeldiagramm zusammen mit diesem Notebook in Moodle hoch. Wenn Sie wollen, können Sie auch ASCII-Textboxen direkt hier einfügen, ungefähr so:*
*Beispiel eines Stapeldiagramms für function_1, die einmal aufgerufen wurde:*
```
+------------------------------------+
function_1 | parameter_1 -> argument_1 |
| parameter_2 -> argument_2 |
+------------------------------------+
```
Für jeden Funktionsaufruf von recurse soll ein neues "Fenster" gezeichnet werden.
**Lösung:**
```
+------------------------------------+
recurse | -> |
| -> |
+------------------------------------+
...
```
%% Cell type:code id: tags:
```
``` python
def recurse(n, s):
'''
'''
if n == 0:
print(s)
else:
recurse(n-1, n+s)
recurse(3, 0)
```
%% Cell type:markdown id: tags:
1. Was würde passieren, wenn wir diese Funktion so aufrufen würden: `recurse(-1, 0)`?
## 2a
Was würde passieren, wenn wir diese Funktion so aufrufen würden: `recurse(-1, 0)`?
2. Fügen Sie einen Docstring zur Funktion hinzu, der alles erklärt, was man wissen sollte, um diese Funktion nutzen zu können (und nicht mehr!).
**Lösung**:
## 2b
Fügen Sie einen Docstring zur Funktion hinzu, der alles erklärt, was man wissen sollte, um diese Funktion nutzen zu können (und nicht mehr!). Insbesondere soll erwähnt werden, welche Eigenschaften die Parameter haben müssen.
*Hinweis: Laden Sie das digitalisierte Stapeldiagramm zusammen mit diesem Notebook in Moodle hoch. Wenn Sie wollen, können Sie auch ASCII-Textboxen direkt hier einfügen, ungefähr so:*
```
+----------------------------------------+
__main__ | teil1 -> 'Holleri du dödel di ' |
| teil2 -> 'diri diri dudel dö' |
+----------------------------------------+
```
%% Cell type:markdown id: tags:
## Aufgabe 3
*(Das ist [Aufgabe 4 im 6. Kapitel](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar06.ipynb#aufgabe-4).)*
Eine ganze Zahl `a` ist eine Potenz von `b`, wenn `a` durch `b` teilbar ist und `a/b` eine Potenz von `b` ist. (Beispielsweise ist 27 eine Potenz von 3, denn 27 ist durch 3 teilbar und 9 ist eine Potenz von 3.) Schreiben Sie eine Funktion `is_power` die Parameter `a` und `b` erwartet und `True` zurückgibt, wenn `a` eine Potenz von `b` ist (ansonsten `False`). Hinweis: Überlegen Sie sich, was der Basisfall ist und wie Sie diesen behandeln.
Eine ganze Zahl `a` ist eine Potenz von `b`, wenn `a` durch `b` teilbar ist und `a/b` eine Potenz von `b` ist. (Beispielsweise ist 27 eine Potenz von 3, denn 27 ist durch 3 teilbar und 9 ist eine Potenz von 3.) Schreiben Sie eine Funktion `ist_potenz` die Parameter `a` und `b` erwartet und `True` zurückgibt, wenn `a` eine Potenz von `b` ist (ansonsten `False`).
Sie dürfen die Code aus Kapitel 6 übernehmen. Beantworten Sie dazu folgende Fragen:
- Was ist die Abbruchbedingung/ der Basisfall?
- **Lösung**:
- Markieren Sie im Code, an welchen Stellen der Basisfall definiert wird
- Markieren Sie im Code, an welcher Stelle der rekursive Aufruf stattfindet
- Wieviele unterschiedliche Rückgabewerte sind möglich? Welche Rückgabewerte gibt es?
- **Lösung**:
- Rufen Sie die Funktion `ist_potenz` mit verschiedenen Argumenten so auf, dass die verschiedenen Abbruchbedingungen mindestens einmal durchlaufen werden. Rufen Sie die Funktion außerdem so auf, dass jeder Rückgabewert mindestens einmal herauskommt.
%% Cell type:code id: tags:
```
# Implementieren und testen Sie hier ihre Funktion
``` python
def ist_potenz(a,b):
```
%% Cell type:code id: tags:
``` python
```
%% Cell type:markdown id: tags:
## Aufgabe 4
Ziel dieser Aufgabe ist, eine ASCII-Tabelle für die Zeichen mit dem Code von 32 (dezimal) bis 127 (dezimal) mit den zugehören Hexadezimalcodes auszugeben. Das Ergebnis sollte so aussehen:
```
20 21 ! 22 " 23 # 24 $ 25 % 26 & 27 ' 28 ( 29 ) 2a * 2b + 2c , 2d - 2e . 2f /
30 0 31 1 32 2 33 3 34 4 35 5 36 6 37 7 38 8 39 9 3a : 3b ; 3c < 3d = 3e > 3f ?
40 @ 41 A 42 B 43 C 44 D 45 E 46 F 47 G 48 H 49 I 4a J 4b K 4c L 4d M 4e N 4f O
50 P 51 Q 52 R 53 S 54 T 55 U 56 V 57 W 58 X 59 Y 5a Z 5b [ 5c \ 5d ] 5e ^ 5f _
60 ` 61 a 62 b 63 c 64 d 65 e 66 f 67 g 68 h 69 i 6a j 6b k 6c l 6d m 6e n 6f o
70 p 71 q 72 r 73 s 74 t 75 u 76 v 77 w 78 x 79 y 7a z 7b { 7c | 7d } 7e ~
```
Lesen Sie sich den Exkurs am Anfang des [5. Kapitels](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar05.ipynb) durch und versuchen Sie zu verstehen, wie die Funktion `dez_zu_allem` funktioniert. Dazu sollte es reichen, die Funktion mit verschiedenen Eingaben aufzurufen und zu verstehen, wie die jeweilige Ausgabe mit der Eingabe zusammenhängt. (Der Parameter `s` stellt das Alphabet für ein Positionssystem dar, wobei alle Zeichen einfach hintereinander als Zeichenkette erwartet werden.)
Lesen Sie sich den Exkurs am Anfang des [7. Kapitels](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar07.ipynb) durch und **versuchen Sie zu verstehen, wie die Funktion `dez_zu_allem` funktioniert**. Dazu sollte es reichen, die Funktion mit verschiedenen Eingaben aufzurufen und zu verstehen, wie die jeweilige Ausgabe mit der Eingabe zusammenhängt. (Der Parameter `s` stellt das Alphabet für ein Positionssystem dar, wobei alle Zeichen einfach hintereinander als Zeichenkette erwartet werden.)
Kopieren Sie sich die Funktion `dez_zu_allem` hierher und rufen Sie sie mit dem Dezimalcode für das Zeichen 'B' auf (diesen finden Sie in der ASCII-Tabelle aus der Vorlesung), so dass der Wert als Hexadezimalzahl zurückgegeben wird. Geben Sie diese Hexadezimalzahl mit `print` aus. (Es sollte '42' ausgegeben werden.)
Rufen Sie die Funktion mit dem Dezimalcode für das Zeichen 'B' auf (diesen finden Sie in der ASCII-Tabelle aus der Vorlesung), so dass der Wert als Hexadezimalzahl zurückgegeben wird. Geben Sie diese Hexadezimalzahl mit `print` aus. (Es sollte '42' ausgegeben werden.)
%% Cell type:code id: tags:
```
# Fügen Sie hier dez_zu_allem sowie Ihren Testcode ein
``` python
# Hilfsfunktion aus Kapitel 7,
def dez_zu_allem(n, s):
if n == 0:
return ""
return dez_zu_allem(n // len(s), s) + s[n % len(s)]
```
%% Cell type:markdown id: tags:
Mit der Funktion `chr` können wir Dezimalzahlen zwischen 0 und 127 in das entsprechende ASCII-Zeichen (als Zeichenkette) umwandeln. Probieren Sie es aus, indem Sie mit Hilfe von `chr` das Zeichen mit dem (dezimalen) ASCII-Code 84 ausgeben. (Es sollte `T` ausgegeben werden.)
%% Cell type:code id: tags:
```
``` python
# Fügen Sie hier Ihren Code ein
```
%% Cell type:markdown id: tags:
Schreiben Sie jetzt eine Funktion `zeichentabelle`, die folgende Parameter erwartet:
- `anfang`: die Dezimalzahl des ASCII-Codes des ersten Zeichens, welches ausgegeben werden soll
- `ende`: die Dezimalzahl des ASCII-Codes des letzten Zeichens, welches ausgegeben werden soll
- `trennzeichen`: eine Zeichenkette, die als Trennzeichen zwischen zwei Code-Zeichen-Paaren ausgegeben werden soll
- `paare_pro_zeile`: die Anzahl an Code-Zeichen-Paaren die pro Zeile ausgegeben werden sollen
Die Funktion soll mit Hilfe einer `for`-Schleife und der `range`-Funktion über alle Dezimalzahlen zwischen `anfang` und `ende` (jeweils inklusive) laufen und den Hexadezimalcode sowie das zugehörige Zeichen durch Leerzeichen getrennt ausgeben. Danach soll das `trennzeichen` ausgegeben werden und nach entsprechend vielen Paaren soll eine neue Zeile erzeugt werden.
Hinweis: Sie können bei der `print`-Funktion die Ausgabe eines Zeilenumbruchs unterdrücken, indem Sie dem Parameter `end` einen anderen Wert mitgeben, beispielsweise so:
%% Cell type:code id: tags:
```
``` python
print("Spalte 1", end=" | ")
print("Spalte 2", end=" | ")
print("Spalte 3")
```
%% Cell type:code id: tags:
```
# Implementieren Sie hier die Funktion
def zeichentabelle ...
``` python
def zeichentabelle(anfang, ende, trennzeichen, paare_pro_zeile):
pass # löschen Sie diese Anweisung, wenn Sie anfangen, die Funktion zu implementieren
# Testaufruf, der die Tabelle oben erzeugen sollte
```
%% Cell type:code id: tags:
``` python
zeichentabelle(32, 127, " ", 16)
```
%% Cell type:code id: tags:
``` python
zeichentabelle(32, 127, " ", 10)
```
%% Cell type:markdown id: tags:
Hier folgen weitere Tipps ... versuchen Sie es aber erst einmal ohne diese Tipps.
<a data-flickr-embed="true" href="https://www.flickr.com/photos/jasoneppink/4964471335" title="Spoiler Alert"><img src="https://farm5.staticflickr.com/4110/4964471335_1f86a923f3_n.jpg" width="320" height="213" alt="Spoiler Alert"></a><script async src="//embedr.flickr.com/assets/client-code.js" charset="utf-8"></script>
Der Restoperator `%` kann Ihnen helfen, im richtigen Rhythmus Zeilenumbrüche einzufügen.
<a data-flickr-embed="true" href="https://www.flickr.com/photos/jasoneppink/4964471335" title="Spoiler Alert"><img src="https://farm5.staticflickr.com/4110/4964471335_1f86a923f3_n.jpg" width="320" height="213" alt="Spoiler Alert"></a><script async src="//embedr.flickr.com/assets/client-code.js" charset="utf-8"></script>
Sie müssen den Rest der aktuellen Zahl bei Division durch `paare_pro_zeile` prüfen.
<a data-flickr-embed="true" href="https://www.flickr.com/photos/jasoneppink/4964471335" title="Spoiler Alert"><img src="https://farm5.staticflickr.com/4110/4964471335_1f86a923f3_n.jpg" width="320" height="213" alt="Spoiler Alert"></a><script async src="//embedr.flickr.com/assets/client-code.js" charset="utf-8"></script>
Es ist etwas knifflig, die Zeilen mit dem richtigen Wert beginnen zu lassen (im Beispiel `20`, `30`, `40`). Das ist ganz normal und sie müssen etwas probieren, um das zu schaffen.
<a data-flickr-embed="true" href="https://www.flickr.com/photos/jasoneppink/4964471335" title="Spoiler Alert"><img src="https://farm5.staticflickr.com/4110/4964471335_1f86a923f3_n.jpg" width="320" height="213" alt="Spoiler Alert"></a><script async src="//embedr.flickr.com/assets/client-code.js" charset="utf-8"></script>
Probieren Sie verschiedene Werte für den Rest durch, dann sollte es klappen.
Da Python Unicode unterstützt können mit der `chr`-Funktion alle Zeichen aus dem Unicode-Vorrat ausgegeben werden. Probieren Sie es einmal mit Zahlen größer als 127 aus:
%% Cell type:code id: tags:
```
``` python
print(chr(2000))
print(chr(4000))
print(chr(8000))
print(chr(16000))
print(chr(32000))
print(chr(64000))
```
%% Cell type:markdown id: tags:
*(Nicht alle Zahlenwerte funktionieren, nur diejenigen, die auch im Unicode definiert sind.)*
Finden Sie den Dezimalwert (!) für das Zeichen `ä` im Unicode (nicht UTF-8) und geben Sie dieses mittels `chr` aus. Es kann sein, dass Sie nur den Hexadezimalwert finden - diesen müssten sie dann zunächst in einen Dezimalwert umrechnen, z.B. auf [dieser Webseite](http://www.binaryhexconverter.com/hex-to-decimal-converter).
Und wenn Sie bis hierher gekommen sind: geben Sie eine Tabelle von Zeichen aus einem anderen Schriftsystem Ihrer Wahl aus, indem Sie Ihre Funktion `zeichentabelle` mit anderen Start- und Endwerten aufrufen:
%% Cell type:code id: tags:
```
chr(228)
``` python
```
%% Cell type:markdown id: tags:
Und wenn Sie bis hierher gekommen sind: geben Sie eine Tabelle von Zeichen aus einem anderen Schriftsystem Ihrer Wahl aus, indem Sie Ihre Funktion `zeichentabelle` mit größeren Start- und Endwerten aufrufen:
%% Cell type:code id: tags:
```
```
![Smiley](https://upload.wikimedia.org/wikipedia/commons/0/0f/Face-glasses.svg)
%% Cell type:markdown id: tags:
![Smiley](https://upload.wikimedia.org/wikipedia/commons/0/0f/Face-glasses.svg)
![CC-BY-NC](https://scm.cms.hu-berlin.de/ibi/python/-/raw/master/img/cc-by-nc.png)
Dieses Notebook ist als freies Werk unter der Lizenz [Creative Commons Attribution-NonCommercial 3.0 Unported](http://creativecommons.org/licenses/by-nc/3.0/) verfügbar. Sie dürfen die Inhalte kopieren, verteilen und verändern, solange Sie die Urheber nennen und sie nicht für kommerzielle Zwecke nutzen.
......
notebooks/hausaufgabe4.ipynb
View file @ 9a8e896d
%% Cell type:markdown id: tags:
# 4. Hausaufgabe
Geben Sie diese Hausaufgabe gemeinsam mit Ihrem/r Partner/in ab. Füllen Sie dazu dieses Notebook aus und speichern Sie es ab (Disketten-Icon oben links). Laden Sie dann die Datei (`hausaufgabe4.ipynb`) in Moodle hoch. Verwenden Sie Kommentare im Python-Quellcode und Markdown-Textboxen im Jupyter-Notebook ([Syntax-Beispiele](https://de.wikipedia.org/wiki/Markdown#Auszeichnungsbeispiele)) um ihr Programm zu kommentieren. Für diese Hausaufgabe sollten Sie alles bis zum 7. Kapitel durchgearbeitet haben, da Iteration, Rekursion, Verzweigungen und Funktionen mit Rückgabewert benötigt werden.
### Bitte lesen Sie sich die nachfolgenden Hinweise zur Hausaufgabe gut durch.
Geben Sie diese Hausaufgabe gemeinsam als Pair Programming Gruppe ab. Füllen Sie dazu dieses Notebook aus und speichern Sie es ab (Disketten-Icon oben links). Laden Sie dann die Datei unter `Hausaufgabe 4` in Moodle hoch. Für diese Hausaufgabe sollten Sie alles bis zum 10. Kapitel durchgearbeitet haben, da Iteration, Rekursion, Verzweigungen und Funktionen mit Rückgabewert benötigt werden.
**Tipps und Anmerkungen**:
- Es reicht, wenn ein Gruppenmitglied die Hausaufgabe einreicht. Passen Sie auf, dass Sie in Moodle auf Abgabe drücken, damit es nicht nur ein Entwurf ist.
- Nutzen Sie http://pythontutor.com, um ihren Code nachvollziehen zu können und Fehler zu finden!
- Fügen Sie außerdem **kurze Kommentare** zu ihrem Code hinzu, mit denen Sie erklären, was die Funktion macht. Dies kann man durch zwei Varianten machen:
- inline-Kommentare (Code kommentieren): `#`
- Docstrings (Beschreibung der Funktion): `''' '''`
- für Kommentare in Markdown-Textboxen im Jupyter-Notebook: ([Syntax-Beispiele](https://de.wikipedia.org/wiki/Markdown#Auszeichnungsbeispiele))
- Bitte ändern Sie den Dateinamen ihrer Hausaufgabe zu: **hausaufgabe4_nachnamePartnerIn1_nachnamePartnerIn2.ipynb**
- z.B. `hausaufgabe4_hachmeier_jaeschke.ipynb`
- Das können Sie einfach machen, indem Sie **jetzt** oben links auf `hausaufgabe4` klicken und den neuen Namen eingeben.
- Falls Sie **generative KI** in der Hausaufgabe genutzt haben wie bspw. ChatGPT: Dokumentieren Sie Ihre Nutzung. Geben Sie **alle** Eingaben an, die Sie in der jeweiligen Aufgabe verwendet haben und beschreiben Sie, welche Änderungen Sie vor Abgabe zur Anpassung an die jeweilige Aufgabe vornehmen mussten. Testen Sie Ihre Implementierung hier besonders gründlich und kommentieren Sie **jede Codezeile** sinnvoll. Bitte beachten Sie, dass sie vollständig für den generierten Code verantwortlich sind.
- Falls es **Musterlösungen in den Übungen** gibt, können Sie gerne diese Code übernehmen (eigener Code ist natürlich schöner). Falls Sie das machen, muss aber durch **Ihre Kommentare** hervorgehen, dass Sie den Code verstanden haben.
- Bei (Verständnis-)Fragen können Sie mich **frühzeitig** per E-Mail oder während der Sitzungen erreichen.
Wir wünschen viel Erfolg beim Lösen der Aufgaben!
%% Cell type:markdown id: tags:
## Aufgabe 1
*(Dies ist [Aufgabe 1 im 7. Kapitel](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar07.ipynb#aufgabe-1).)*
Implementieren Sie die folgenden Funktionen und rufen Sie ihre Funktionen mit verschiedenen Argumenten auf, um sie auf Funktionalität zu testen.
Kopieren Sie die Schleife aus [Abschnitt 7.5](seminar07.ipynb#7.5-Quadratwurzeln) und verkapseln Sie sie in eine Funktion `mysqrt` die einen Parameter `a` erwartet, einen sinnvollen Wert für `x` wählt und eine Näherung für die Quadratwurzel von `a` zurückliefert.
### 1a
Schreiben Sie eine Funktion, die als Parameter eine Zeichenkette erwartet und prüft, ob das erste Zeichen der Zeichenkette ein Kleinbuchstaben ist. Die Funktion soll einen Wahrheitswert zurückgeben.
%% Cell type:code id: tags:
```
# Implementieren Sie hier die Funktion mysqrt
``` python
def is_lower_first_char(s):
pass
# Testen Sie hier die Funktion
print("Die Wurzel von 2 ist ungefähr ", mysqrt(2))
print("Die Wurzel von 23 ist ungefähr ", mysqrt(23))
is_lower_first_char("Test")
is_lower_first_char("test")
is_lower_first_char("tEST")
is_lower_first_char("TESt")
is_lower_first_char("TesT")
```
%% Cell type:markdown id: tags:
Testen Sie die Funktion, indem Sie eine Funktion `test_square_root` schreiben, die eine Tabelle der folgenden Art ausgibt:
```
a mysqrt(a) math.sqrt(a) diff
- --------- ------------ ----
1.0 1.0 1.0 0.0
2.0 1.41421356237 1.41421356237 2.22044604925e-16
3.0 1.73205080757 1.73205080757 0.0
4.0 2.0 2.0 0.0
5.0 2.2360679775 2.2360679775 0.0
6.0 2.44948974278 2.44948974278 0.0
7.0 2.64575131106 2.64575131106 0.0
8.0 2.82842712475 2.82842712475 4.4408920985e-16
9.0 3.0 3.0 0.0
```
### 1b
Dabei ist die erste Spalte eine Zahl, `a`; die zweite Spalte ist die Quadratwurzel von `a` die mit `mysqrt` berechnet wurde; die dritte Spalte ist die Quadratwurzel, die mittels `math.sqrt` berechnet wurde; und die vierte Spalte ist der Absolutbetrag des Unterschieds zwischen den beiden Werten.
Schreiben Sie eine Funktion, die als Parameter eine Zeichenkette erwartet und prüft, ob das erste **oder** das letzte Zeichen Kleinbuchstaben sind. Die Funktion soll einen Wahrheitswert zurückgeben.
%% Cell type:code id: tags:
```
def test_square_root():
# Implementieren Sie hier die Funktion test_square_root
``` python
def is_lower_first_last_char(s):
pass
# Rufen Sie hier die Funktion test_square_root auf
test_square_root()
is_lower_first_last_char("Test")
is_lower_first_last_char("test")
is_lower_first_last_char("tEST")
is_lower_first_last_char("TESt")
is_lower_first_last_char("TesT")
```
%% Cell type:markdown id: tags:
## Aufgabe 2
### 1c
Schreiben Sie eine Funktion, die als Parameter eine Zeichenkette erwartet und prüft, ob **alle** Zeichen der Zeichenkette Ziffern (0,...,9) sind. Die Funktion soll einen Wahrheitswert zurückgeben.
*(Dies ist [Aufgabe 2 im 7. Kapitel](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar07.ipynb#aufgabe-2).)*
%% Cell type:code id: tags:
Die eingebaute Funktion `eval` erwartet eine Zeichenkette und führt sie dann mit dem Python-Interpreter aus. Beispielsweise:
``` python
def is_number(s):
pass
%% Cell type:code id: tags:
```
eval('1 + 2 * 3')
is_number("9847")
is_number("9.312")
is_number("T238ws")
is_number("+4917600011100")
is_number("0049176-00011100")
is_number("004917600011100")
```
%% Cell type:markdown id: tags:
### 1d
Schreiben Sie jeweils eine Funktion, die als Parameter eine Zeichenkette erwartet und alle Ziffern innerhalb einer Zeichenkette ausgibt.
%% Cell type:code id: tags:
```
import math
eval('math.sqrt(5)')
``` python
def return_digits(s):
pass
return_digits("123123")
return_digits("9847")
return_digits("9.312")
return_digits("T238ws")
return_digits("Die Hausaufgabenabgabe ist am 13.Februar 2022.")
return_digits("Und zwar vor 00:00.")
```
%% Cell type:markdown id: tags:
### 1e
Schreiben Sie eine Funktion, die als Parameter zwei Zeichenketten `s` und `w` erwartet und **alle** Vorkommen von `w` innerhalb von `s` zählt. Hierbei soll Groß-/Kleinschreibung ignoriert werden.
Hinweis: Falls das Wort *USA* gefunden werden soll, sollen auch *usa, Usa, uSa*, usw. gefunden werden.
%% Cell type:code id: tags:
```
eval('type(math.pi)')
``` python
def count_occ(s, w):
pass
count_occ("Yippie yippie Yeah YiPPIE Yeah, Krawall und Remmi Demmi! Yippi YIPI Yeah YIPPIE Yeah, Krawall und Remmi Demmi!", "yippie")
```
%% Cell type:markdown id: tags:
Schreiben Sie eine Funktion `eval_loop`, die den Nutzer iterativ bittet etwas einzugeben, die eingegebene Zeichenkette mittels `eval` ausführt und schließlich das Ergebnis ausgibt.
## Aufgabe 2
Schreiben Sie eine Funktion, die eine Zeichenkette als Parameter erwartet und die Zeichenkette folgendermaßen ändert.Nutzen Sie dafür **nur** [eingebauten Methoden ("built-in methods")](https://docs.python.org/3/library/stdtypes.html#string-methods), für jeden Task eine neue.
Die Funktion sollte so lange laufen, bis der Nutzer `fertig` eingibt und dann sollte der Rückgabewert des letzten ausgeführten Ausdrucks ausgegeben werden.
- Alle Leerzeichen am Anfang und Ende der Zeichenkette sollen gelöscht werden
- Alle Minus-Zeichen ("-") sollen durch Unterstriche ("_") ersetzt werden
- Der gesamte Text soll nur noch aus Kleinbuchstaben bestehen
%% Cell type:code id: tags:
```
# Implementieren Sie hier die Funktion eval_loop
``` python
def process_text(s):
pass
process_text(" The function Return-Digits(S) returns all digits of a string. BELIEVE ME. ... ")
```
%% Cell type:markdown id: tags:
## Aufgabe 3
Ziel dieser Aufgabe ist, dass Sie üben, fremden Code zu lesen, zu verstehen und zu verändern.
In [Aufgabe 3 im 7. Kapitel](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar07.ipynb#aufgabe-3) wird eine Methode zur näherungsweisen Berechnung von $\pi$ vorgestellt, einschließlich des [Quellcodes](http://thinkpython2.com/code/pi.py). Verändern Sie diesen Quellcode, so dass stattdessen die Näherungsformel
Schreiben Sie eine Funktion, die als Parameter zwei Listen `l` und `d` erwartet und **alle** Elemente aus der Liste `l`, die auch in `d` vorkommen, löscht. Die Rückgabe soll die modifizierte Liste `l` sein.
\begin{equation}
\pi = \sqrt{12}\sum^\infty_{k=0} \frac{(-3)^{-k}}{2k+1} = \sqrt{12}\sum^\infty_{k=0} \frac{(-\frac{1}{3})^k}{2k+1}
\end{equation}
zur Berechnung von $\pi$ verwendet wird ([Madhava–Leibniz Folge](https://en.wikipedia.org/wiki/Approximations_of_%CF%80#Middle_Ages)). Kommentieren Sie Ihren Quellcode in eigenen Worten (auf Deutsch) und entfernen Sie jeglichen Code, der nicht zur Berechnung benötigt wird.
%% Cell type:code id: tags:
```
# Implementieren und testen Sie hier ihre Funktion
``` python
def del_elements(l, d):
pass
print(estimate_pi())
del_elements([1,3,5,7,9,11,13,15,17,19,21,23,25,27,29], [9,15,21,25])
```
%% Cell type:markdown id: tags:
![Smiley](https://upload.wikimedia.org/wikipedia/commons/0/0f/Face-glasses.svg)
%% Cell type:markdown id: tags:
![CC-BY-NC](https://scm.cms.hu-berlin.de/ibi/python/-/raw/master/img/cc-by-nc.png)
Dieses Notebook ist als freies Werk unter der Lizenz [Creative Commons Attribution-NonCommercial 3.0 Unported](http://creativecommons.org/licenses/by-nc/3.0/) verfügbar. Sie dürfen die Inhalte kopieren, verteilen und verändern, solange Sie die Urheber nennen und sie nicht für kommerzielle Zwecke nutzen.
......
notebooks/markdown_cheatsheet.ipynb 0 → 100644
View file @ 9a8e896d
%% Cell type:markdown id: tags:
# Markdown cheat sheet
%% Cell type:markdown id: tags:
## Markdown Zellen
Eine Markdown-Zelle (oder Text-Zelle oder HTML-Zelle) in Jupyter-Notebook ist im Gegensatz zu einer Code-Zelle eine Zelle, deren Inhalt nicht aus Code bestehen soll und auch nicht vom Python Interpreter ausgeführt werden kann.
Stattdessen soll in diesen Zellen Text (Theorie, Aufgaben, Notizen und verschriftliche Lösungen) stehen. Diesen Text kann man auf verschiedene Weise strukturieren und übersichtlich gestalten. Im Folgenden werden dazu verschieden Möglichkeiten gezeigt.
Die jeweiligen Beispiele kann man natürlich nur sehen, wenn man in den Editormodus der Zelle springt.
<hr style="border:2px solid gray"> </hr>
%% Cell type:markdown id: tags:
## 1. Überschriften
Überschriften kann man über das **Rauten-Symbol (#)** darstellen.
Dazu fügt man einfach am Anfang der Zeile eine (oder mehrer) Rauten hinzu.
Je mehr Rautensymbole man hinzufügt, desto kleiner wird die Schrift. Zwischen der letzten Raute und dem anschließenden Text muss ein Leerzeichen stehen.
Syntax:
`# Text`
Beispiele:
# Text (1)
## Text (2)
### Text (3)
#### Text (4)
<hr style="border:2px solid gray"> </hr>
%% Cell type:markdown id: tags:
## 2. Aufzählungen
Aufzählungen sind durch das **Minus-, Plus- oder Multiplikationssymbol** möglich. Im Editiermodus werden die Aufzählungen farbig gekennzeichnet.
Syntax:
`- Text`
`+ Text`
`* Text`
Beispiel:
- Text (1)
- Text (2)
Durch die Tab-Taste kann man zusätzlich **Aufzählungen verschachteln**.
Die verschachtelten Aufzählungen bekommen verschiedene Aufzählungszeichen und werden im Editiermodus farbig gekennzeichnet.
Syntax:
<pre>
- Text
- Text
</pre>
Beispiel:
- Text (1)
- Text (2)
Zudem kann man die **Aufzählungen auch nummerieren**.
Syntax:
`1. Text`
`2. Text`
Beispiel
1. Text
2. Text
<hr style="border:2px solid gray"> </hr>
%% Cell type:markdown id: tags:
## 3. Schriftauszeichnung
Es gibt verschiedene Möglichkeiten, Textteile innerhalb eines Textes auszuzeichnen oder hervorzuheben.
**Fettgedruckt**:
- Syntax: `**Text**`
- Beispiel: **Text**
*Kursiv*:
- Syntax: `*Text*`
- Beispiel: *Text*
~~Durchgestrichen~~:
- Syntax: `~~Text~~`
- Beispiel: ~~Text~~
`Hervorheben`:
- Syntax: `` ` ``Text`` ` ``
- Beispiel: `Text`
<hr style="border:2px solid gray"> </hr>
#### Zusätzlich kann man HTML code nutzen:
<u>Unterstrichen</u>:
- Syntax: `<u>` Text `</u>`
- Beispiel: <u> Text </u>
<font color = green>Farbig</font>:
- Syntax: ` <font color = red>` Text `</font>`
- Beispiel: <font color = red>Text</font>
- Farbauswahl: red, yellow, blue, orange, purple, etc.
<font color = #ff0000>Farbig (#rrggbb)</font>:
- Syntax:`<font color = #ff0000>` Text `</font>`
- Beispiel:<font color = #ff16f0>Text</font>
- Farbauswahl: alle rgb Farben (Code #rrggbb)
<span style="color: rgb(250,100,0)">Farbig mit span-Befehl</span>:
- Syntax: `<span style="color: rgb(255,0,0)">` Text `</span>`
- Beispiel:<span style="color: rgb(0,0,255)">Text</span>
- Farbauswahl: alle rgb Farben ([0-255],[0-255],[0-255])
<span style="background-color:rgb(150,150,50)">Hintergrundfarbe </span>:
- Syntax:`<font color = #ff0000>` Text `</font>`
- Beispiel:<font color = #ff16f0>Text</font>
<hr style="border:2px solid gray"> </hr>
%% Cell type:markdown id: tags:
## 4. Noch mehr Möglichkeiten
#### Zeilenumbrüche
Zeilenumbrüche funktionieren einfach durch zwei Leerzeichen hinter dem letzten Buchstaben in der Zeile oder durch den Befehl `<br>`
Syntax:
`Text <br>`
Beispiel:
Text
Text <br>
Text
<hr style="border:2px solid gray"> </hr>
#### Absätze
Absätze funktionieren durch eine leere Zeile zwischen den Texten.
Syntax:
`Text`
` `
`Text`
Beispiel:
Text
Text
<hr style="border:2px solid gray"> </hr>
#### Horizontale Linien
Drei Sterne, Minus, oder Unterstriche ergeben eine graue horizontale Linie:
Syntax:
`***`
`---`
`___`
Beispiel:
***
---
___
Um dickere Linien zu erzeugen, braucht man html Code:
Syntax:
`<hr style="border:2px solid gray"> </hr>`
<hr style="border:2px solid gray"> </hr>
#### Python Code anzeigen
Manchmal möchte man Python-Code einfach in einer Notiz festhalten und ihn deswegen in eine Markdown-Zelle schreiben. Dort kann er nicht ausgeführt werden.
Syntax:
`` ``` ``
Python-Code (Zeile 1)
Python Code (Zeile 2)
`` ``` ``
Beispiel:
```
for i in range(10):
print(i)
```
<hr style="border:2px solid gray"> </hr>
#### Zitieren/ Einrücken:
Durch das Zeichen `>` könnt ihr einen Text einrücken und abgrenzen.
Syntax :
`>`
Beispiel:
> Text
<hr style="border:2px solid gray"> </hr>
#### mathematische Formeln
Mathematische Formeln können durch zwischen zwei Dollarzeichen dargestellt werden.
Syntax:
`$` Formel `$`
Beispiel:
$f(x)= ax² +bx +c$
<hr style="border:2px solid gray"> </hr>
#### Links
Syntax:
`[beschreibender Text der Seite](url)`
Beispiel:
[Das ist die moodle Seite des Programmierkurses](https://moodle.hu-berlin.de/course/view.php?id=97747)
<hr style="border:2px solid gray"> </hr>
#### Tabellen
Man kann auch Tabellen erstellen. Eine senkrechter Strich `|` teilt die Spalten ein, Minus zwischen den senkrechten Strichen sind für die horizontalen Reihen.
Es muss in **jeder Reihe dieselbe Anzahl an senkrechten Strichen** geben.
Syntax:
`Spalte1 | Spalte2 | Spalte3`
`--- | --- | ---`
`Text | Text | Text`
Beispiel:
Spalte1 | Spalte2 | Spalte3
-| -| -
~~Text~~| *Text* | **Text**
~~Text~~| *Text* | **Text**
~~Text~~| *Text* | **Text**
%% Cell type:markdown id: tags:
![CC-BY-NC](https://scm.cms.hu-berlin.de/ibi/python/-/raw/master/img/cc-by-nc.png)
Dieses Notebook ist als freies Werk unter der Lizenz [Creative Commons Attribution-NonCommercial 3.0 Unported](http://creativecommons.org/licenses/by-nc/3.0/) verfügbar. Sie dürfen die Inhalte kopieren, verteilen und verändern, solange Sie die Urheber nennen und sie nicht für kommerzielle Zwecke nutzen.
notebooks/pics/pile_triangle.png 0 → 100644
View file @ 9a8e896d
notebooks/pics/pile_triangle.png

2.27 KiB

notebooks/pics/repeat_triangle.png 0 → 100644
View file @ 9a8e896d
notebooks/pics/repeat_triangle.png

1.53 KiB

notebooks/pics/string_indices.svg 0 → 100644
View file @ 9a8e896d
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->
<svg
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:cc="http://creativecommons.org/ns#"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:svg="http://www.w3.org/2000/svg"
xmlns="http://www.w3.org/2000/svg"
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
width="90.216782mm"
height="23.421494mm"
viewBox="0 0 90.216782 23.421493"
version="1.1"
id="svg8"
inkscape:version="0.92.2 5c3e80d, 2017-08-06"
sodipodi:docname="string_indices.svg">
<defs
id="defs2">
<marker
inkscape:stockid="Arrow2Mend"
orient="auto"
refY="0"
refX="0"
id="Arrow2Mend"
style="overflow:visible"
inkscape:isstock="true">
<path
id="path4569"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
transform="scale(-0.6)"
inkscape:connector-curvature="0" />
</marker>
<marker
inkscape:stockid="Arrow1Send"
orient="auto"
refY="0"
refX="0"
id="Arrow1Send"
style="overflow:visible"
inkscape:isstock="true">
<path
id="path4557"
d="M 0,0 5,-5 -12.5,0 5,5 Z"
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.00000003pt;stroke-opacity:1"
transform="matrix(-0.2,0,0,-0.2,-1.2,0)"
inkscape:connector-curvature="0" />
</marker>
</defs>
<sodipodi:namedview
id="base"
pagecolor="#ffffff"
bordercolor="#666666"
borderopacity="1.0"
inkscape:pageopacity="0.0"
inkscape:pageshadow="2"
inkscape:zoom="2.7149036"
inkscape:cx="130.19211"
inkscape:cy="29.608807"
inkscape:document-units="mm"
inkscape:current-layer="layer1"
showgrid="false"
inkscape:window-width="1440"
inkscape:window-height="855"
inkscape:window-x="0"
inkscape:window-y="1"
inkscape:window-maximized="1"
fit-margin-top="0"
fit-margin-left="0"
fit-margin-right="0"
fit-margin-bottom="0" />
<metadata
id="metadata5">
<rdf:RDF>
<cc:Work
rdf:about="">
<dc:format>image/svg+xml</dc:format>
<dc:type
rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
<dc:title />
</cc:Work>
</rdf:RDF>
</metadata>
<g
inkscape:label="Ebene 1"
inkscape:groupmode="layer"
id="layer1"
transform="translate(-16.045178,-42.890053)">
<rect
style="opacity:1;fill:#a9aaff;fill-opacity:1;stroke:#000000;stroke-width:0.54548609;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
id="rect4886"
width="89.671295"
height="14.243092"
x="16.317921"
y="43.162796" />
<text
xml:space="preserve"
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:6.85094547px;line-height:100%;font-family:'DejaVu Sans Mono';-inkscape-font-specification:'DejaVu Sans Mono';text-align:center;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.57091236px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
x="75.100517"
y="56.787315"
id="text4487"
transform="scale(1.0377083,0.96366194)"><tspan
sodipodi:role="line"
id="tspan4485"
x="75.100517"
y="56.787315"
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12.17945766px;font-family:Arial;-inkscape-font-specification:Arial;stroke-width:0.57091236px">&quot;banana&quot;</tspan></text>
<text
xml:space="preserve"
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:6.53554153px;line-height:100%;font-family:'DejaVu Sans Mono';-inkscape-font-specification:'DejaVu Sans Mono';text-align:center;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.54462844px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
x="27.685129"
y="52.778156"
id="text4491"><tspan
sodipodi:role="line"
id="tspan4489"
x="27.685129"
y="52.778156"
style="stroke-width:0.54462844px;-inkscape-font-specification:Arial;font-family:Arial;font-weight:normal;font-style:normal;font-stretch:normal;font-variant:normal">fruit</tspan></text>
<path
style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.54548609;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:1.09097222, 0.54548611;stroke-dashoffset:0;stroke-opacity:1"
d="M 56.353885,43.112153 V 61.127172"
id="path4493"
inkscape:connector-curvature="0" />
<path
style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.54548609;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:1.09097222, 0.54548611;stroke-dashoffset:0;stroke-opacity:1"
d="M 64.013814,43.112153 V 61.127172"
id="path4493-2"
inkscape:connector-curvature="0" />
<path
style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.54548609;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:1.09097222, 0.54548611;stroke-dashoffset:0;stroke-opacity:1"
d="M 70.751714,43.112153 V 61.127175"
id="path4493-6"
inkscape:connector-curvature="0" />
<path
style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.54548609;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:1.09097222, 0.54548611;stroke-dashoffset:0;stroke-opacity:1"
d="M 77.986092,43.112153 V 61.127172"
id="path4493-4"
inkscape:connector-curvature="0" />
<path
style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.54548609;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:1.09097222, 0.54548611;stroke-dashoffset:0;stroke-opacity:1"
d="M 84.936766,43.112153 V 61.127172"
id="path4493-5"
inkscape:connector-curvature="0" />
<path
style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.54548609;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:1.09097222, 0.54548611;stroke-dashoffset:0;stroke-opacity:1"
d="M 91.958367,43.112153 V 61.127172"
id="path4493-20"
inkscape:connector-curvature="0" />
<path
style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.54548609;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:1.09097222, 0.54548611;stroke-dashoffset:0;stroke-opacity:1"
d="M 98.696265,43.112153 V 61.127172"
id="path4493-29"
inkscape:connector-curvature="0" />
<path
style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.54462844px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;marker-end:url(#Arrow2Mend)"
d="m 38.749464,50.508548 h 9.362138"
id="path4540"
inkscape:connector-curvature="0" />
<text
xml:space="preserve"
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:6.53554153px;line-height:100%;font-family:'DejaVu Sans Mono';-inkscape-font-specification:'DejaVu Sans Mono';text-align:center;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.54462844px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
x="33.670418"
y="66.219002"
id="text4890"><tspan
sodipodi:role="line"
id="tspan4888"
x="33.670418"
y="66.219002"
style="stroke-width:0.54462844px;-inkscape-font-specification:Arial;font-family:Arial;font-weight:normal;font-style:normal;font-stretch:normal;font-variant:normal">Index</tspan></text>
<text
xml:space="preserve"
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:6.53554153px;line-height:100%;font-family:'DejaVu Sans Mono';-inkscape-font-specification:'DejaVu Sans Mono';text-align:center;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.54462844px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
x="56.425217"
y="66.104126"
id="text4894"><tspan
sodipodi:role="line"
id="tspan4892"
x="56.425217"
y="66.104126"
style="stroke-width:0.54462844px;-inkscape-font-specification:Arial;font-family:Arial;font-weight:normal;font-style:normal;font-stretch:normal;font-variant:normal">0</tspan></text>
<text
xml:space="preserve"
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:6.53554153px;line-height:100%;font-family:'DejaVu Sans Mono';-inkscape-font-specification:'DejaVu Sans Mono';text-align:center;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.54462844px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
x="63.385426"
y="66.017967"
id="text4898"><tspan
sodipodi:role="line"
id="tspan4896"
x="63.385426"
y="66.017967"
style="stroke-width:0.54462844px;-inkscape-font-specification:Arial;font-family:Arial;font-weight:normal;font-style:normal;font-stretch:normal;font-variant:normal">1</tspan></text>
<text
xml:space="preserve"
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:6.53554153px;line-height:100%;font-family:'DejaVu Sans Mono';-inkscape-font-specification:'DejaVu Sans Mono';text-align:center;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.54462844px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
x="70.722176"
y="66.104126"
id="text4902"><tspan
sodipodi:role="line"
id="tspan4900"
x="70.722176"
y="66.104126"
style="stroke-width:0.54462844px;-inkscape-font-specification:Arial;font-family:Arial;font-weight:normal;font-style:normal;font-stretch:normal;font-variant:normal">2</tspan></text>
<text
xml:space="preserve"
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:6.53554153px;line-height:100%;font-family:'DejaVu Sans Mono';-inkscape-font-specification:'DejaVu Sans Mono';text-align:center;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.54462844px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
x="77.845131"
y="66.104126"
id="text4906"><tspan
sodipodi:role="line"
id="tspan4904"
x="77.845131"
y="66.104126"
style="stroke-width:0.54462844px;-inkscape-font-specification:Arial;font-family:Arial;font-weight:normal;font-style:normal;font-stretch:normal;font-variant:normal">3</tspan></text>
<text
xml:space="preserve"
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:6.53554153px;line-height:100%;font-family:'DejaVu Sans Mono';-inkscape-font-specification:'DejaVu Sans Mono';text-align:center;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.54462844px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
x="84.942558"
y="66.017967"
id="text4910"><tspan
sodipodi:role="line"
id="tspan4908"
x="84.942558"
y="66.017967"
style="stroke-width:0.54462844px;-inkscape-font-specification:Arial;font-family:Arial;font-weight:normal;font-style:normal;font-stretch:normal;font-variant:normal">4</tspan></text>
<text
xml:space="preserve"
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:6.53554153px;line-height:100%;font-family:'DejaVu Sans Mono';-inkscape-font-specification:'DejaVu Sans Mono';text-align:center;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.54462844px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
x="92.113373"
y="66.017967"
id="text4914"><tspan
sodipodi:role="line"
id="tspan4912"
x="92.113373"
y="66.017967"
style="stroke-width:0.54462844px;-inkscape-font-specification:arial;font-family:arial;font-weight:normal;font-style:normal;font-stretch:normal;font-variant:normal">5</tspan></text>
<text
xml:space="preserve"
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:6.53554153px;line-height:100%;font-family:'DejaVu Sans Mono';-inkscape-font-specification:'DejaVu Sans Mono';text-align:center;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.54462844px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
x="99.2108"
y="66.104126"
id="text4918"><tspan
sodipodi:role="line"
id="tspan4916"
x="99.2108"
y="66.104126"
style="stroke-width:0.54462844px;-inkscape-font-specification:Arial;font-family:Arial;font-weight:normal;font-style:normal;font-stretch:normal;font-variant:normal">6</tspan></text>
</g>
</svg>
notebooks/pics/tiled_triangle.png 0 → 100644
View file @ 9a8e896d
notebooks/pics/tiled_triangle.png

3.32 KiB

notebooks/programmierspaß_spiele.ipynb 0 → 100644
View file @ 9a8e896d
%% Cell type:markdown id: tags:
# Einführungsaufgaben
## neue Bibliothek
### nb_black
- Installation (Terminal / Anaconda prompt): <code>$ [sudo] pip install nb_black </code>
- https://github.com/dnanhkhoa/nb_black
- uncompromising Python code formatter
- makes code review faster
- Apply by putting this code <code>%load_ext nb_black </code> into the first cell in your Notebook, run it and that's all :)
- based on black
- https://pypi.org/project/black/
- for "normal" python scripts
%% Cell type:code id: tags:
```
%load_ext nb_black
```
%% Cell type:markdown id: tags:
## Würfeln
1. Erstelle eine Funktion <code>dice</code>, die einen Würfel x-mal würfelt. (x soll die Eingabe der Funktion sein).
2. Gebe eine Statistik aus, wie oft welcher Wert gewürfelt wurde.
- Tipp: Nutze die Bibliothek random, um zufällige Werte zu generieren.
- Tipp: Nutze Schleifen (while, for)
3. Verkürze deinen Code durch List Comprehension
%% Cell type:code id: tags:
```
def dice(x):
""
```
%% Cell type:code id: tags:
```
# Codetest
dice(1000000)
```
%% Cell type:markdown id: tags:
## Schere, Stein, Papier
1. Erstelle ein Schere-Stein-Papier-Spiel, der eine Eingabe (durch <code> input() </code>) von dir entgegennimmt und den Computer eine zufällige Antwort generieren lässt. Anschließend soll die Funktion ausgeben, wer gewonnen hat.
- Nutze Schleifen (for, while)
- Bedingungen (if-statements)
- Nutze die Bibliothek random
- Akzeptiere Groß-und Kleinschreibung
%% Cell type:code id: tags:
```
def ssp():
""
```
%% Cell type:code id: tags:
```
ssp()
```
%% Cell type:markdown id: tags:
## Plotten
1. Plotte eine sinus und eine cosinus Kurve.
- Nutze die Bibliothek numpy, um die sinus und cosinus Funktion zu benutzen
- Nutze die Bibliothek matplotlib, um die Kurven zu zeichnen
2. Gebe dem Plot eine Überschrift, Achsenbeschriftungen, Einschränkungen der x-Achse (-360° bis 360°) und eine Legende.
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
## Hangman
1. Erstelle ein Hangman-Spiel in mehreren Schritten (https://de.wikipedia.org/wiki/Galgenm%C3%A4nnchen). Die nächsten Schritte sind Tipps, wie ihr vorgehen könnt. Das ist nur eine von vielen Möglichkeiten. Probiert es selbst aus, ihr könnt gerne auch einen anderen Weg gehen.
2. Erstelle eine Funktion, die zwei Strings entgegennimmt und alle Indizes wiedergibt, an denen der erste String im zweiten String erscheint.
- Nutze die Bibliothek <code>re</code> und ggf. die Funktion <code>finditer</code> (Man kann die Ausgabe von <code>finditer</code> durchlaufen und durch <code>start()</code> auf den Index zugreifen. Siehe auch die Dokumentation und Beispiele im Internet)
3. Anschließend erweitere die Funktion, sodass die Funktion nur noch das Wort entgegennimmt und du per Eingabe (<code>input()</code>) nacheinander mehrere Buchstaben eingeben kannst (z.B. per Schleife, siehe -> <code>while true:</code>). Auch hier sollen wieder alle Indizes ausgegeben werden, an denen die einzelnen Buchstaben im Wort erscheinen.
4. Erstelle zunächst eine Bedingung, die checkt, ob der Buchstabe im Wort vorkommt. Falls ja, gebe den Buchstaben aus. Wenn nein, gebe bitte eine Nachricht aus, dass die Eingabe falsch war.
5. Was brauchen wir noch? In jedem Schritt die Ausgabe von dem unvollständigen Wort mit den schon gefundenen Buchstaben.
- eine Liste mit sovielen Elementen, wie es Buchstaben im Wort gibt. Jedes Element ist ein Minus oder Unterstrich
- Erweitere die Bedingung aus 4), indem du in der Liste das Element mit dem zur Zeit eingegebenen Buchstaben ersetzt
6. Jetzt brauchen wir noch Abbruchbedingungen in der Schleife durch <code>return</code>. Wo müssen diese hin?
7. Wir können jetzt durch einen Counter die Anzahl der Versuche limitieren. (zusätzliche Bedingung?)
8. Ein Willkommenstext wäre außerdem schön.
9. Anstatt eines Wortes soll die Funktion nun eine Liste von Wörtern entgegennehmen und zufällig eins aussuchen, um das gespielt wird. Dann weißt du auch nicht mehr, welches dran ist.
10. Anzahl der Fehlversuche variabel setzen (z.B. bei jedem neuen Spiel einsetzbar, verschiedene Schwierigkeitsstufen, abhängig von der Länge des Wortes, etc.)
11. Ein Hangman-Bild bei jedem Fehlversuch anzeigen und jedes Mal erweitern.
%% Cell type:code id: tags:
```
# hier ist ein Bild, was ihr theoretisch zur Visualisierung nehmen könnt.
# Ihr könnt euch aber auch ein eigenes ausdenken. Vielleicht gibt es coolere.
hangman = """
______
| |
o |
\|/ |
| |
/ \ |
/ \
"""
print(hangman)
```
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
![CC-BY-NC](https://scm.cms.hu-berlin.de/ibi/python/-/raw/master/img/cc-by-nc.png)
Dieses Notebook ist als freies Werk unter der Lizenz [Creative Commons Attribution-NonCommercial 3.0 Unported](http://creativecommons.org/licenses/by-nc/3.0/) verfügbar. Sie dürfen die Inhalte kopieren, verteilen und verändern, solange Sie die Urheber nennen und sie nicht für kommerzielle Zwecke nutzen.
notebooks/recap.ipynb 0 → 100644
View file @ 9a8e896d
%% Cell type:markdown id: tags:
# Python Grundlagen
- Dynamisch typisierte Sprache
- Statt geschweifter Klammern für Codeblöcke (Funktionen, Schleifen) wird Code mit vier Leerzeichen (pro Hierarchieebene) eingerückt
- Die meisten Editoren ersetzen Tab automatisch durch vier Leerzeichen
- Kommentare beginnen mit Raute #
%% Cell type:markdown id: tags:
## Krasse neue Bibliothek
Formatiert euren Code nach jeder Ausführung
- für "normale" python scripte: **black**
- für jupyter notebooks: **nb_black**
- Installation: *pip install nb_black*
- Ausführung: Einfach **%load_ext nb_black** in einem Codeblock einmalig ausführen
%% Cell type:code id: tags:
```
%load_ext nb_black
```
%% Cell type:markdown id: tags:
## Grundlegende Datentypen
Zahlentypen (int/float) sind größtenteils äquivalent zu Java. Strings können mit doppelten oder einfachen Anführungszeichen deklariert werden.
%% Cell type:code id: tags:
```
a = 2 * 2.0
b = 5
print(a + b)
print(type(a))
```
%% Cell type:code id: tags:
```
a += 1
# ist kurz für
a = a + 1
# a++ existiert nicht
print(a)
```
%% Cell type:code id: tags:
```
2 ** 4 # Potenzen
```
%% Cell type:code id: tags:
```
2 / 4 # Brüche
```
%% Cell type:code id: tags:
```
text1 = "Hallo "
text2 = "Welt"
print(text1 + text2)
# Andere Datentypen müssen explizit in Strings konvertiert werden,
# wenn sie an einen String angehängt werden sollen.
print(text1 + str(1))
# ansonsten muss per Komma getrennt werden
print(text1, 1)
```
%% Cell type:code id: tags:
```
float("1")
```
%% Cell type:code id: tags:
```
float(1)
```
%% Cell type:markdown id: tags:
*None* entspricht *null* in Java.
%% Cell type:code id: tags:
```
myvar = None
```
%% Cell type:code id: tags:
```
print(myvar)
```
%% Cell type:code id: tags:
```
if myvar is None:
print("x ist nicht definiert")
```
%% Cell type:markdown id: tags:
## Listen
Listen werden mit eckigen Klammern oder list() initialisiert.
%% Cell type:code id: tags:
```
l1 = []
l = [1, 2, 3, 3]
l.append(4)
print(l1)
print(l)
```
%% Cell type:markdown id: tags:
Vorsicht bei der Kombination von Listen. append hängt die übergebene Variable als einzelnen Listeneintrag an die Liste an.
%% Cell type:code id: tags:
```
l.append([5, 6])
print(l)
```
%% Cell type:markdown id: tags:
Zur Kombination von zwei Listen wird der +-Operator verwendet.
%% Cell type:code id: tags:
```
l2 = l + [5, 6]
print(l2)
```
%% Cell type:markdown id: tags:
## Mengen
Mengen können mit geschweiften Klammern oder set() initialisiert werden.
%% Cell type:code id: tags:
```
s = {1, 2, 3, 3}
s2 = set([2, 3, 4, 5])
print(s)
print(s.intersection(s2))
```
%% Cell type:code id: tags:
```
s.add(9)
s.remove(2)
s
```
%% Cell type:markdown id: tags:
Mit list() und set() können die Typen auch ineinander konvertiert werden.
%% Cell type:code id: tags:
```
list(s)
```
%% Cell type:code id: tags:
```
set([1, 2, 3])
```
%% Cell type:markdown id: tags:
## Ranges
Auflistung von Zahlen, werden z.Bsp. für for-Schleifen mit Index verwendet.
%% Cell type:code id: tags:
```
for i in range(5):
print(i)
```
%% Cell type:markdown id: tags:
## Tupel
Für sortierete Werte mit fester Komponentenanzahl und fester Bedeutung für jeden Eintrag.
%% Cell type:code id: tags:
```
essen = "Chili"
preis = 2.51
boneintrag = (essen, preis)
print(boneintrag)
print(boneintrag[0])
print(boneintrag[1])
```
%% Cell type:code id: tags:
```
(essen2, preis2) = boneintrag
print(essen2)
print(preis2)
```
%% Cell type:markdown id: tags:
Klammern können oft weggelassen werden
%% Cell type:code id: tags:
```
boneintrag = essen, preis
essen2, preis2 = boneintrag
print(boneintrag)
print(essen2)
print(preis2)
```
%% Cell type:markdown id: tags:
## Dictionaries
Äquivalent zu Maps.
%% Cell type:code id: tags:
```
d = {"Chili": 1.90, "Penne": 2.50}
```
%% Cell type:code id: tags:
```
d.keys()
```
%% Cell type:code id: tags:
```
d.values()
```
%% Cell type:code id: tags:
```
for key, val in d.items():
print("{}: {}".format(key, val))
```
%% Cell type:code id: tags:
```
d["Chili"]
```
%% Cell type:code id: tags:
```
d["Burger"] = 4.90
d
```
%% Cell type:code id: tags:
```
del d["Burger"]
d
```
%% Cell type:markdown id: tags:
## If-Anweisungen
%% Cell type:code id: tags:
```
if 2 > 1 or 1 > 2:
print("Bedingung erfüllt.")
```
%% Cell type:code id: tags:
```
y = 10
x = 5 if y > 10 else 4
print(x)
```
%% Cell type:markdown id: tags:
## Schleifen
%% Cell type:code id: tags:
```
x = 5
while x > 0:
x -= 1
x
```
%% Cell type:code id: tags:
```
for x in ["a", "b", "c"]:
print(x)
```
%% Cell type:markdown id: tags:
## Funktionen
%% Cell type:code id: tags:
```
def sum_upto(n):
return n * (n + 1) / 2
sum_upto(4)
```
%% Cell type:markdown id: tags:
Zur besseren Übersicht (insbesondere bei vielen Parametern) können diese auch namentlich zugewiesen werden.
%% Cell type:code id: tags:
```
sum_upto(n=4)
```
%% Cell type:markdown id: tags:
Funktionen können *Default-Parameter* haben, d.h. Werte, die von der Funktion als Standardwert verwendet werden (wenn kein anderer Wert übergeben wird). Default-Parameter müssen am Ende der Funktion stehen und übergeben werden.
%% Cell type:code id: tags:
```
def fun_with_default(x=3):
print("Parameter is {}".format(x))
```
%% Cell type:code id: tags:
```
fun_with_default()
```
%% Cell type:code id: tags:
```
fun_with_default(x=4)
```
%% Cell type:markdown id: tags:
Funktionen können wie Variablen referenziert werden (Pointer auf die Funktion) und zum Beispiel als Parameter übergeben werden.
%% Cell type:code id: tags:
```
def calc_and_print(calc_function, n):
calc_result = calc_function(n)
print(calc_result)
```
%% Cell type:code id: tags:
```
calc_and_print(sum_upto, 4)
```
%% Cell type:markdown id: tags:
## Lambda-Funktionen
I.d.R. für Inline-Funktionen. Können zum Beispiel an Funktionen als Parameter übergeben oder als Variable deklariert werden. Lambdas enthalten ein einzelnes Statement, dessen Wert automatisch der Rückgabewert ist.
%% Cell type:code id: tags:
```
calc_square = lambda x: x ** 2
calc_square(3)
```
%% Cell type:code id: tags:
```
calc_and_print(calc_square, 4)
```
%% Cell type:code id: tags:
```
calc_and_print(lambda x: x ** 3, 4)
```
%% Cell type:markdown id: tags:
## List Comprehensions
%% Cell type:code id: tags:
```
y = [x ** 2 for x in range(10)]
y
```
%% Cell type:code id: tags:
```
xy = [(x, x ** 2) for x in range(10) if x % 2 == 0]
xy
```
%% Cell type:markdown id: tags:
## Klassen
Objekte einer Klasse bekommen bei Methodenaufrufen als ersten Parameter automatisch das *"self"*-Objekt übergeben (vgl. *this* in Java). Dieser Parameter muss also immer auch als erster Parameter einer Klassenmethode übergeben werden.
%% Cell type:code id: tags:
```
class Vehicle:
# Constructor
def __init__(self, n_wheels=4, noise="beep"):
self.n_wheels = n_wheels
self.noise = noise
def make_noise(self):
print(self.noise)
```
%% Cell type:code id: tags:
```
basicVehicle = Vehicle()
basicVehicle.make_noise()
```
%% Cell type:markdown id: tags:
Properties sind immer von außen sichtbar und lassen sich verändern. Properties, die nicht zur Veränderung gedacht sind, werden nach Konvention durch zwei Unterstriche im Namen gekennzeichnet.
%% Cell type:code id: tags:
```
basicVehicle.n_wheels
```
%% Cell type:markdown id: tags:
Vererbung ist in Python möglich. In der Regel wird aber Duck-Typing verwendet.
“When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.”
%% Cell type:code id: tags:
```
bike = Vehicle(n_wheels=2, noise="ring")
bike.make_noise()
```
%% Cell type:code id: tags:
```
class Bike(Vehicle):
def __init__(self):
self.n_wheels = 2
self.noise = "ring"
```
%% Cell type:code id: tags:
```
Bike().make_noise()
```
%% Cell type:markdown id: tags:
# Jupyter Notebook Grundlagen
- Notebook besteht aus Zellen
- Unter der Zelle wird der Rückgabewert des letzten Statements ausgegeben
- Quellcode kann auf mehrere Zellen aufgeteilt werden (Variablen behalten ihre Gültigkeit/Sichtbarkeit)
- Variablen sind auch nach dem Löschen von Zellen weiter sichtbar. Um den Speicher zu bereinigen *Kernel -> Restart*
%% Cell type:markdown id: tags:
# Shortcuts
Übersicht: *Help -> Keyboard Shortcuts*
- *Enter*: Editiermodus für selektierte Zelle (grün)
- *Esc*: Editiermodus verlassen/Kommandomodus (blau)
- *Shift+Strg*: Selektierte Zelle ausführen
- *Shift+Enter*: Selektierte Zelle ausführen und in nächste Zelle springen
Im Editiermodus:
- Tab: Autocomplete oder Einrücken
Im Kommandomodus:
- *B*: Zelle darunter einfügen
- *A*: Zelle darüber einfügen
- *DD*: Zelle löschen
- *M*: Zelltyp Markdown (für formatierte beschreibende Texte)
- *Y*: Zelltyp Code (Default)
%% Cell type:markdown id: tags:
![CC-BY-NC](https://scm.cms.hu-berlin.de/ibi/python/-/raw/master/img/cc-by-nc.png)
Dieses Notebook ist als freies Werk unter der Lizenz [Creative Commons Attribution-NonCommercial 3.0 Unported](http://creativecommons.org/licenses/by-nc/3.0/) verfügbar. Sie dürfen die Inhalte kopieren, verteilen und verändern, solange Sie die Urheber nennen und sie nicht für kommerzielle Zwecke nutzen.
notebooks/seminar00.ipynb
View file @ 9a8e896d
%% Cell type:markdown id: tags:
# Seminar Problemorientierte Programmierung
Diese Notebooks sind im Wesentlichen eine Übersetzung der 2. Ausgabe des Buches "Think Python" von Allen B. Downey. Sie finden den originalen Text hier: http://greenteapress.com/wp/think-python-2e/.
Falls Sie im Python Programmierkurs sind und dies ihr erstes geöffnetes Jupyter Notebook ist:
**Herzlichen Glückwunsch! Sie haben die erste Hürde gemeistert. :)**
Diese Notebooks sind im Wesentlichen eine Übersetzung der 3. Ausgabe des Buches [Think Python](https://greenteapress.com/wp/think-python-3rd-edition/) von Allen B. Downey.
%% Cell type:markdown id: tags:
## Lernziele und Ablauf diese Seminars
Unser Lernziel ist, dass Sie Programmieren lernen (mit Python :-). Bis dahin ist es ein weiter Weg. Der beste Tipp ist: üben, üben, üben.
Unser Lernziel ist, programmieren zu lernen (mit Python :-)). Bis dahin ist es ein weiter Weg. Der beste Tipp ist: üben, üben, üben.
Das Seminar wird wie folgt ablaufen:
1. Sie arbeiten als Pair-Programming-Team diese Jupyter-Notebooks durch.
- Währenddessen bin ich für Sie da um Fragen zu beantworten und Probleme zu lösen
- Nutzen sie bitte auch das [gemeinsame Etherpad](https://etherpad.gwdg.de/p/Pro2P) für Codeschnipsel und allgemeine Probleme.
2. Alle ca. 15 Minuten unterbrechen wir das Programmieren und Sie wechseln die Rollen (NavigatorIn<->FahrerIn)
- Währenddessen bin ich für Sie da, um Fragen zu beantworten und Probleme zu lösen
- Nutzen Sie gerne auch das [gemeinsame Etherpad](https://etherpad.gwdg.de/p/Pro2P), um Probleme, Fragen oder fehlerhaften Code zu posten.
2. Alle ca. 15 Minuten unterbrechen wir das Programmieren und Sie wechseln die Rollen (NavigatorIn <--> FahrerIn)
3. Die Schritte 1. und 2. wiederholen wir bis zum Ende des Seminars
4. Zuhause arbeiten Sie gemeinsam das durch, was Sie im Seminar nicht geschafft haben. Dies gilt besonders für die Aufgaben
- Wir werden im Seminar entscheiden, bis zu welchem Notebook Sie kommen sollten.
## Tipps
- Arbeiten Sie die Notebooks selbständig im Team durch und probieren Sie möglichst viel aus. Seien Sie kreativ, neugierig und manchmal auch destruktiv. Denn auch durch Fehler lernen Sie.
- Sie können alles in Ihrem Notebook bearbeiten ... nutzen Sie diese Möglichkeit. Ergänzen Sie also Text, löschen Sie, was Sie überflüssig finden, fügen Sie Ihre eigenen Notizen oder Programme hinzu. Dieses Notebook kann Ihr "Portfolio" werden: eine Demonstration dessen, was Sie schon können.
- Denken Sie daran, alle Code-Blöcke auszuführen. "Unbekannter" Code führt in Jupyter häufig zu leicht vermeidbaren Fehlern.
- Falls Sie mal nicht weiterkommen: helfen Sie sich gegenseitig und versuchen Sie verschiedene Dinge. Schreiben Sie Ihr Problem z.B. einfach mal ganz genau hier im Notebook auf. Oft hilft das Aufschreiben eines Problems schon bei der Lösung eines Problems.
## Wiederkehrende Abschnitte:
## Wiederkehrende Abschnitte
- **Exkurse** sind Material, welches Sie sich nur anschauen brauchen, falls es Sie interessiert. Bitte schauen Sie sich die Exkurse eher zu Hause an, als während des Seminars, damit Sie vorwärts kommen. Die Inhalte der Exkurse sind nicht notwendig, um vorwärts zu kommen, aber hilfreich, um mehr zu lernen.
- **Debugging-Abschnitte** erklären, wie Sie Fehler finden und beheben können.
- **Glossar-Abschnitte** listen die Begriffe auf, die im Kapitel vermittelt wurden. Es ist eine gute Übung für zu Hause, jeden Begriff dort noch einmal in eigenen Worten zu definieren.
- Schließlich gibt es **Übungen**, diese sollten Sie unbedingt durchführen und erst fortfahren, wenn Sie die Aufgaben lösen konnten und verstanden haben.
%% Cell type:markdown id: tags:
## Hinweise zur Benutzung von Jupyter
- Sie kommen deutlich schneller vorwärts, wenn Sie Tastaturkürzel nutzen (und nicht die Maus). Im "Help"-Menü gibt es dazu den "Keyboard Shortcuts"-Eintrag. Sie können aber auch einfach die Tastenkombination `ESC h` drücken (das bedeutet: die `ESC`-Taste drücken und dann die Taste h). Wichtigste Kombinationen: `ESC b` fügt einen neuen Block ein, `STRG-ENTER` (oder `STRG-RETURN`, also `STRG` gedrückt halten und dann `RETURN` drücken) führt den aktuellen Block aus, `ESC m` ändert den Typ des aktuellen Blocks auf Markdown (und `ESC y` zu Python), usw.
- Alternativ können Sie auch die Knöpfe oben mit der Maus bedienen.
- Es gibt zwei Arten von Blöcken: "Code" ist für Python-Code, "Markdown" ist für Texte, die Sie mit Hilfe der [Markdown-Syntax](https://de.wikipedia.org/wiki/Markdown#Auszeichnungsbeispiele) formatieren können.
- Sie können auf Text doppelt klicken, um sich den Markdown-Quellcode anzuzeigen. Probieren Sie es mit diesem Text aus.
- Wenn Sie mal etwas "kaputtgespielt" haben, hilft es evtl., im "Kernel"-Menü den "Restart"-Eintrag auszuwählen.
- Mit der Funktion help können Sie in Python zu vielen Funktionen Hilfe erhalten. Die offizielle Python-Dokumentation finden Sie hier: https://docs.python.org/3/.
### Jupyter Notebook Grundlagen und Informationen
- open-source, browserbasiertes Tool für verschiedene Programmiersprachen (wir benutzen Python)
- **Vorteil**: Code, Visualisierungen und Text / Erklärungen in einem Dokument
- Notebook besteht aus Blöcken bzw. Zellen
- Unter der Zelle wird der Rückgabewert des letzten Statements ausgegeben
- Quellcode kann auf mehrere Blöcke aufgeteilt werden (Variablen behalten ihre Gültigkeit/Sichtbarkeit)
- Es gibt zwei Arten von Blöcken: "Code" ist für Python-Code, "Markdown" ist für Texte, die Sie mit Hilfe der [Markdown-Syntax](https://de.wikipedia.org/wiki/Markdown#Auszeichnungsbeispiele) formatieren können.
- Sie können auf Text doppelt klicken, um sich den Markdown-Quellcode anzuzeigen. Probieren Sie es mit diesem Text aus.
- durch die Tastenkombination "Strg" und "Enter" oder durch Drücken von dem "Run" Button oben im Menü kommen Sie wieder in den Lesemodus
- Wenn Sie mal etwas "kaputtgespielt" haben, hilft es evtl., im "Kernel"-Menü den "Restart"-Eintrag auszuwählen.
### Standardbrowser
Bitte verwenden Sie **nicht** Safari oder Internet Explorer. Auch mit Windows Edge gab es in der Vergangenheit Probleme. Wir empfehlen die Verwendung von Firefox, aber auch Google Chrome lief in der Vergangenheit problemlos. Wenn Sie unsicher sind, was ihr aktueller Standardbrowser ist, folgen Sie einfach der folgenden Anleitung zum Ändern des Standardbrowsers und gehen Sie sicher, dass der richtige Standardbrowser ausgewählt ist.
#### Anleitungen
**Änderung des Standardbrowsers in...**
*macOS:*
1. Öffnen sie die Systemeinstellungen.
2. Klicken Sie auf „Allgemein“.
3. Wählen Sie unter „Standard-Webbrowser“ den gewünschten Browser aus.
*Ubuntu Linux:*
1. Öffnen Sie die System Settings.
2. Klicken Sie auf „Applications“.
3. Wählen Sie in der linken Spalte „Default Applications“ aus.
4. Klicken Sie in der Spalte rechts davon auf „Web Browser“.
5. Wählen Sie „in the following browser:“ aus.
6. Wählen Sie den gewünschten Browser aus.
*Windows:*
1. Öffnen Sie die Systemsteuerung.
2. Klicken Sie auf „Standardprogramme“.
3. Klicken Sie auf „Standardprogramme festlegen“.
4. Klicken Sie in der Liste auf den gewünschten Browser.
5. Klicken Sie dann auf „Dieses Programm als Standard festlegen“.
### Shortcuts
**Bitte probieren Sie alle unten stehenden Befehle und verstehen Sie, was gemacht wird. Das ist die Basis, die Sie für das Arbeiten mit Jupyter Notebooks brauchen.**
Übersicht: *Menü Help -> Keyboard Shortcuts*
Wichtigste Shortcuts:
- *Enter*: Editiermodus für selektierte Zelle (grün umrandet)
- *Esc*: Editiermodus verlassen/Kommandomodus (blau umrandet)
- *Strg + Enter*: Selektierte Zelle ausführen
- *Shift + Enter*: Selektierte Zelle ausführen und in nächste Zelle springen
Im Editiermodus:
- *Tab*: Autocomplete oder Einrücken
- *Shift + Tab*: Einrücken rückwärts
Im Kommando-/Lesemodus:
- *B*: Zelle darunter einfügen
- *A*: Zelle darüber einfügen
- *DD*: Zelle löschen
- *M*: Zelltyp Markdown (für formatierte beschreibende Texte, zB diese Zelle)
- *Y*: Zelltyp Code (Default)
- *Strg + Shift + k*: Inhaltsverzeichnis einblenden/ausblenden
%% Cell type:markdown id: tags:
#### Beispiel: Markdown Zelle vs. Code Zelle
%% Cell type:markdown id: tags:
Dies ist eine **Markdown Zelle**. Hier kann jeglicher Text geschrieben werden. Durch Strg+Enter wird er in den Lesemodus gebracht, durch ein einfach Enter (oder Doppelklick) in den Editiermodus.
Hier werden keine Rechnungen ausgeführt, siehe:
5+3
In diesen Feldern werden Erklärungen, Aufgabenstellungen und schriftliche Antworten von euch stehen.
%% Cell type:code id: tags:
``` python
# Das ist eine **Code Zelle**, bei Strg+Enter wird die folgende Rechnung ausgeführt und darunter angezeigt
# Mit Enter kommt man in den Editiermodus, mit Strg+Enter wird der Code ausgeführt.
# Der Text kann hier nur stehen, da eine Raute am Anfang der Zeile steht.
# Dadurch werden diese Zeilen nicht ausgeführt.
31+11
# In diesen Zellen wird der Python Code geschrieben, manchmal müssen Sie ihn schreiben,
# manchmal steht der Code schon dort und muss von Ihnen nur ausgeführt werden.
```
%% Cell type:markdown id: tags:
# Code für *Think Python*
Am Anfang eines Notebooks sehen Sie üblicherweise eine Zelle mit einem Code wie diesem:
%% Cell type:code id: tags:
``` python
from os.path import basename, exists
def download(url):
filename = basename(url)
if not exists(filename):
from urllib.request import urlretrieve
local, _ = urlretrieve(url, filename)
print("Downloaded " + str(local))
return filename
download('https://raw.githubusercontent.com/AllenDowney/ThinkPython/v3/thinkpython.py')
import thinkpython
```
%% Cell type:markdown id: tags:
Sie müssen nicht wissen, wie dieser Code funktioniert, aber wenn Sie am Ende des Kurses angelangt sind, wird das meiste davon einen Sinn ergeben. Wie Sie sich vielleicht denken können, wird eine Datei heruntergeladen - genauer gesagt, `thinkpython.py`. Diese Datei enthält Python-Code, der speziell für dieses Buch bereitgestellt wurde.
Die letzte Zeile *importiert* diesen Code, was bedeutet, dass wir den Code im Notebook verwenden können.
In anderen Kapiteln werden Sie Code sehen, der `diagram.py` herunterlädt, mit dem die Diagramme im Buch erstellt werden, sowie `jupyturtle.py`, das in mehreren Kapiteln zur Erstellung von [*Turtle-Grafiken*](https://docs.python.org/3/library/turtle.html) verwendet wird.
An einigen Stellen werden Sie eine Zelle wie diese sehen, die mit `%%expect` beginnt.
%% Cell type:code id: tags:
``` python
%%expect SyntaxError
abs 42
```
%% Cell type:markdown id: tags:
`%%expect` ist nicht Teil von Python - es ist ein [*magischer Befehl*](https://ipython.readthedocs.io/en/stable/interactive/magics.html) von Jupyter, der anzeigt, dass wir erwarten, dass die Zelle einen Fehler produziert. Wenn Sie diesen Befehl sehen, bedeutet das, dass der Fehler beabsichtigt ist. Das tun wir um auf typische Fehler hinzuweisen.
%% Cell type:markdown id: tags:
## Exkurs: Was mir an Python gefällt:
In dieser Rubrik, die normalerweise am Anfang eines Kapitels steht, möchte ich Ihnen zeigen, wofür ich Python nutze und warum ich es mag. Sie werden vielleicht noch nicht verstehen, was ich genau mache, aber Sie sehen damit schon einmal die Möglichkeiten von Python und können später darauf zurückgreifen. Da dies ein Exkurs ist, können Sie diese Rubrik gerne auch erst einmal überspringen.
**Hier müssen Sie den Code NIE verändern. Einfach Ausführen durch: *Strg+Enter* oder im Menü unter *> Run*.**
*Sollten Sie den Code doch einmal versehentlich verändert haben, sodass der Exkurs nicht mehr korrekt funktioniert, können Sie das Jupyter-Notebook erneut in Gitlab herunterladen*
Ich finde toll, dass ich mit Python ganz einfach Zufallsexperimente durchtesten kann. Das hilft mir, Stochastik besser zu verstehen. Z.B. das Würfeln mit zwei Würfeln:
%% Cell type:code id: tags:
```
``` python
import random # Zufallszahlen, siehe https://docs.python.org/3/library/random.html
# Werte initialisieren, größter möglicher Wert bei zwei Würfeln: 6+6=12
haeufigkeiten = [0 for i in range(13)]
wuerfe = 100000
wuerfe = 1000
for i in range(wuerfe):
# Würfelsumme für zwei Würfel zählen
haeufigkeiten[random.randrange(1,7) + random.randrange(1,7)] += 1
# Ergebnis als Tabelle ausgeben
print("Wir würfeln wiederholt mit zwei sechsseitigen Würfeln und addieren die Augenzahlen zusammen:")
print("Summe Augenzahlen:", "\t".join([str(i) for i in range(2,13)]), sep='\t')
print("Anzahl der Würfe:", "\t".join([str(i) for i in haeufigkeiten[2:]]), sep='\t')
print("Wahrscheinlichkeit:", "\t".join(["{:2.3f}".format(i/wuerfe) for i in haeufigkeiten[2:]]), sep='\t')
```
%% Cell type:markdown id: tags:
![RFC 1149.5 specifies 4 as the standard IEEE-vetted random number.](https://imgs.xkcd.com/comics/random_number.png)
([Random Number](https://xkcd.com/221/), Randall Munroe)
%% Cell type:markdown id: tags:
<img src="https://scm.cms.hu-berlin.de/ibi/python/-/raw/master/img/by-nc-sa.png" alt="CC BY-NC-SA" style="width: 150px;"/>
Der Text dieses Notebooks ist als freies Werk unter der Lizenz [CC BY-NC-SA 4.0 ](https://creativecommons.org/licenses/by-nc-sa/4.0/) verfügbar.
Der Code dieses Notebooks ist als freies Werk unter der Lizenz [MIT License](https://mit-license.org/) verfügbar.
Es handelt sich um übersetzte und leicht veränderte Notebooks von [Allen B. Downey](https://allendowney.com) aus [Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html).
......
notebooks/seminar01.ipynb
View file @ 9a8e896d
%% Cell type:markdown id: tags:
# Seminar Problemorientierte Programmierung
# Kapitel 1: Programmieren als Denkweise
__[Chapter 1: Programming as a way of thinking](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/chap01.ipynb)__
## Kapitel 1: Die Ersten Programme
__[Chapter 1 The Way of the Program](http://greenteapress.com/thinkpython2/html/thinkpython2002.html)__
**Wichtig:** Bevor Sie anfangen dieses Jupyter-Notebook zu bearbeiten schauen Sie sich bitte zuerst [das 0. Seminarnotebook](seminar00.ipynb) an. Es enthält wichtige Hinweise für das Verwenden von Jupyter-Notebooks. Wenn Sie das Notebook in das selbe Verzeichnis heruntergeladen und nicht umbenannt haben, können Sie den Link verwenden um es zu öffnen, andernfalls können Sie die Notebooks ebenfalls auf [Gitlab](https://scm.cms.hu-berlin.de/ibi/python/-/tree/master/notebooks) finden.
### Ihre Lernziele:
Beschreiben Sie in 2-3 Stichpunkten was Sie heute lernen wollen. Sie können diesen Text durch Doppelklick bearbeiten.
%% Cell type:markdown id: tags:
-
-
-
## Ihre Lernziele
Sie können eine Übersicht der Inhalte dieses Notebooks einblenden mit *Strg + Shift + k*.
Beschreiben Sie in 2-3 Stichpunkten was Sie heute lernen wollen. Sie können diesen Text durch Doppelklick bearbeiten.
-
%% Cell type:markdown id: tags:
## Exkurs: Was mir an Python gefällt:
Ich finde toll, dass mir Python Berechnungen mit Datumsangaben sehr vereinfacht:
Bitte beachten Sie, dass Sie **erst den Code ausführen (Strg + Enter)** und anschließend in das neue Eingabefeld Ihren Geburtstag eingeben.
%% Cell type:code id: tags:
```
import datetime
datum = input("Geben Sie Ihr Geburtsdatum im Format TT.MM.JJJJ an: ")
# Zahlen für Tag, Monat und Jahr extrahieren
(tag, monat, jahr) = (int(d) for d in datum.split('.'))
# Datumsobjekt anlegen
datum = datetime.datetime(jahr, monat, tag)
print("You were born on a", datum.strftime("%A"),)
print("You were born on a", datum.strftime("%A"))
```
%% Cell type:markdown id: tags:
## Python-Programme starten
Wenn wir ein Programm (hier einer der Blöcke mit Python-Code) starten, dann starten wir im Hintergrund den sogenannten **Python-Interpreter**. Das ist ein Programm, welches den Python-Code liest, für den Computer übersetzt und ausführt. Wir können den Python-Interpreter auch ohne Jupyter aufrufen und dort direkt Python-Anweisungen eingeben oder Programme starten, die wir in einer Datei gespeichert haben. Für den Anfang bleiben wir aber bei Jupyter, weil wir hier Programme und Erklärungen leicht kombinieren können.
**Tipp**: Nutzen Sie http://pythontutor.com, um Ihren Code nachvollziehen zu können und Fehler zu finden!
%% Cell type:markdown id: tags:
## Herunterladen des unterstützenden Codes
Die folgende Zelle lädt eine Datei herunter und führt einen Code aus, der speziell für dieses Notebook verwendet wird. Sie müssen diesen Code nicht verstehen, aber Sie sollten die Zelle ausführen vor allen weiteren Zellen in diesem Notebook.
%% Cell type:code id: tags:
```
from os.path import basename, exists
def download(url):
filename = basename(url)
if not exists(filename):
from urllib.request import urlretrieve
local, _ = urlretrieve(url, filename)
print("Downloaded " + str(local))
return filename
download('https://github.com/AllenDowney/ThinkPython/raw/v3/thinkpython.py');
import thinkpython
```
%% Cell type:markdown id: tags:
## Programmieren als Denkweise
Das erste Ziel dieses Buches ist es, Ihnen das Programmieren in Python beizubringen.
Programmieren zu lernen bedeutet allerdings, eine komplett neue Denkweise anzunehmen, daher ist das zweite Ziel, Ihnen dabei zu helfen, wie ein$*$e Informatiker$*$in zu denken.
Diese Denkweise vereint einige der besten Aspekte der Mathematik, des Ingenieurwesens und der Naturwissenschaft.
Wie Mathematiker$*$innen nutzen Informatiker$*$innen formale Sprachen, um Ideen – und insbesondere Berechnungen – zu bezeichnen.
Wie Ingenieure entwerfen sie Dinge, fügen Einzelteile zu Systemen zusammen und evaluieren Kompromisse zwischen verschiedenen Alternativen.
Wie Wissenschaftler$*$innen beobachten sie das Verhalten komplexer Systeme, bilden Hypothesen und testen Vorhersagen.
Wir werden mit den grundlegendsten Elementen des Programmierens beginnen und uns nach und nach hocharbeiten.
In diesem Kapitel betrachten wir, wie Python Zahlen, Buchstaben und Wörter darstellt.
Außerdem werden Sie lernen, arithmetische Operationen durchzuführen.
Sie werden zudem beginnen, das Programmiervokabular zu erlernen, welches Begriffe wie Operator, Ausdruck, Wert und Datentyp enthält.
Dieses Vokabular ist wichtig – Sie werden es brauchen, um den Rest des Buches zu verstehen, um mit anderen Programmierer$*$innen zu kommunizieren und um virtuelle Assistenten zu nutzen und zu verstehen.
%% Cell type:markdown id: tags:
## Arithmetische Operatoren
Ein **arithmetischer Operator** ist ein Symbol, das eine arithmetische Berechnung repräsentiert. Das Plus-Zeichen, `+`, führt zum Beispiel eine Addition durch.
%% Cell type:code id: tags:
```
30 + 12
```
%% Cell type:markdown id: tags:
Das Minus-Zeichen, `-`, ist der Operator, der zur Subtraktion dient.
%% Cell type:code id: tags:
```
43 - 1
```
%% Cell type:markdown id: tags:
Der Asterisk, `*`, führt eine Multiplikation durch.
%% Cell type:code id: tags:
```
6 * 7
```
%% Cell type:markdown id: tags:
Und der Schrägstrich, `/`, führt eine Division durch:
%% Cell type:code id: tags:
```
84 / 2
```
%% Cell type:markdown id: tags:
Hier sollte Ihnen auffallen, dass das Ergebnis der Division `42.0` und nicht `42` ist. Das liegt daran, dass es in Python zwei verschiedene Arten von Zahlen gibt:
* **Ganze Zahlen** (Englisch: _integer_) und
* **Gleitkommazahlen** (Englisch: _float_), die Zahlen mit einem Dezimalanteil repräsentieren (in Python wird der Dezimalanteil anders als im Deutschen durch einen Punkt und kein Komma dargestellt).
Wenn Sie zwei ganze Zahlen addieren, subtrahieren oder multiplizieren, ist das Ergebnis eine ganze Zahl.
Wenn Sie jedoch zwei ganze Zahlen dividieren, ist das Ergebnis eine Gleitkommazahl.
Python stellt einen weiteren Operator, `//`, bereit, der eine **ganzzahlige Division** durchführt.
Das Ergebnis einer ganzzahligen Division ist immer eine ganze Zahl.
%% Cell type:code id: tags:
```
84 // 2
```
%% Cell type:markdown id: tags:
Die Division von ganzen Zahlen wird auf Englisch auch als "floor division" (Dt.: "Bodendivision") bezeichnet, da hierbei immer abgerundet wird, sozusagen dem "floor" (Dt.: "Boden") entgegen.
%% Cell type:code id: tags:
```
85 // 2
```
%% Cell type:markdown id: tags:
Zuletzt gibt es noch den Operator `**`, der eine Potenzierung durchführt:
%% Cell type:markdown id: tags:
In manchen Sprachen wird das Caret, `^`, für die Potenzierung verwendet, in Python ist dieses allerdings ein bitweiser Operator namens XOR.
Wenn Sie sich nicht mit bitweisen Operatoren auskennen könnte das folgende Ergebnis unerwartet sein:
%% Cell type:code id: tags:
```
7 ^ 2
```
%% Cell type:markdown id: tags:
Bitweise Operatoren werden hier nicht weiter behandelt, sollten Sie sich für diese interessieren können Sie hier mehr darüber lesen: <https://de.wikipedia.org/wiki/Bitweiser_Operator>.
%% Cell type:markdown id: tags:
## Ausdrücke
Eine Ansammlung von Operatoren und Zahlen heißt **Ausdruck**.
Ein Ausdruck kann eine beliebige Anzahl von Operatoren und Zahlen enthalten.
Hier ist beispielsweise ein Ausdruck, der zwei Operatoren enthält.
%% Cell type:code id: tags:
```
6 + 6 ** 2
```
%% Cell type:markdown id: tags:
Ihnen sollte hier auffallen, dass die Potenzierung vor der Addition stattfindet.
Python folgt der Reihenfolge der Rechenschritte, die Sie wahrscheinlich im Mathematikunterricht gelernt haben: Potenzen werden vor Multiplikationen und Divisionen berechnet, welche wiederum vor Additionen und Subtraktionen durchgeführt werden.
Im folgenden Beispiel findet die Multiplikation vor der Addition statt.
%% Cell type:code id: tags:
```
12 + 5 * 6
```
%% Cell type:markdown id: tags:
Wenn Sie die Addition als ersten Schritt durchführen möchten, können Sie hierfür Klammern verwenden.
%% Cell type:code id: tags:
```
(12 + 5) * 6
```
%% Cell type:markdown id: tags:
### Programme
Jeder Ausdruck hat einen **Wert**.
Der Ausdruck `6 * 7` hat zum Beispiel den Wert `42`.
%% Cell type:markdown id: tags:
## Arithmetische Funktionen
Was ist ein Programm?
Zusätzlich zu den arithmetischen Operatoren gibt es in Python auch noch einige **Funktionen**, die mit Zahlen arbeiten.
Die `round` Funktion nimmt zum Beispiel eine Gleitkommazahl und rundet sie auf die nächste ganze Zahl ab.
> Eine Folge von Anweisungen, die genau beschreibt wie eine "Berechnung" ausgeführt werden muss
%% Cell type:code id: tags:
In jeder Programmiersprache sind die Details etwas anderes, aber es gibt ein paar grundlegende Instruktionen, die es in so gut wie jeder Programmiersprache gibt:
```
round(42.4)
```
- **Eingabe (input)** Daten von der Tastatur, einer Datei, dem Netzwerk oder von irgendeinem anderen Gerät werden eingegeben
- **Ausgabe (output)** Darstellung von Daten auf dem Bildschirm, Speichern in einer Datei, Verschicken über das Netzwerk und so weiter
- **Berechnung (math)** Durchführen grundlegender mathematischer Operationen (Addition, Multiplikation, ...)
- **bedingte Ausführung (conditional execution)** Prüfe bestimmte Bedingungen und führe den entsprechenden Code aus
- **Wiederholung (repetition)** Führe eine beliebige Aktion wiederholt aus, normalerweise mit einigen Abweichungen
%% Cell type:code id: tags:
Das ist es im Wesentlichen. Jedes Programm, dass Sie schon verwendet haben, besteht im Grunde nur aus diesen Bausteinen. Programmieren heißt also, ein großes Problem in viele kleine Aufgaben zu zerlegen, die sich mit diesen Bausteinen lösen lassen.
```
round(42.6)
```
%% Cell type:markdown id: tags:
### Eine erste Anweisung
Die `abs` Funktion berechnet den Betrag einer Zahl.
Für eine positive Zahl ist der Betrag die Zahl selbst.
%% Cell type:code id: tags:
```
abs(42)
```
%% Cell type:markdown id: tags:
Diese Bausteine bestehen aus kleineren Zeilen Code. Der Grundbaustein jedes Programms ist die **Anweisung**. Jedes Programm ist im Wesentlichen eine Folge von Anweisungen. Das erste Programm, das man häufig in Programmiersprachen schreibt heißt __[Hello World](https://de.wikipedia.org/wiki/Hallo-Welt-Programm)__. Es ist ein einfaches Programm mit nur einer Anweisung.
Für eine negative Zahl ist der Betrag positiv.
%% Cell type:code id: tags:
```
print("Hello World!")
abs(-42)
```
%% Cell type:markdown id: tags:
Diese Anweisung ruft die **Funktion** `print` auf und übergibt ihr das **Argument** "Hello World!", was in diesem Fall eine **Zeichenkette** ist (das erkennen wir an den Gänsefüßchen). Die **Argumente** einer Funktion werden immer nach dem Namen der Funktion in Klammern übergeben.
Wenn wir eine solche Funktion verwenden, bezeichnet man das als ein **Aufrufen** der Funktion.
Ein Ausdruck, der eine Funktion aufruft ist ein **Funktionsaufruf**.
Wenn Sie eine Funktion aufrufen, sind Klammern notwendig.
Lassen Sie diese weg, erhalten Sie eine Fehlermeldung.
Wir können einer Funktion **Argumente** übergeben, diese werden immer nach dem Namen der Funktion in Klammern übergeben.
![Funktionsaufruf](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/funktionsaufruf.png)
Das Ergebnis dieses Funktionsaufrufs ist, dass die Zeichenkette auf dem Bildschirm ausgegeben wird.
Probieren Sie es nun selber und geben Sie eine Zeichenkette Ihrer Wahl aus, indem Sie die Zeichenkette in Gänsefüßchen der `print`-Funktion als **Argument** übergeben:
%% Cell type:markdown id: tags:
**Anmerkung**: Die folgende Zelle verwendet `%%expect`, einen *magischer Befehl* von Jupyter. Der Befehl wird verwendet, wenn wir erwarten, dass der Code in dieser Zelle einen Fehler erzeugt. Mehr hierzu finden Sie im [Einführungsnotebook](seminar00.ipynb)
%% Cell type:code id: tags:
```
print()
%%expect SyntaxError
abs 42
```
%% Cell type:markdown id: tags:
Zusammengefasst: Die **Anweisung** ruft eine **Funktion** mit dem Namen `print` auf, der das **Argument** `Hello World!` mit `()` und Gänsefüßschen eingeschlossen übergeben wurde.
Sie können die erste Zeile der Meldung ignorieren, diese enthält keine Information, die Sie jetzt schon verstehen müssen.
In der zweiten Zeile ist der Code, der den Fehler enthält. Darunter befindet sich ein Caret (`^`), um die Stelle zu markieren, wo der Fehler gefunden wurde.
Die letzte Zeile zeigt auf, dass es sich um einen **Syntaxfehler** handelt, was bedeutet, dass etwas mit der Struktur des Ausdrucks nicht stimmt. In dem vorliegenden Beispiel ist das Problem, dass ein Funktionsaufruf Klammern erfordert.
Schauen Sie jetzt was passiert, wenn Sie die Klammern *und* den Wert weglassen.
%% Cell type:code id: tags:
```
abs
```
%% Cell type:markdown id: tags:
### Python-Programme starten
Der Name einer Funktion alleine ist ein erlaubter Ausdruck, der einen Wert hat.
Wenn er dargestellt wird zeigt der Wert an, dass `abs` eine Funktion ist. Er enthält auch einige zusätzliche Informationen, die später erklärt werden sollen.
Wenn wir ein Programm (hier einer der Blöcke mit Python-Code) starten, dann starten wir im Hintergrund den sogenannten **Python-Interpreter**. Das ist ein Programm, welches den Python-Code liest, für den Computer übersetzt und ausführt. Wir können den Python-Interpreter auch ohne Jupyter aufrufen und dort direkt Python-Anweisungen eingeben oder Programme starten, die wir in einer Datei gespeichert haben. Für den Anfang bleiben wir aber bei Jupyter, weil wir hier Programme und Erklärungen leicht kombinieren können.
%% Cell type:markdown id: tags:
### Arithmetik
## Zeichenketten
Neben Zeichenketten sind Zahlen ein wichtiges Mittel zur Informationsdarstellung. Wir können mit der `print`-Funktion auch Zahlen ausgeben, diese müssen wir nicht in Gänsefüßchen einschließen:
Außer Zahlen kann Python auch Abfolgen von Buchstaben repräsentieren, welche **Zeichenketten** (Englisch: _String_) heißen, da die Buchstaben aneinandergereiht werden wie Perlen auf eine Kette.
Um eine Zeichenkette zu schreiben können wir eine Buchstabenfolge in einfache gerade Anführungszeichen setzen.
%% Cell type:code id: tags:
```
print(17)
'Hello'
```
%% Cell type:markdown id: tags:
Siebzehn ist eine **ganze Zahl** (*Englisch: Integer*), wir können aber auch **Gleitkommazahlen** (*Englisch: Float*) also Zahlen mit Dezimalanteil darstellen:
Es ist auch erlaubt, doppelte gerade Anführungszeichen zu verwenden.
%% Cell type:code id: tags:
```
print(3.14159)
"world"
```
%% Cell type:markdown id: tags:
Dazu verwenden wir - anders als in Deutschland üblich - einen Punkt als Dezimaltrennzeichen anstelle eines Kommas. (Dies ist in den Ländern in denen Python entwickelt wurde so üblich.)
Doppelte gerade Anführungszeichen machen es einfach eine Zeichenkette zu schreiben, die einen Apostroph enthält, da dieser das gleiche Symbol verwendet wie ein einfaches gerades Anführungszeichen.
Arithmetische **Operatoren** ermöglichen die Verknüpfung von Zahlen durch Rechnen, z.B. `+` (Addition), `-` (Subtraktion), `*` (Multiplikation), `/` (Division) und `**` (Exponentiation).
%% Cell type:code id: tags:
Wir können eine Berechnung direkt mit `print` ausgeben:
```
"it's a small "
```
%% Cell type:markdown id: tags:
Zeichenketten können auch Leerzeichen, Punktuation und Ziffern enthalten.
%% Cell type:code id: tags:
```
'Well, '
```
%% Cell type:markdown id: tags:
Der `+` Operator arbeitet mit Zeichenketten, er fügt zwei Zeichenketten zu einer einzelnen zusammen. Dieser Vorgang heißt **Konkatenation** oder **Verkettung**.
%% Cell type:code id: tags:
```
'Well, ' + "it's a small " + 'world.'
```
%% Cell type:markdown id: tags:
Der `*` Operator funktioniert ebenfalls mit Zeichenketten, er macht Kopien von einer Zeichenkette und konkateniert diese.
%% Cell type:code id: tags:
```
'Spam, ' * 4
```
%% Cell type:markdown id: tags:
Die anderen arithmetischen Operatoren funktionieren nicht mit Zeichenketten.
Python bietet eine Funktion namens `len`, die die Länge einer Zeichenkette berechnet.
%% Cell type:code id: tags:
```
len('Spam')
```
%% Cell type:markdown id: tags:
Beachten Sie, dass `len` nur die Buchstaben zwischen den Anführungszeichen zählt, nicht die Anführungszeichen selbst.
Wenn Sie eine Zeichenkette erstellen ist es wichtig, gerade Anführungszeichen zu verwenden.
Der Gravis oder auch Abwärtsakzent (Englisch: _back quote_) verursacht einen Syntaxfehler.
%% Cell type:code id: tags:
```
%%expect SyntaxError
`Hello`
```
%% Cell type:markdown id: tags:
Typografische Anführungszeichen sind ebenfalls nicht erlaubt.
%% Cell type:code id: tags:
```
‘Hello’
```
%% Cell type:markdown id: tags:
## Werte und Datentypen
%% Cell type:code id: tags:
```
print(1+2+3-4+5)
from IPython.lib.display import YouTubeVideo
YouTubeVideo('https://www.youtube.com/watch?v=1WqFJ5wsA4o&list=PL_pqkvxZ6ho3u8PJAsUU-rOAQ74D0TqZB&index=5')
```
%% Cell type:markdown id: tags:
Probieren Sie es selbst für folgende Berechnungen aus:
Bis jetzt haben wir drei Arten von Werten gesehen:
* `2` ist eine ganze Zahl (Integer),
* `42.0` ist eine Gleitkommazahl (Float) und
- 40 + 2
- 43 - 1
- 6 * 7
- 84 / 2
- 6**2 + 6
* `'Hello'` ist eine Zeichenkette (String).
Sie können die folgende Anweisung ändern oder ergänzen.
Eine Art von Wert wird **Datentyp** genannt.
Jeder Wert hat einen Datentyp -- oder, wie es machmal ausgedrückt wird, "gehört" zu einem Datentyp.
Python bietet eine Funktion namens `type`, die Ihnen den Datentyp eines Werts mitteilen kann.
Der Datentyp einer ganzen Zahl (Integer) ist `int`.
%% Cell type:code id: tags:
```
print(40+2)
type(2)
```
%% Cell type:markdown id: tags:
Tipp: Wir können mehrere Anweisungen hintereinander ausführen, indem wir sie als **Folge** von Anweisungen zeilenweise untereinander schreiben
Der Datentyp einer Gleitkommazahl ist `float`.
%% Cell type:code id: tags:
```
print("Der Umfang eines Kreises mit dem Radius 3 ist:")
print(2 * 3.1415926 * 3)
type(42.0)
```
%% Cell type:markdown id: tags:
### Werte und Datentypen
Und der Datentyp eines Zeichenkette ist `str`.
Ein **Wert**, also z.B. eine Zahl oder eine Zeichenkette, ist eines der grundlegenden Dinge, die in einem Programm verarbeitet werden. Beispiele für Werte, die wir schon gesehen haben sind `"Hello World!"`, `17` und `3.1415926`. Diese Werte haben verschiedenen **Datentypen**:
- `"Hello World!"` ist eine **Zeichenkette** (Englisch: *string*)
- `17` ist eine **ganze Zahl** (Englisch: *integer*)
- `3.1415926` ist eine **Gleitkommazahl** (Englisch: *float*)
%% Cell type:code id: tags:
Wenn wir uns nicht sicher sind, welchen Datentyp ein Wert hat, können wir es mit der Funktion `type` herausfinden:
```
type('Hello, World!')
```
%% Cell type:markdown id: tags:
Die Datentypen `int`, `float`, und `str` können als Funktionen verwendet werden.
`int` kann beispielsweise eine Gleitkommazahl nehmen und diese in eine ganze Zahl umwandeln (rundet immer ab).
%% Cell type:code id: tags:
```
type("Hello World!")
int(42.9)
```
%% Cell type:markdown id: tags:
Diese gibt uns - je nach Datentyp - zum Beispiel die englischen Abkürzungen `str`, `int` und `float` zurück (die *string*, *integer* und *float* entsprechen). Probieren Sie es selbst mit verschiedenen Werten (z.B. 2, 42.0) aus:
Und `float` kann eine ganze Zahl in eine Gleitkommazahl umwandeln.
%% Cell type:code id: tags:
```
type()
float(42)
```
%% Cell type:markdown id: tags:
Übrigens: `type` funktioniert auch mit anderen Arten von "Typen". Probieren Sie es mal aus, indem Sie der `type`-Funktion die `print`-Funktion übergeben:
Nun kommt ein Punkt, der möglicherweise etwas verwirrend ist.
Was erhalten Sie, wenn Sie eine Zahlenabfolge in Anführungszeichen setzen?
%% Cell type:code id: tags:
```
type(print)
'126'
```
%% Cell type:markdown id: tags:
Was passiert, wenn wir Werte wie `"42"` und `"3.14"`mit Gänsefüßchen einfassen wie Zeichenketten? Finden Sie es heraus indem Sie den folgenden Codeblock nutzen.
Es sieht wie eine Zahl aus, ist aber eigentlich eine Zeichenkette.
%% Cell type:code id: tags:
```
type('126')
```
%% Cell type:markdown id: tags:
Sind es Zeichenketten oder Zahlen?
Wenn Sie versuchen, es wie eine Zahl zu verwenden, erhalten Sie möglicherweise eine Fehlermeldung.
%% Cell type:code id: tags:
```
%%expect TypeError
'126' / 3
```
%% Cell type:markdown id: tags:
Dieses Beispiel generiert einen `TypeError`, das bedeutet, dass die Werte im Ausdruck, die als **Operanden** bezeichnet werden, den falschen Datentyp haben.
Die Fehlermeldung drückt aus, dass der `/` Operator die Datentypen der Werte, in diesem Fall `str` und `int`, nicht unterstützt.
Wenn Sie eine Zeichenkette haben, die Ziffern enthält, können Sie `int` verwenden, um diese in eine ganze Zahl umzuwandeln.
%% Cell type:code id: tags:
```
int('126') / 3
```
%% Cell type:markdown id: tags:
Wenn Sie eine Zeichenkette haben, die Ziffern und einen Dezimalanteil enthält, können Sie `float` verwenden, um diese in eine Gleitkommazahl umzuwandeln.
%% Cell type:code id: tags:
```
float('12.6')
```
%% Cell type:markdown id: tags:
Wenn Sie eine große ganze Zahl schreiben sind Sie möglicherweise versucht, Kommata zwischen Gruppen von Ziffern zu verwenden, wie beispielsweise bei `1,000,000` (die Kommata werden hier so verwendet, wie im Deutschen bei großen Zahlen Punkte verwendet werden würden).
Dies ist ein erlaubter Ausdruck in Python, das Ergebnis ist allerdings keine ganze Zahl.
%% Cell type:code id: tags:
```
1,000,000
```
%% Cell type:markdown id: tags:
Python interpretiert `1,000,000` als eine Sequenz von ganzen Zahlen, die durch Kommata getrennt werden.
Wir werden über diese Art von Sequenz später noch mehr lernen.
Sie können stattdessen Unterstriche verwenden, um große Zahlen besser lesbar zu machen.
%% Cell type:code id: tags:
```
1_000_000
```
%% Cell type:markdown id: tags:
In Python gibt es noch weitere Datentypen, die wir später kennenlernen werden. Hier schon einmal ein Überblick:
![Datentypen](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/datentypen.png)
%% Cell type:markdown id: tags:
### Formale und natürliche Sprachen
## Formale und natürliche Sprachen
Besonders ausführlich wird der Unterschied zwischen natürlicher und formaler Sprache in [Abschnitt 1.6](http://greenteapress.com/thinkpython2/html/thinkpython2002.html#sec11) des englischen Buchs behandelt.
Grundsätzlich jedoch sind **natürliche Sprachen** Sprachen, die gesprochen werden, wie zum Beispiel Deutsch, Englisch oder Französisch. Sie werden nicht von Menschen entworfen und entwickeln sich natürlich.
**Formale Sprachen** sind von Menschen für bestimmte Zwecke entworfene Sprachen. Das hier relevanteste Beispiel sind **Programmiersprachen**.
Sie haben meist sehr strenge **Syntax-Regeln**, die ihre Struktur bestimmen. Dabei gibt es Regeln zu den erlaubten Zeichen und zu der erlaubten Struktur. Während der menschenliche **Parser** häufig mit sprachlichen Regelbrüchen umgehen kann, kann es der **Parser** im Computer nicht.
Sie haben meist sehr strenge **Syntax-Regeln**, die ihre Struktur bestimmen. Dabei gibt es Regeln zu den erlaubten Zeichen und zu der erlaubten Struktur. Während der menschliche **Parser** häufig mit sprachlichen Regelbrüchen umgehen kann, kann es der **Parser** im Computer nicht.
>Die§ ist ein gr@mmatikalisch k0rrekter S@tz mit ungültigen Zeichen. Satz dieser nur erlaubte Zeichen aber Grammatik falsche hat.
Wichtige Unterschiede sind, dass näturliche Sprache zweideutig, redundant und voller Symbolismus sein darf, formale Sprache aber nicht.
Wichtige Unterschiede sind, dass natürliche Sprache zweideutig, redundant und voller Symbolismus sein darf, formale Sprache aber nicht.
%% Cell type:markdown id: tags:
### Exkurs: Programmierer
## Exkurs: Programmierer*innen
Wir können effektiver programmieren, wenn wir eine **Entwicklungsumgebung** benutzen. Meistens ist das ein Texteditor, der einem das Programmieren erleichtert, indem z.B. der Quelltext farblich hervorgehoben wird - wie hier in Jupyter auch. Es gibt einen [seit Jahren schwelenden "Streit"](https://en.wikipedia.org/wiki/Editor_war), welcher Editor der beste ist: Emacs oder Vi. Randall Munroe (Autor des Webcomics [XKCD](https://xkcd.com/)) hat das auf seine ganz eigene Art verarbeitet:
![Real programmers set the universal constants at the start such that the universe evolves to contain the disk with the data they want.](https://imgs.xkcd.com/comics/real_programmers.png)
([Real Programmers](https://xkcd.com/378/), Randall Munroe)
%% Cell type:markdown id: tags:
### Debugging
## Debugging
Als Programmierer/innen machen wir häufiger Fehler. Diese Fehler werden **bugs** genannt und der Vorgang, Sie zu finden und zu beheben **debugging**. Dies kann zu starken (negativen) Gefühlen führen.
Es lässt sich darauf zurück führen, dass wir Computer unterbewusst wie Menschen behandeln und darum auf unkooperative Computer genauso reagieren wie auf unkooperative Mitmenschen. Es kann helfen darauf vorbereitet zu sein und den Computer als Mitarbeiter zu sehen, der sehr schnell und gut rechnen kann aber sehr genaue Anweisungen braucht.
Als Programmierer/innen machen wir häufiger Fehler. Diese Fehler werden **bugs** genannt und der Vorgang, Sie zu finden und zu beheben nennt man **debugging**. Dies kann zu starken (negativen) Gefühlen führen.
Es lässt sich darauf zurückführen, dass wir Computer unterbewusst wie Menschen behandeln und darum auf unkooperative Computer genauso reagieren wie auf unkooperative Mitmenschen. Es kann helfen darauf vorbereitet zu sein und den Computer als Mitarbeiter zu sehen, der sehr schnell und gut rechnen kann aber sehr genaue Anweisungen braucht.
Obwohl es sehr frustrierend sein kann zu lernen wie man diese Fehler findet und behebt ist es eine wertvolle Fähigkeit und in dieser Kategorie werden wir uns regelmäßig Tipps und Strategien des Debugging anschauen, die Ihnen hoffentlich helfen.
Obwohl es sehr frustrierend sein kann, zu lernen wie man diese Fehler findet und behebt, ist es eine wertvolle Fähigkeit und wir werden uns in dieser Kategorie regelmäßig Tipps und Strategien des Debugging anschauen, die Ihnen hoffentlich helfen.
![Computerweitwurf](https://media.giphy.com/media/L4AQvif7x9fS8/giphy.gif)
%% Cell type:markdown id: tags:
### Glossar
## Glossar
Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 1 gelernt haben:
- Anweisung:
- Programm:
- `print`-Funktion:
- Argument:
- Operator:
- Wert:
- Datentyp:
- Zeichenkette:
- ganze Zahl:
- Gleitkommazahl:
- bug:
- debugging:
Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit.
Sollten Sie einmal nicht weiterkommen, schauen Sie im Glossar von *Think Python* nach oder fragen Sie noch einmal nach.
%% Cell type:markdown id: tags:
### Übung
## Übung
Diese Übung ist ein wichtiger Teil des Seminars. Bitte fahren Sie erst fort, wenn Sie die Aufgaben selbständig lösen konnten. Sie geben Ihnen die Möglichkeit, das Gelernte zu überprüfen und zu vertiefen.
#### Aufgabe 1
%% Cell type:code id: tags:
```
# Diese Zelle weist Jupyter an, detaillierte Debugging-Informationen bereitzustellen.
# Führen Sie diese aus, bevor Sie an den Übungen arbeiten.
%xmode Verbose
```
%% Cell type:markdown id: tags:
### Fragen Sie einen virtuellen Assistenten
Während Sie sich durch dieses Buch arbeiten gibt es verschiedene Arten, auf die Sie einen virtuellen Assistenten oder Chatbot nutzen können, um Ihnen beim Lernen zu helfen.
* Wenn Sie mehr über ein in einem Kapitel behandeltes Thema wissen wollen, oder etwas noch nicht ganz verstanden haben, können Sie einen virtuellen Assistenten nach Erklärungen fragen.
* Wenn Ihnen die Übungen Schwierigkeiten bereiten, können Sie um Hilfe fragen.
Ich werde Ihnen in jedem Kapitel Übungen vorschlagen, die Sie mit einem virtuellen Assistenten bearbeiten können. Ich ermutige Sie aber auch dazu, selbst Dinge zu testen, um herausuzufinden, was für Sie am besten funktioniert.
Sie können zum Beispiel die [Sprachmodelle der HU](https://ki.cms.hu-berlin.de/de/large-language-models-an-der-hu) nutzen, sofern Sie sich im Netz der HU befinden oder sich [per VPN verbunden](https://www.cms.hu-berlin.de/de/dl/netze/vpn) haben.
Hier sind einige Themen, zu denen Sie einen virtuellen Assistenten befragen könnten:
* Weiter oben habe ich bitweise Operatoren erwähnt, aber nicht erklärt warum der Wert von `7 ^ 2` 5 ist. Versuchen Sie zu fragen "Was sind bitweise Operatoren in Python?" oder "Was ist der Wert von `7 XOR 2`?".
* Ich habe außerdem die Reihenfolge von Operationen erwähnt. Für mehr Details dazu, fragen Sie "Was ist die Reihenfolge der Operationen in Python?".
Wann immer wir etwas neues ausprobieren, sollten wir versuchen, absichtlich einen Fehler zu machen. Probieren Sie z.B.
- Was passiert, wenn Sie im "Hello World"-Programm eines der Gänsefüßchen weglassen?
- Was passiert, wenn Sie beide weglassen?
- Was passiert, wenn sie `print` falsch schreiben?
- Was passiert, wenn Sie beim Aufruf der `print`-Funktion eine oder beide der Klammern weglassen?
Probieren Sie es aus:
* Die `round` Funktion, die wir verwenden um eine Gleitkommazahl zu nächsten ganzen Zahl zu runden, kann ein zweites Argument aufnehmen. Versuchen Sie zu fragen "Was sind die Argumente der round-Funktion?" oder "Wie runde ich pi auf drei Nachkommastellen ab?".
* Es gibt einen weiteren arithmetischen Operator, den ich bisher nicht beschrieben habe. Versuchen Sie daher zu fragen: "Was ist der modulus Operator in Python?".
Die meisten virtuellen Assistenten kennen Python, daher beantworten Sie Fragen wie diese in der Regel recht zuverlässig.
Aber denken Sie immer daran, dass diese Tools Fehler machen können.
Wenn Sie Code von einem Chatbot erhalten, testen Sie diesen!
%% Cell type:markdown id: tags:
### Aufgabe 1
Sie fragen sich vielleicht, was `round` tut, wenn eine Zahl mit `0.5` endet.
Die Antwort ist, dass es manchmal auf- und manchmal abrundet.
Testen Sie diese Beispiele und versuchen Sie herauszufinden, welcher Regel das Runden der Zahlen folgt.
%% Cell type:code id: tags:
```
round(42.5)
```
%% Cell type:code id: tags:
```
round(43.5)
```
%% Cell type:markdown id: tags:
Solche Experimente helfen uns dabei das Gelesene einzuprägen. Zusätzlich werden mit Fehlermeldungen vertraut und haben eine Ahnung, was sie bedeuten könnten. Lieber jetzt ein paar Fehler absichtlich machen, als später unabsichtlich. Und letztlich lernen wir Programmieren nur, indem wir programmieren.
### Aufgabe 2
Wenn Sie ein neues Feature kennenlernen ist es sinnvoll, dieses auszuprobieren und dabei mit Absicht Fehler zu machen.
Auf diese Art lernen Sie die Fehlermeldungen und wissen bereits was diese bedeuten, wenn Sie Ihnen später erneut begegnen. Es ist besser, jetzt absichtlich Fehler zu machen, als später ausversehen.
- Negative Zahlen können wir mit einem Minuszeichen darstellen: `-2`. Was passiert, wenn wir ein Plus-Zeichen vor eine Zahl stellen? Was ergibt `2++2`? Was ergibt `2+-+2`? Probieren Sie es mit verschiedenen Kombinationen von Plus- und Minus-Zeichen aus, bis Ihnen klar ist, was passiert:
1. Sie können ein Minus-Zeichen verwenden, um eine negative Zahl wie `-2` darzustellen. Was passiert, wenn Sie ein Plus-Zeichen vor eine Zahl setzen? Was ergibt sich aus `2++2`?
- In der Mathematik ist es kein Problem, eine Null vor einer Zahl zu schreiben: 02 ist gleich 2. Was passiert, wenn wir das in Python probieren?
2. Was passiert, wenn Sie zwei Werte ohne Operator dazwischen haben, wie beispielsweise `4 2`?
- Was passiert, wenn wir zwei Werte ohne Operator dazwischen haben?
3. Wenn Sie eine Funktion wie `round(42.5)` aufrufen, was passiert, wenn Sie eine oder beide Klammern weglassen?
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
#### Aufgabe 2
### Aufgabe 3
Nutzen Sie Python als Taschenrechner:
Nutzen Sie Python als Taschenrechner: Keine Sorge, während Sie hier zwar Textaufgaben lösen müssen ist dies nicht das Ziel der Übung. Wenn Sie nicht weiterkommen schauen Sie sich zuerst die Hinweise an und fragen Sie gegebenenfalls um Hilfe. Es geht hier darum zu verstehen, wie man diese Aufgabe in Python lösen kann, der Rechenweg ist eher Zweitrangig.
- Wieviele Sekunden entsprechen 42 Minuten und 42 Sekunden?
- Wie viele Sekunden entsprechen 42 Minuten und 42 Sekunden?
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
- Wieviele Meilen entsprechen 10 Kilometer (Hinweis: eine Meile ist 1.61 Kilometer lang)
<details>
<summary type="button" class="btn btn-success">Lösung</summary>
<div class="alert alert-success" role="alert">
2562 Sekunden
</div>
</details>
%% Cell type:markdown id: tags:
- Wie viele Meilen entsprechen 10 Kilometern?
<details>
<summary type="button" class="btn btn-info">Hinweis</summary>
<div class="alert alert-info" role="alert">
Eine Meile ist 1.61 Kilometer lang.
</div>
</details>
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
- Wenn Sie ein Rennen über 10 Kilometer in 42 Minuten und 42 Sekunden beenden, was ist Ihre Durchschnittsgeschwindigkeit (Zeit pro Meile in Minuten und Sekunden)? Was ist Ihre Durchschnittsgeschwindigkeit in Meilen pro Stunde?
<details>
<summary type="button" class="btn btn-success">Lösung</summary>
<div class="alert alert-success" role="alert">
6.21 Meilen
</div>
</details>
%% Cell type:markdown id: tags:
- Wenn Sie ein Rennen über 10 Kilometer in 42 Minuten und 42 Sekunden beenden, was ist Ihre Durchschnittsgeschwindigkeit (**Zeit pro Meile** in Minuten und Sekunden)? Was ist Ihre Durchschnittsgeschwindigkeit in **Meilen pro Stunde**?
<details>
<summary type="button" class="btn btn-info">Hinweise</summary>
<div class="alert alert-info" role="alert">
1. Zuerst müssen Sie herausfinden wie viele Meilen das Rennen lang ist. Das können Sie im vorherigen Teil der Aufgabe erfahren. <br>
2. Rechnen Sie zudem die Zeit in Sekunden um. Dazu können Sie wieder die Lösung aus dem vorherigen Teil der Aufgabe nehmen. <br>
3. Um die Zeit pro Meile zu errechnen, müssen Sie die Gesamtzeit durch die Anzahl an Meilen teilen. Rechnen Sie anschließend die Zeit von Sekunden in Minuten pro Meile um. <br>
4. Um dann die Geschwindigkeit in Meilen pro Stunde zu berechnen gehen Sie analog vor. Teilen Sie die Gesamtzahl an Meilen durch die Gesamtdauer des Rennens. Rechnen Sie anschließend das Ergebnis von **Meilen pro Sekunde** in **Meilen pro Stunde** um.
</div>
</details>
%% Cell type:code id: tags:
```
```
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
##### Ergebnisse
![Spoiler Alert](https://imgs.xkcd.com/comics/spoiler_alert.png)
([Spoiler Alert](https://xkcd.com/109/), Randall Munroe)
<details>
<summary type="button" class="btn btn-success">Lösung</summary>
<div class="alert alert-success" role="alert">
Die Durchschnittsgeschwindigkeit beträgt 6,88 Minuten pro Meile bzw. 8,73 Meilen pro Stunde.
2562 Sekunden, 6.21 Meilen, Die Durchschnittsgeschwindigkeit beträgt 6,88 Minuten pro Meile bzw. 8,73 Meilen pro Stunde
</div>
</details>
%% Cell type:markdown id: tags:
![Speichern](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/floppy.png) Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (nicht auf einem Pool-Rechner). Rufen Sie dazu im Menü "File" den Punkt "Download as"->"Notebook" auf und nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/).
![Speichern](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/floppy.png) Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (nicht auf einem Pool-Rechner). Rufen Sie dazu im Menü *File* den Punkt *Download as* → *Notebook* auf und nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/).
Herzlichen Glückwunsch! Sie haben das erste Kapitel geschafft!
%% Cell type:markdown id: tags:
<img src="https://scm.cms.hu-berlin.de/ibi/python/-/raw/master/img/by-nc-sa.png" alt="CC BY-NC-SA" style="width: 150px;"/>
Der Text dieses Notebooks ist als freies Werk unter der Lizenz [CC BY-NC-SA 4.0 ](https://creativecommons.org/licenses/by-nc-sa/4.0/) verfügbar.
Der Code dieses Notebooks ist als freies Werk unter der Lizenz [MIT License](https://mit-license.org/) verfügbar.
Es handelt sich um übersetzte und leicht veränderte Notebooks von [Allen B. Downey](https://allendowney.com) aus [Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html).
......
notebooks/seminar02.ipynb
View file @ 9a8e896d
%% Cell type:markdown id: tags:
%% Cell type:markdown id:b112e25b tags:
# Seminar Problemorientierte Programmierung
# Kapitel 2: Variablen und Anweisungen
__[Chapter 2: Variables and Statements](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/chap02.ipynb)__
Eine der mächtigsten Fähigkeiten von Programmiersprachen ist, **Variablen** zu verändern. Variablen sind Namen, die auf einen Wert verweisen.
**Bevor Sie mit diesem Notebook starten, sollten Sie wiederholen, was Sie im letzten Notebook gelernt haben. Gehen Sie zurück und schauen Sie sich mindestens das Glossar an und wiederholen Sie die dort genannten Begriffe.**
%% Cell type:markdown id:019fa0dd-e50e-420b-94b1-40e0658f47d9 tags:
## Ihre Lernziele
Sie können eine Übersicht der Inhalte dieses Notebooks einblenden mit *Strg + Shift + k*.
Beschreiben Sie in 2-3 Stichpunkten kurz was Sie im Seminar heute lernen wollen. Klicken Sie dazu doppelt auf diesen Text und bearbeiten Sie dann den Text:
-
-
-
## Exkurs: Was mir an Python gefällt
In dieser Rubrik, die immer am Anfang eines Kapitels steht, möchte ich Ihnen zeigen, wofür ich Python nutze und warum ich es mag. Sie werden vielleicht noch nicht verstehen, was ich genau mache, aber Sie sehen damit schon einmal die Möglichkeiten von Python und können später darauf zurückgreifen. Da dies auch ein Exkurs ist, können Sie diese Rubrik gerne auch erst einmal überspringen.
Dieses Programm durchsucht alle Jupyter Notebooks in dem Verzeichnis in dem dieses Notebook gespeichert ist.
%% Cell type:code id: tags:
%% Cell type:code id:de4ca195-3433-4ff2-876f-5a63bd9cc9ee tags:
```
import os
query = "Experiment"
# Suche nach query in s; falls gefunden: Fundstelle + hervorgehobene Anfrage zurückgeben
def search(s, query, context = 20):
i = s.find(query)
if i >= 0:
return s[max(0, i-context):i] + "*" + s[i:i + len(query)] + "*" + s[i + len(query):min(len(s), i+context)]
return None
print("Suche nach '" + query + "':")
# alle Python-Notebooks im aktuellen Verzeichnis durchsuchen
for entry in os.listdir():
if entry.endswith(".ipynb"):
with open(entry, "rt") as f:
for line in f:
result = search(line, query)
if result:
print(entry + ":", result)
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:eb668bab-6740-474c-a0f2-659e67df4d7b tags:
## 2: Variablen, Ausdrücke und Anweisungen
## Herunterladen des unterstützenden Codes
Die folgende Zelle lädt eine Datei herunter und führt einen Code aus, der speziell für dieses Notebook verwendet wird. Sie müssen diesen Code nicht verstehen, aber Sie sollten die Zelle ausführen vor allen weiteren Zellen in diesem Notebook.
Weiter geht es in [Kapitel 2](http://greenteapress.com/thinkpython2/html/thinkpython2003.html).
%% Cell type:code id:d0775eaa-52a1-480f-a28d-a1754e9e61eb tags:
Eine der mächtigsten Fähigkeiten von Programmiersprachen ist, **Variablen** zu verändern. Variablen sind Namen, die auf einen Wert verweisen.
```
from os.path import basename, exists
def download(url):
filename = basename(url)
if not exists(filename):
from urllib.request import urlretrieve
local, _ = urlretrieve(url, filename)
print("Downloaded " + str(local))
return filename
download('https://github.com/AllenDowney/ThinkPython/raw/v3/thinkpython.py');
download('https://github.com/AllenDowney/ThinkPython/raw/v3/diagram.py');
import thinkpython
```
### Zuweisung
%% Cell type:markdown id:d0286422 tags:
Die **Zuweisung** ist eine besondere Form der Anweisung. Sie erzeugt eine neue Variable (falls Sie nicht schon existierte) und gibt ihr einen Wert:
# Variablen und Anweisungen
%% Cell type:code id: tags:
Im vorherigen Kapitel haben wir Operatoren verwendet, um Ausdrücke zu schreiben, die arithmetische Berechnungen ausführen.
In diesem Kapitel werden wir Variablen und Anweisungen, die `import` Anweisung und die `print` Funktion kennenlernen.
Außerdem werde ich weitere Teile des Vokabulars einführen, das wir verwenden, um über Programme zu sprechen, so etwa beispielsweise "Argument" und "Modul".
%% Cell type:markdown id:7c7e9108-43a5-41c8-8cbb-990d7dc2cc2f tags:
## Variablen
%% Cell type:code id:805ffc73-cc00-4c0b-b865-4f7acf1885bb tags:
```
from IPython.lib.display import YouTubeVideo
YouTubeVideo('https://www.youtube.com/watch?v=jfOLXKPGXJ0&list=PL_pqkvxZ6ho3u8PJAsUU-rOAQ74D0TqZB&index=4')
```
%% Cell type:markdown id:4ac44f0c tags:
Eine **Variable** ist ein Name, der sich auf einen Wert bezieht.
Um eine Variable zu erschaffen, können wir eine spezielle Anweisung, genannt **Zuweisung**, schreiben. Diese sieht wie folgt aus:
%% Cell type:code id:59f6db42 tags:
```
nachricht = "Das ist ein ganz einfacher Mechanismus."
n = 17
```
%% Cell type:markdown id:52f187f1 tags:
Eine Zuweisung hat drei Bestandteile: den *Namen* der Variable ganz links, ein *Gleichheitszeichen*, `=`, und einen *Ausdruck* auf der rechten Seite.
Im obigen Beispiel ist der Ausdruck eine ganze Zahl.
Im folgenden Beispiel ist der Ausdruck eine Gleitkommazahl:
%% Cell type:code id:1301f6af tags:
```
pi = 3.141592653589793
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:3e27e65c tags:
Und im nächsten Beispiel ist der Ausdruck eine Zeichenkette:
%% Cell type:code id:f7adb732 tags:
```
nachricht = 'Und nun für was ganz anderes'
```
In diesem Beispiel sehen wir drei Zuweisungen:
1. die erste weist die Zeichenkette `"Das ist ein ganz einfacher Mechanismus."` einer Variable mit dem Namen `nachricht` zu
2. die zweite weist die Zahl `17` der Variablen `n` zu und
3. die dritte weist (einen Näherungswert für) Pi der Variablen `pi` zu.
%% Cell type:markdown id:cb5916ea tags:
Legen Sie selbst ein paar Variablen an und weisen Sie Ihnen Werte zu:
Wenn wir eine Zuweisung ausführen, gibt es keine Ausgabe.
Python erschafft die Variable und gibt ihr einen Wert, aber die Zuweisung hat keinen sichtbaren Effekt.
Nachdem wir eine Variable erstellt haben, können wir diese als Ausdruck verwenden.
Also können wir den Wert von `nachricht` folgendermaßen ausgeben:
%% Cell type:code id: tags:
%% Cell type:code id:6bcc0a66 tags:
```
nachricht
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:e3fd81de tags:
### (Variablen)Namen
Wir können Variablen auch als Teil eines Ausdrucks mit arithmetischen Operatoren verwenden:
Variablen (und auch Funktionen) benötigen Namen. Als Programmierer/in sollten wir Namen wählen, die aussagekräftig sind und dokumentieren, wofür die Variable (oder Funktion) verwendet wird. Folgende Regeln gelten: Variablennamen
- dürfen beliebig lang sein
%% Cell type:code id:3f11f497 tags:
%% Cell type:code id: tags:
```
n + 25
```
%% Cell type:code id:6b2dafea tags:
```
diesistabereinelangevariableundtrotzdemmeckertpythonnicht = 1
2 * pi
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:97396e7d tags:
- dürfen Zahlen (0-9), Buchstaben (A-Z, a-z) und Unterstrich (`_`) enthalten
Und wir können eine Variable als Argument verwenden, wenn wir eine Funktion aufrufen:
%% Cell type:code id: tags:
%% Cell type:code id:72c45ac5 tags:
```
so_ist_es_besser_lesbar = "richtig"
round(pi)
```
%% Cell type:markdown id: tags:
%% Cell type:code id:6bf81c52 tags:
- aber nicht mit einer Zahl beginnen
```
len(nachricht)
```
%% Cell type:code id: tags:
%% Cell type:markdown id:af7974e4-6d01-43f7-b860-7c8dad808c9c tags:
Legen Sie selbst ein paar Variablen an und weisen Sie ihnen Werte zu:
%% Cell type:code id:36344854-6839-4bd4-8bd6-8ce175efb2da tags:
```
0das_gibt_Aerger = 1
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:6fe6b8fd-4ed6-40a8-a845-6d6f8d0a97c8 tags:
Der Name `0das_gibt_Aerger` ist nicht erlaubt, weil er mit einer Zahl beginnt. Probieren wir ein paar andere Namen aus (führen Sie den Code aus, um die Fehlermeldungen zu sehen):
## Zustandsdiagramme
Eine übliche Art, Variablen zu skizzieren, ist das Schreiben des Namens mit
einem Pfeil, der auf seinen Wert zeigt.
%% Cell type:code id: tags:
%% Cell type:code id:f5da0a13-dd3a-4f5d-855a-aa301b88fc6f tags:
```
mehr@ = 100
import math
from diagram import make_binding, Frame
binding = make_binding("nachricht", 'Und nun für was ganz anderes')
binding2 = make_binding("n", 17)
binding3 = make_binding("pi", 3.141592653589793)
frame = Frame([binding2, binding3, binding])
```
%% Cell type:code id: tags:
%% Cell type:code id:d0d366c3-5625-4810-bacb-eca0811fe8d9 tags:
```
class = 'Advanced Theoretical Zymurgy'
from diagram import diagram, adjust
width, height, x, y = [3.62, 1.01, 0.6, 0.76]
ax = diagram(width, height)
bbox = frame.draw(ax, x, y, dy=-0.25)
#adjust(x, y, bbox)
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:6fc2ea1c-e9f5-4404-890f-e7a9ea798c9c tags:
Diese Art von Abbildung wird **Zustandsdiagramm** genannt, weil sie zeigt, in welchem Zustand sich die einzelnen Variablen befinden (man kann sich das als den Geisteszustand der Variablen vorstellen).
Wir werden im gesamten Buch Zustandsdiagramme verwenden, um ein Modell darzustellen, wie Python Variablen und ihre Werte speichert.
%% Cell type:markdown id:ba252c85 tags:
Erklärungen:
- Der Name `mehr@` ist nicht erlaubt, weil das Zeichen `@` nicht zu den Zeichen gehört, aus denen ein Name bestehen darf.
- Der Name `class` ist anders, denn er enthält nur erlaubte Zeichen. Warum gibt es dennoch einen Fehler? Der Grund ist, dass `class` ein sogenanntes **Schlüsselwort** ist. Schlüsselwörter helfen Python, die Struktur eines Programms zu erkennen und dürfen daher nicht als Namen für Variablen (und Funktionen) verwendet werden. In Python 3 gibt es die folgenden Schlüsselwörter: `False None True and as assert break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield`. Sie brauchen sich die Liste nicht zu merken. In den meisten Entwicklungsumgebungen (Programmen zum Bearbeiten von Quellcode - wie z.B. Jupyter) werden diese Wörter farblich hervorgehoben und Sie werden somit gewarnt, falls Sie eines dieser Wörter als Variablennamen verwenden wollen.
## Variablennamen
%% Cell type:markdown id: tags:
Variablennamen können so lang sein, wie wir möchten. Sie können sowohl Buchstaben als auch Zahlen beinhalten, dürfen aber nicht mit einer Zahl beginnen.
Großbuchstaben sind erlaubt, es ist aber eher üblich, nur Kleinbuchstaben für Variablennamen zu verwenden.
### Ausdrücke und Anweisungen
Das einzige Sonderzeichen, welches in einem Variablennamen auftauchen darf, ist der Unterstrich, `_`. Er wird oft in Namen mit mehreren Worten wie zum Beispiel `dein_name` oder `so_ist_es_besser_lesbar` verwendet.
Ein **Ausdruck** ist eine Kombination von Werten, Variablen und Operatoren. Wir haben Ausdrücke bereits kennengelernt: In der Anweisung
Wenn wir einer Variable einen nicht erlaubten Namen geben, erhalten wir einen Syntaxfehler.
Der Name `million!` ist nicht erlaubt, da er das Sonderzeichen `!` enthält:
%% Cell type:code id: tags:
%% Cell type:code id:ac2620ef tags:
```
print(1 + 2 + 3 + 4 + 5)
```
%%expect SyntaxError
%% Cell type:markdown id: tags:
million! = 1000000
```
weiter oben gibt die `print`-Funktion den Wert des Ausdrucks `1 + 2 + 3 + 4 + 5` aus. In diesem Beispiel ist der Ausdruck `1 + 2 + 3 + 4 + 5` eine Kombination von Werten (1, 2, 3, 4, und 5) und dem Operator `+`.
%% Cell type:markdown id:a1cefe3e tags:
Jeder Wert ist selbst ein Ausdruck und auch jede Variable ist ein Ausdruck. Das folgende sind also alles Ausdrücke:
`0das_gibt_Aerger` ist nicht erlaubt, da es mit einer Zahl beginnt:
%% Cell type:code id: tags:
%% Cell type:code id:1a8b8382 tags:
```
42
%%expect SyntaxError
0das_gibt_Aerger = 1
```
%% Cell type:code id: tags:
%% Cell type:markdown id:94aa7e60 tags:
`class` ist ebenfalls nicht erlaubt, der Grund dafür ist aber weniger offensichtlich:
%% Cell type:code id:b6938851 tags:
```
n
%%expect SyntaxError
class = 'Selbstverteidigung gegen frisches Obst'
```
%% Cell type:markdown id:784cfb5c tags:
Es stellt sich heraus, dass `class` ein **Schlüsselwort** ist, das bedeutet ein spezielles Wort, das verwendet wird, um die Struktur eines Programmes anzugeben.
Schlüsselwörter können nicht als Variablennamen verwendet werden.
Hier ist eine vollständige Liste aller Schlüsselwörter von Python:
%% Cell type:markdown id:127c07e8 tags:
```
False await else import pass
None break except in raise
True class finally is return
and continue for lambda try
as def from nonlocal while
assert del global not with
async elif if or yield
```
%% Cell type:code id: tags:
%% Cell type:code id:4a8f4b3e tags:
```
n + 25
from keyword import kwlist
len(kwlist)
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:6f14d301 tags:
Wir brauchen uns diese Liste nicht zu merken. In den meisten Entwicklungsumgebungen (Programmen zum Bearbeiten von Quellcode – wie z.B. Jupyter) werden diese Wörter farblich hervorgehoben und wir werden somit gewarnt, falls wir eines dieser Wörter als Variablennamen verwenden wollen.
Wenn wir einen Ausdruck am Ende einer Code-Box in Jupyter eingeben, dann wird der Ausdruck **ausgewertet** (also dessen Wert berechnet) und das Ergebnis ausgegeben. Allerdings passiert sonst nicht viel - der Wert wird nicht gespeichert und kann so nicht weiterverwendet werden. Wir können aber beispielsweise mit einer Zuweisung (wie oben gesehen) den Wert eines Ausdrucks einer Variablen zuweisen.
![Keep it simple, stupid](http://www.commitstrip.com/wp-content/uploads/2016/09/Strip-Le-stagiaire-et-la-variable-english650-final.jpg)
**Anweisungen** haben wir in Kapitel 1 schon kennengelernt (als die Bausteine eines Programms). Anweisungen sind Codestücke, die eine Auswirkung haben - also z.B. einer Variablen einen Wert zuweisen oder ein Ergebnis anzeigen:
([Keep it simple, stupid](http://www.commitstrip.com/en/2016/09/01/keep-it-simple-stupid/), CommitStrip.com)
%% Cell type:code id: tags:
%% Cell type:markdown id:c954a3b0 tags:
## Die Import-Anweisung
Um manche Features von Python nutzen zu können, müssen diese zunächst **importiert** werden.
Die folgende Anweisung importiert zum Beispiel das `math` Modul:
%% Cell type:code id:98c268e9 tags:
```
n = 17
print(n)
import math
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:ea4f75ec tags:
Die erste Zeile ist eine Zuweisung, die der Variablen `n` einen Wert zuweist. Die zweite Zeile ruft die Funktion `print` auf, um den Wert von `n` auszugeben.
Ein **Modul** ist eine Sammlung von Variablen und Funktionen.
Das `math`-Modul stellt eine Variable namens `pi` zur Verfügung, die den Wert der mathematischen Konstante $\pi$ enthält.
Wir können ihren Wert folgendermaßen darstellen:
Wenn wir eine Anweisung starten (mit "Run Cell" aus dem "Cell"-Menü, oder `STRG-ENTER`), dann wird die Anweisung **ausgeführt**, d.h., der Python-Interpreter tut, was immer die Anweisung verlangt.
%% Cell type:code id:47bc17c9 tags:
Schreiben Sie eine Folge von drei Anweisungen:
1. Weisen Sie einer Variable `radius` den Wert 3 zu.
2. Weisen Sie einer Variable `umfang` den (Wert des) Ausdrucks zu, der den Umfang eines Kreises mit dem Radius `radius` berechnet
3. Geben Sie den Wert der Variablen `umfang` mit der Funktion `print` aus.
```
math.pi
```
%% Cell type:code id: tags:
%% Cell type:markdown id:c96106e4 tags:
Um eine Variable in einem Modul zu nutzen, müssen wir den **Punktoperator** (`.`) zwischen dem Namen des Moduls und dem Namen der Variable benutzen.
Das `math`-Modul enthält auch Funktionen.
Beispielsweise berechnet `sqrt` Quadratwurzeln:
%% Cell type:code id:fd1cec63 tags:
```
math.sqrt(25)
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:185e94a3 tags:
Prüfen Sie ihr Ergebnis - ist alles korrekt? Notieren Sie hier kurz, welche Schwierigkeiten Ihnen begegnet sind:
-
-
-
Und `pow` potenziert eine Zahl mit einer zweiten Zahl:
### Reihenfolge von Operatoren
%% Cell type:code id:87316ddd tags:
Enthält ein Ausdruck mehrere Operatoren, so werden diese in der folgenden Reihenfolge ausgewertet:
- Zuerst werden Klammern ausgewertet (wie in der Mathematik dürfen wir Klammern verwenden, um die Reihenfolge bei der Berechnung festzulegen):
```
math.pow(5, 2)
```
%% Cell type:markdown id:5df25a9a tags:
Bisher haben wir zwei Möglichkeiten gesehen, eine Zahl zu potenzieren: Wir können die Funktion `math.pow` oder den Potenzierungsoperator `**` verwenden.
Beide Optionen sind in Ordnung, der Operator wird aber häufiger als die Funktion verwendet.
%% Cell type:markdown id:6538f22b tags:
## Ausdrücke und Anweisungen
Bislang haben wir verschiedene Arten von **Ausdrücken** gesehen.
Ein Ausdruck kann ein einzelner Wert sein, wie etwa eine ganze Zahl, eine Gleitkommazahl oder eine Zeichenkette.
Er kann auch eine Ansammlung von Werten und Operatoren sein.
Er kann außerdem Variablennamen und Funktionsaufrufe enthalten.
Hier ist ein Ausdruck, der mehrere dieser Elemente beinhaltet:
%% Cell type:code id: tags:
%% Cell type:code id:7f0b92df tags:
```
2 * (3-1)
19 + n + round(math.pi) * 2
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:000dd2ba tags:
ist also 4 und
Wir haben auch schon einige Arten von Anweisungen gesehen.
Eine **Anweisung** ist eine Einheit von Code, die eine Wirkung, aber keinen Wert hat.
Zum Beispiel erstellt eine Zuweisung (die eine spezielle Anweisung ist) eine Variable und gibt ihr einen Wert, aber die Anweisung selbst hat keinen Wert.
%% Cell type:code id: tags:
%% Cell type:code id:b882c340 tags:
```
(1+1)**(5-2)
n = 17
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:cff0414b tags:
ist 8
- Exponentiation hat die nächsthöhere Priorität, daher ergibt
Ähnlich verhält es sich mit der Import-Anweisung: sie importiert ein Modul, damit wir dessen Werte und Funktionen nutzen können, aber sie hat keinen sichtbaren Effekt:
%% Cell type:code id: tags:
%% Cell type:code id:299817d8 tags:
```
1 + 2**3
import math
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:2aeb1000 tags:
Denn Wert eines Ausdrucks zu berechnen bezeichnet man als **Evaluation**.
Die Ausführung einer Anweisung heißt **Ausführung**.
9 (und nicht 27) und
%% Cell type:markdown id:f61601e4 tags:
%% Cell type:code id: tags:
## Die `print`-Funktion
Wenn wir einen Ausdruck evaluieren, wird das Ergebnis dargestellt:
%% Cell type:code id:805977c6 tags:
```
2 * 3**2
n + 1
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:efacf0fa tags:
Wenn wir allerdings mehr als einen Ausdruck gleichzeitig evaluieren, wird nur der Wert des letzten gezeigt:
ergibt 18 (und nicht 36).
%% Cell type:code id:962e08ab tags:
- Multiplikation und Division haben eine höhere Priorität als Addition und Subtraktion. Daher ergibt
```
n + 2
n + 3
```
%% Cell type:markdown id:cf2b991d tags:
Um mehr als einen Wert anzuzeigen, können wir die `print`-Funktion nutzen:
%% Cell type:code id: tags:
%% Cell type:code id:a797e44d tags:
```
2*3-1
print(n+2)
print(n+3)
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:29af1f89 tags:
5 und nicht 4 und
Diese funktioniert auch mit Gleitkommazahlen und Zeichenketten:
%% Cell type:code id: tags:
%% Cell type:code id:73428520 tags:
```
6+4/2
print('Der Wert der Kreiszahl ist ungefähr')
print(math.pi)
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:8b4d7f4a tags:
ergibt 8 und nicht 5.
Wir können auch eine Reihe von Ausdrücken, getrennt durch Kommata verwenden:
- Operatoren mit der gleichen Priorität werden von links nach rechts ausgewertet (ausser Exponentiation). Im Ausdruck `degrees / 2 * pi` wird also zuerst dividiert und dann wird mit `pi` multipliziert. Um stattdessen durch `pi` zu dividieren, können wir Klammern verwenden oder stattdessen `degrees / 2 / pi` schreiben.
%% Cell type:code id:9ad5bddd tags:
```
print('Der Wert der Kreiszahl ist ungefähr', math.pi)
```
Wir müssen uns die Reihenfolge nicht merken. Wenn wir uns nicht sicher sind, verwenden wir einfach Klammern, um die Reihenfolge festzulegen.
%% Cell type:markdown id:af447ec4 tags:
Ändern Sie den folgenden Ausdruck so ab, dass zuerst 2 und 3.141 addiert werden und das Ergebnis mit 4 multipliziert wird:
Beachten Sie, dass die `print`-Funktion eine Leerstelle zwischen den Werten platziert.
%% Cell type:code id: tags:
%% Cell type:markdown id:7c73a2fa tags:
## Argumente
%% Cell type:code id:edd0832f-501c-4a4c-97e0-835f30d274f6 tags:
```
2 + 3.141 * 4
from IPython.lib.display import YouTubeVideo
YouTubeVideo('https://www.youtube.com/watch?v=af9ORp1Pty0&list=PL_pqkvxZ6ho3u8PJAsUU-rOAQ74D0TqZB&index=19')
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:c90012b9-3656-48a7-a815-523e7c3b72c4 tags:
Wenn wir eine Funktion aufrufen, heißt der Ausdruck in den Klammern **Argument**.
Normalerweise würde ich erklären, warum, aber in diesem Fall hat die technische Bedeutung des Begriffs fast nichts mit der gewöhnlichen Bedeutung des Wortes zu tun, daher werde ich es erst gar nicht versuchen.
Die Ausgabe sollte dann 20.564 statt 14.564 betragen.
Einige der Funktionen, die wir bisher gesehen haben nehmen nur ein Argument auf, so wie `int`:
### Operatoren für Zeichenketten
%% Cell type:code id:060c60cf tags:
```
int('101')
```
Im allgemeinen können wir mathematische Operatoren nicht für Zeichenketten verwenden, auch wenn die Zeichenketten wie Zahlen aussehen:
%% Cell type:markdown id:c4ad4f2c tags:
%% Cell type:code id: tags:
Manche nehmen zwei auf, so wie `math.pow`:
%% Cell type:code id:2875d9e0 tags:
```
'2' - '1'
math.pow(5, 2)
```
%% Cell type:code id: tags:
%% Cell type:markdown id:17293749 tags:
Manche können auch zusätzliche optionale Argumente aufnehmen.
Zum Beispiel kann `int` ein zweites Argument annehmen, das die Basis der Zahl angibt:
%% Cell type:code id:43b9cf38 tags:
```
'acht' / 'zwei'
int('101', 2)
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:c95589a1 tags:
Die Ziffernfolge „101“ zur Basis 2 entspricht der Zahl 5 zur Basis 10.
Es gibt aber zwei Ausnahmen: `+` und `*`:
`round` nimmt auch ein optionales zweites Argument auf, dieses gibt die Anzahl an Dezimalstellen an, auf die gerundet werden soll:
%% Cell type:code id: tags:
%% Cell type:code id:e8a21d05 tags:
```
a = "Donau"
b = "dampf"
c = "schiff"
a + b + c
round(math.pi, 3)
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:21e4a448 tags:
Manche Funktionen können auch beliebig viele Argumente aufnehmen, so zum Beispiel `print`:
%% Cell type:code id:724128f4 tags:
```
print('So', 'viele', 'wie', 'gewünscht')
```
Mit dem Operator `+` können wir Zeichenketten verknüpfen (oder verketten). D.h., die beiden Zeichenketten werden hinereinander geschrieben.
%% Cell type:markdown id:667cff14 tags:
Mit dem Operator `*` können wir eine Zeichkette wiederholen:
Wenn wir eine Funktion aufrufen und zu viele Argumente für diese angeben führt das zu einem `TypeError`:
%% Cell type:code id: tags:
%% Cell type:code id:69295e52 tags:
```
c * 3
%%expect TypeError
float('123.0', 2)
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:5103368e tags:
Dabei muss einer der beiden Werte eine Zeichenkette sein und der andere eine ganze Zahl. Probieren Sie aus, ob die Reihenfolge von Zeichenkette und Zahl egal ist:
Wenn wir zu wenige Argumente angeben führt das ebenfalls zu einem `TypeError`.
%% Cell type:code id: tags:
%% Cell type:code id:edec7064 tags:
```
%%expect TypeError
math.pow(2)
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:5333c416 tags:
Die beiden Operatoren funktionieren ähnlich wie bei Zahlen: So wie `4*3` gleich `4+4+4` ist, ist `dampf*3` gleich `dampfdampfdampf`. Allerdings gibt es einen wichtigen Unterschied: Welche Eigenschaft erfüllt die Addition bei Zahlen, die die Verknüpfung von Zeichenketten nicht erfüllt?
-
Und wenn wir ein Argument eines Datentyps liefern, der nicht mit der Funktion kompatibel ist, ergibt auch das einen `TypeError`:
### Kommentare
%% Cell type:code id:f86b2896 tags:
Sobald Programme größer und komplexer werden, wird es schwer, sie zu verstehen. Die Information, die im Programmcode steckt ist sehr dicht und es fällt oft schwer, nur durch einen Blick auf den Programmcode herauszufinden, was der Code macht und warum.
```
%%expect TypeError
math.sqrt('123')
```
%% Cell type:markdown id:548828af tags:
Diese Art der Kontrolle kann am Anfang lästig sein, aber sie hilft uns, Fehler zu erkennen und zu korrigieren.
%% Cell type:markdown id:be2b6a9b tags:
## Kommentare
Sobald Programme größer und komplexer werden, wird es schwer, sie zu verstehen. Die Information, die im Programmcode steckt, ist sehr dicht und es fällt oft schwer, nur durch einen Blick auf den Programmcode herauszufinden, was der Code macht und warum.
Daher ist es eine gute Idee, Notizen in natürlicher Sprache einzufügen, die erklären, was das Programm macht. Diese Notizen heißen **Kommentare** und sie beginnen mit dem Zeichen `#`:
%% Cell type:code id: tags:
%% Cell type:code id:607893a6 tags:
```
pi = 3.1415926
pi = 3.141592653589793
radius = 7
# die Fläche eines Kreises berechnen
flaeche = 2 * pi * radius**2
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:519c83a9 tags:
Wir können Kommentare auch am Ende einer Zeile hinzufügen:
%% Cell type:code id: tags:
%% Cell type:code id:615a11e7 tags:
```
flaeche = 2 * pi * radius**2 # die Fläche eines Kreises berechnen
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:87c8d10c tags:
Alles ab `#` bis zum Ende der Zeile wird ignoriert und hat keine Auswirkung auf die Ausführung des Programms.
- Kommentare werden in der Entwicklungsumgebung oft farblich hervorgehoben, was zusätzlich die Orientierung erleichtert.
- Kommentare sind am hilfreichsten, wenn sie das nicht-Offensichtliche erklären
- Wir können davon ausgehen, dass der/die Leser/in herausfinden kann, *was* das Programm macht, daher sollten wir eher erklären *warum* das an der Stelle gemacht wird.
- Wir können davon ausgehen, dass der$*$die Leser$*$in herausfinden kann, *was* das Programm macht, daher sollten wir eher erklären *warum* das an der Stelle gemacht wird.
Der folgende Kommentar ist beispielsweise redundant und daher nutzlos:
%% Cell type:code id: tags:
%% Cell type:code id:cc7fe2e6 tags:
```
v = 5 # assign 5 to v
v = 8 # 8 der Variable v zuordnen
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:eb83b14a tags:
Dieser Kommentar dagegen enthält nützliche Information, die sich nicht im Quellcode befindet:
%% Cell type:code id: tags:
%% Cell type:code id:7c93a00d tags:
```
v = 5 # Geschwindigkeit in Meter pro Sekunde
v = 8 # Geschwindigkeit in Kilometern pro Stunde
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:6cd60d4f tags:
Übrigens können wir uns mit aussagekräftigen Variablennamen auch Kommentare sparen. (Andererseits werden Ausdrücke durch sehr lange Namen auch schwerer lesbar ... wir müssen also einen guten Mittelweg finden.)
Mit aussagekräftigen Variablennamen können wir uns Kommentare sparen, allerdings werden Ausdrücke durch sehr komplexe oder lange Namen schwer lesbar. Wir müssen also einen guten Mittelweg finden.
Finden Sie heraus, was das folgende Programm tut und fügen Sie aussagekräftige Kommentare hinzu:
%% Cell type:code id: tags:
%% Cell type:code id:b2503cf2-b1ee-43b7-8420-11091c3dd1e3 tags:
```
import math
x1 = 5
y1 = 4
x2 = 1
y2 = 1
distance_h = x1 - x2
distance_v = y1 - y2
distance = math.sqrt(distance_h**2 + distance_v**2)
print("distance((x1, y1), (x2, y2)) = ", distance)
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:c97c7d01-0aa8-463a-b312-8ae312ccba2b tags:
Exkurs: Wieviele Kommentare in einem Programm gut und notwendig sind, ist durchaus umstritten. Wenn Sie mögen, können Sie einen Ausschnitt des Diskurses dazu hier verfolgen:
- "Good code is its own best documentation." ([Steve McConnell](http://en.wikipedia.org/wiki/Steve_McConnell))
- http://mikegrouchy.com/blog/2013/03/yes-your-code-does-need-comments.html
- https://stackoverflow.com/questions/184618/what-is-the-best-comment-in-source-code-you-have-ever-encountered
Wieviele Kommentare in einem Programm gut und notwendig sind ist durchaus umstritten. Wenn Sie mögen, können Sie einen Ausschnitt des Diskurses dazu hier verfolgen:
%% Cell type:markdown id: tags:
### Debugging
- ["Good code is its own best documentation." (Steve McConnell)](http://de.wikipedia.org/wiki/Steve_McConnell)
- ["Yes your Code does need comments" (Mike Grouchy)](http://mikegrouchy.com/blog/2013/03/yes-your-code-does-need-comments.html)
- [Funny comments](https://stackoverflow.com/questions/184618/what-is-the-best-comment-in-source-code-you-have-ever-encountered)
![Comments are areas of text that computers ignore ...](https://prairieworldcomicsblog.files.wordpress.com/2018/01/progelements2comments.jpg?w=656)
([Programming Elements – Comments](https://prairieworldcomicsblog.wordpress.com/2018/01/26/programming-elements-comments/), William Wise)
%% Cell type:markdown id:7d61e416 tags:
## Debugging
Programme können drei Arten von Fehlern enthalten:
- Syntax-Fehler ("syntax error")
- Laufzeit-Fehler ("runtime error")
- Semantische Fehler
- **Syntax-Fehler** ("syntax error") – Fehler in der **Syntax**, also der Struktur, des Programmes. Das Programm ist nicht ausführbar bis der Fehler behoben ist. Vor allem zu Beginn, werden Sie vermutlich viele Syntax- Fehler machen, zum Beispiel indem Sie eine Klammer vergessen. Je mehr Übung Sie haben, desto weniger Syntax-Fehler werden Sie machen. Zudem werden Sie diese auch schneller finden.
- **Laufzeit-Fehler** ("runtime error") – Laufzeit-Fehler treten erst auf, während das Programm läuft. Sie werden auch **Ausnahme** ("exception") genannt, da sie üblicherweise bedeuten, dass etwas außergewöhnliches (und schlechtes) passiert ist. In einfachen Programmen sind Laufzeitfehler selten, Sie werden Ihnen vermutlich noch eine Weile nicht begegnen.
- **Semantische Fehler** ("semantic error") sind Fehler in der **Semantik** – also Fehler, die mit der Bedeutung des Programms zusammenhängen. Das Programm läuft ohne eine Fehlermeldung auszugeben, aber das Ergebnis ist nicht so wie erwartet. Das Programm tut genau das, was Sie ihm gesagt haben. Semantische Fehler zu finden ist schwierig, da von der Ausgabe aus rückwärts durch das Programm gearbeitet werden muss. Häufig ist es hilfreich zusätzliche `print`-Anweisungen einzufügen, die Zwischenergebnisse ausgeben, sodass der Punkt gefunden werden kann, an dem die erwarteten Ergebnisse von den tatsächlichen abweichen.
Lesen Sie mehr zu den Unterschieden in [Abschnitt 2.8](http://greenteapress.com/thinkpython2/html/thinkpython2003.html#sec23).
%% Cell type:markdown id:6cd52721 tags:
%% Cell type:markdown id: tags:
Wie wir bereits gesehen haben, handelt es sich bei einem nicht erlaubten Variablennamen um einen Syntax-Fehler:
### Glossar
%% Cell type:code id:86f07f6e tags:
```
%%expect SyntaxError
million! = 1000000
```
%% Cell type:markdown id:b8971d33 tags:
Wenn wir einen Operator mit einem Datentyp verwenden, den dieser nicht unterstützt, ist das ein Laufzeit-Fehler:
%% Cell type:code id:682395ea tags:
```
%%expect TypeError
'126' / 3
```
%% Cell type:markdown id:e51fa6e2 tags:
Zuletzt noch ein Beispiel für einen semantischen Fehler.
Nehmen wir an, wir wollen den Durchschnitt von `1` und `3` berechnen, vergessen aber die Reihenfolge der Operationen zu beachten und schreiben Folgendes:
%% Cell type:code id:2ff25bda tags:
```
1 + 3 / 2
```
%% Cell type:markdown id:0828afc0 tags:
Wird dieser Ausdruck evaluiert, produziert er keine Fehlermeldung, also liegt hier kein Syntax- oder Laufzeit-Fehler vor.
Aber das Ergebnis ist trotzdem nicht der Durchschnitt von `1` und `3`, also ist das Programm nicht korrekt.
Dies ist ein semantischer Fehler, da das Programm zwar läuft, es aber nicht tut, was es tun soll.
%% Cell type:markdown id:07396f3d tags:
## Glossar
Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 2 gelernt haben:
- Variable:
- Zuweisung:
- Schlüsselwort:
- Ausdruck:
- Zeichenketten verknüpfen:
- Zuweisung: Eine Zuweisung ist eine Anweisung, bei der einer Variable ein Wert zugewiesen wird
- Zuweisungsanweisung:
- Keyword:
- Import-Anweisung:
- Modul:
- Punktoperator:
- evaluieren:
- Anweisung:
- ausführen:
- Argument:
- Kommentar:
- Syntaxfehler:
- Laufzeitfehler:
- semantischer Fehler:
- Laufzeit-Fehler:
- Ausnahme:
- Semantischer Fehler:
- `print`-Funktion:
Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit.
%% Cell type:markdown id:70ee273d tags:
## Übung
%% Cell type:code id:c9e6cab4 tags:
```
# Diese Zelle weist Jupyter an, detaillierte Debugging-Informationen bereitzustellen, wenn ein
# Laufzeit-Fehler passiert. Führen Sie sie daher aus, bevor Sie mit den Übungsaufgaben beginnen.
%xmode Verbose
```
%% Cell type:markdown id:7256a9b2 tags:
%% Cell type:markdown id: tags:
### Fragen Sie einen virtuellen Assistenten
### Übung
Auch hier möchte ich Sie dazu ermutigen, einen virtuellen Assistenten zu benutzen, um mehr über die Themen in diesem Kapitel zu erfahren.
#### Aufgabe 1
Sie können zum Beispiel die [Sprachmodelle der HU](https://ki.cms.hu-berlin.de/de/large-language-models-an-der-hu) nutzen, sofern Sie sich im Netz der HU befinden oder sich [per VPN verbunden](https://www.cms.hu-berlin.de/de/dl/netze/vpn) haben.
Wenn wir etwas neues lernen, sollten wir es immer gleich ausprobieren. Wir sollten auch versuchen, absichtlich ein paar Fehler einzubauen, um zu schauen, was dann passiert.
Wenn Sie sich für eines der aufgeführten Keywords interessieren, könnten Sie fragen: „Warum ist class ein Keyword?“ oder „Warum können Variablennamen keine Keywords sein?“
Sie haben vielleicht bemerkt, dass `int`, `float` und `str` keine Python-Keywords sind.
Sie sind Variablen, die Datentypen repräsentieren, und können als Funktionen verwendet werden.
Es ist also *erlaubt*, eine Variable oder Funktion mit einem dieser Namen zu haben, aber es wird dringend davon abgeraten. Fragen Sie einen Assistenten: „Warum ist es schlecht, int, float und string als Variablennamen zu verwenden?“
Fragen Sie auch: „Was sind eingebaute Funktionen in Python?“
Wenn Sie sich für eine dieser Funktionen interessieren, fragen Sie nach weiteren Informationen dazu.
In diesem Kapitel haben wir das Modul `math` importiert und einige der Variablen und Funktionen verwendet, die es zur Verfügung stellt. Fragen Sie einen Assistenten: „Welche Variablen und Funktionen befinden sich im math Modul?“ und „Welche anderen Module außer math werden zum Kern von Python gezählt?“
%% Cell type:markdown id:f92afde0 tags:
### Aufgabe 1
Wenn wir etwas Neues lernen, sollten wir es immer gleich ausprobieren. Wir sollten auch versuchen, absichtlich ein paar Fehler einzubauen, um zu sehen, was dann passiert und zu lernen, wie die Fehlermeldungen aussehen.
- Wir haben gesehen, dass `n = 42` erlaubt ist. Was ist mit `42 = n`?
%% Cell type:code id: tags:
%% Cell type:code id:02492a50-8c57-4ff2-89d6-b7aee56ace1a tags:
```
```
%% Cell type:markdown id:23695a85-af17-4c18-8f6e-0b097b4aace7 tags:
- Und wie sieht es mit `x = y = 1` aus? (Lassen Sie sich danach die Werte für `x` und `y` mit Hilfe der `print`-Funktion ausgeben.)
%% Cell type:code id:f155a57c-13fa-43e8-82fa-140dcfe4749e tags:
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:b10a289b-638a-4c2d-b3c1-e9895f9f26f0 tags:
- Und wie schaut es mit `x = y = 1` aus? (Lassen Sie sich danach die Werte für `x` und `y` mit Hilfe der `print`-Funktion ausgeben.)
- In einigen Programmiersprachen müssen Anweisungen mit einem Semikolon, `;`, beendet werden. Was passiert, falls wir in Python ein Semikolon ans Ende einer Anweisung schreiben?
%% Cell type:code id: tags:
%% Cell type:code id:279c1809-8c52-4e23-8b97-f0b36fcef40d tags:
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:98d78f94-12c8-41fa-b884-853cf961b0a8 tags:
- In einigen Programmiersprachen müssen Anweisungen mit einem Semikolon (;) beendet werden. Was passiert, falls wir in Python ein Semikolon ans Ende einer Anweisung schreiben?
- Und was passiert, wenn wir einen Punkt, `.`, ans Ende einer Anweisung schreiben?
%% Cell type:code id: tags:
%% Cell type:code id:5a6fc1ab-a0fe-4b1b-ad0c-efa46c51f959 tags:
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:98b4fcad-cd82-4380-b1f5-895181ae94c4 tags:
- Und was passiert, wenn wir einen Punkt (.) ans Ende einer Anweisung schreiben?
- Was geschieht, wenn Sie den Namen eines Moduls falsch schreiben und versuchen, `maath` zu importieren?
%% Cell type:code id: tags:
%% Cell type:code id:1ac92469-267c-49af-af3f-8480e9bd8059 tags:
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:9d562609 tags:
### Aufgabe 2
Nutzen Sie Python als Taschenrechner. Denken Sie auch hier wieder daran, dass wir nicht zwingend Ihre mathematischen Fähigkeiten testen wollen. Nutzten Sie erst die Hinweise und versuchen Sie einander zu helfen, aber zögern Sie nicht uns zu fragen. Es ist wichtiger, dass Sie verstehen, wie Sie die Aufgabe in Python umsetzen, als die mathematischen Grundlagen zu verstehen.
#### Aufgabe 2
Nutzen Sie Python als Taschenrechner:
- Das Volumen einer Kugel mit dem Radius r ist 4/3 π r³. Wie groß ist das Volumen einer Kugel mit dem Radius 5?
- Wie groß ist das Volumen einer Kugel mit dem Radius 5?
%% Cell type:code id: tags:
<details>
<summary type="button" class="btn btn-info">Hinweis</summary>
<div class="alert alert-info" role="alert">
Die Formel zum Berechnen des Volumens ist: $v = 4/3⋅π⋅r^3$
</div>
</details>
%% Cell type:code id:18de7d96 tags:
```
pi = 3.141592653589793
# Geben Sie hier Ihren Ausdruck zur Berechnung ein
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:e6efaa50-7662-46ea-90e1-de82e321f34c tags:
<details>
<summary type="button" class="btn btn-success">Lösung</summary>
<div class="alert alert-success" role="alert">
Das Volumen ist 523,599.
</div>
</details>
%% Cell type:markdown id:6449b12b tags:
**Part 2.** Eine trigonometrische Regel besagt, dass für jeden Wert von $x$, $(\cos x)^2 + (\sin x)^2 = 1$. Lassen Sie uns sehen, ob das für einen bestimmten Wert von $x$ wie zum Beispiel 42 zutrifft.
Erstellen Sie eine Variable namens `x` mit diesem Wert.
Nutzen Sie dann `math.cos` und `math.sin`, um den Sinus und den Cosinus von $x$ sowie die Summe ihrer Quadrate zu berechnen.
%% Cell type:markdown id:96953cee-b713-47b3-8767-fcb3642394c7 tags:
- Angenommen, der Preis des Buches "Once upon an Algorithm" ist 29,99€, aber wir bekommen es mit 40% Rabatt, weil wir eine Bildungseinrichtung sind. Der Versand kostet 3€ für das erste Buch und 0,75€ für jedes weitere Buch. Wir wollen 60 Exemplare für das IBI bestellen - was kostet uns das insgesamt?
<details>
<summary type="button" class="btn btn-info">Hinweis</summary>
<div class="alert alert-info" role="alert">
%% Cell type:code id: tags:
Die Variable wird in Klammern an die Funktion übergeben, dies hat die Form "Modul.Funktion(Variable)".
</div>
</details>
%% Cell type:code id:de812cff tags:
```
# Geben Sie hier Ihren Ausdruck zur Berechnung ein
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id:4ac41dca-6490-4a8f-bbe5-cf77a2909c00 tags:
<details>
<summary type="button" class="btn btn-success">Lösung</summary>
<div class="alert alert-success" role="alert">
Das Ergebnis sollte nahe bei 1 liegen. Es ist möglicherweise nicht genau 1, da die Fließkommaarithmetik nicht exakt ist, sondern nur annähernd korrekt.
</div>
</details>
%% Cell type:markdown id:4986801f tags:
**Part 3.** Außer `pi` ist noch eine weitere Variable, `e`, im `math` Modul definiert, welche die Basis des natürlichen Logarithmus, in mathematischer Notation "$e$", repräsentiert. Wenn Sie sich mit diesem Wert nicht auskennen, fragen Sie einen virtuellen Assistenten „Was ist `math.e`?“ Lassen Sie uns nun $e^2$ auf drei verschiedene Arten berechnen:
* Verwenden Sie `math.e` und den Potenzierungsoperator (`**`).
* Verwenden Sie `math.pow`, um `math.e` auf die Potenz `2` zu erhöhen.
* Verwenden Sie `math.exp`, das als Argument einen Wert $x$ nimmt und $e^x$ berechnet.
Ihnen fällt vielleicht auf, dass das letzte Ergebnis leicht von den anderen zwei abweicht.
Schauen Sie, ob Sie herausfinden können, welches das Richtige ist.
%% Cell type:markdown id:316ffc26-6b79-490e-aee7-84670505dc97 tags:
<details>
<summary type="button" class="btn btn-info">Hinweis</summary>
<div class="alert alert-info" role="alert">
Die Variable wird in Klammern an die Funktion übergeben, dies hat die Form "Modul.Funktion(Variable)". Statt einer Variable kann auch eine weitere Funktion übergeben werden, solange sie ein gültiges Ergebnis (eine Zahl) an die übergeordnete Funktion übergibt.
</div>
</details>
(Ergebniskontrolle: Die gesamte Bestellung würde 1126,89€ kosten.)
%% Cell type:code id:54bc23ce-e82a-4b7c-816e-8ecf13ae974a tags:
- Wenn ich mein Haus um 6:52 Uhr verlasse und 1 Meile gemütlich laufe (8:15 Minuten pro Meile), dann 3 Meilen schneller (7:12 Minuten pro Meile) und dann nochmal 1 Meile gemütlich, wann komme ich dann zum Frühstück an?
```
# Geben Sie hier Ihren Ausdruck zur Berechnung ein
```
%% Cell type:code id: tags:
%% Cell type:code id:aff052ca-1e28-4a13-b63b-e440920646f6 tags:
```
# Geben Sie hier Ihren Ausdruck zur Berechnung ein
```
%% Cell type:markdown id: tags:
%% Cell type:code id:4d730af9-f237-44c6-a8dc-5c8f0575e75e tags:
```
# Geben Sie hier Ihren Ausdruck zur Berechnung ein
```
%% Cell type:markdown id:e66990f0-6442-4c13-968a-a89b6cbccf71 tags:
<details>
<summary type="button" class="btn btn-success">Lösung</summary>
<div class="alert alert-success" role="alert">
Die ersten beiden Aufgaben liefern das Ergebnis 7.3890560989306495.
Die letzte Aufgabe liefert das Ergbnis 7.38905609893065.
</div>
</details>
%% Cell type:markdown id:b436a292-a82a-42f6-8215-73ccc22b568c tags:
![Speichern](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/floppy.png) Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (nicht auf einem Pool-Rechner). Rufen Sie dazu im Menü *File* den Punkt *Download as* → *Notebook* auf und nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/).
%% Cell type:markdown id:1bda5b12-5432-4822-9fbe-c112576b96d2 tags:
(Ankunft ist 7:30 Uhr und 6 Sekunden.)
![Speichern](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/floppy.png) Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (nicht auf einem Pool-Rechner). Rufen Sie dazu im Menü "File" den Punkt "Download as"->"Notebook" auf und nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/).
Herzlichen Glückwunsch! Sie haben das 2. Kapitel geschafft!
%% Cell type:markdown id:27e14f5c-6f38-4cd6-81b3-709a3faceb02 tags:
%% Cell type:markdown id: tags:
<img src="https://scm.cms.hu-berlin.de/ibi/python/-/raw/master/img/by-nc-sa.png" alt="CC BY-NC-SA" style="width: 150px;"/>
![Smiley](https://upload.wikimedia.org/wikipedia/commons/thumb/b/bc/Face-grin.svg/240px-Face-grin.svg.png)
Der Text dieses Notebooks ist als freies Werk unter der Lizenz [CC BY-NC-SA 4.0 ](https://creativecommons.org/licenses/by-nc-sa/4.0/) verfügbar.
Der Code dieses Notebooks ist als freies Werk unter der Lizenz [MIT License](https://mit-license.org/) verfügbar.
Herzlichen Glückwunsch! Sie haben das 2. Kapitel geschafft. Weiter geht es in [3: Funktionen](seminar03.ipynb).
Es handelt sich um übersetzte und leicht veränderte Notebooks von [Allen B. Downey](https://allendowney.com) aus [Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html).
......

Impressum | Datenschutzerklärung