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 (222)
122 additional commits have been omitted to prevent performance issues.
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 9313 additions and 3796 deletions
README.org
View file @ 9a8e896d
......@@ -19,18 +19,17 @@ 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.
......@@ -52,18 +51,18 @@ Urheber nennen und sie nicht für kommerzielle Zwecke nutzen.
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]]
- 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
......
img/by-nc-sa.png 0 → 100644
View file @ 9a8e896d
img/by-nc-sa.png

21.9 KiB

notebooks/FAQ.ipynb
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 12)
- 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 in GitLab 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 auf
den Button "Download" und speichern Sie es als Datei:
* Seminar Problemorientierte Programmierung
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 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:
[[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/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
This diff is collapsed.
notebooks/hausaufgabe2.ipynb
View file @ 9a8e896d
This diff is collapsed.
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.
* Geben Sie bitte Ihrem **Notebook einen Namen**, sodass es Ihnen und Ihrem Partner zugeordnet werden kann (z.B. *hausaufgabe2_nachname1_nachname2.ipynb*)
* Fügen Sie außerdem **Kommentare** zu ihrem Code hinzu, mit denen Sie erklären, was die Funktion macht (Schleife, Bedingungen, etc. beschreiben). Dies kann man durch zwei Varianten machen:
- \#
- Mit Hilfe der Raute kann ein Kommentar in einem Codeblock stehen, um einzelne Codesgemente zu beschreiben und zu interpretieren
- z.B. : # Kommentar zu einzelnen Code-Segmenten
- ''' '''
- Hier kann ein Kommentar stehen, der die Funktion als Ganzes beschreibt
- z.B. ''' Beschreibung einer Funktion '''
Wir wünschen viel Erfolg beim Lösen der Aufgaben!
%% Cell type:markdown id: tags:
# 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.
Ihre Aufgabe ist es, einen Durchlauf des Spiels zu implementieren.
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.
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.
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:
```
``` 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:
```
# Rufen Sie hier ihre Funktionen auf, um sie zu testen
``` 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 (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(5, 0)
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`).
*Falls Sie die Lösung aus der Übung übernehmen, schreiben Sie Kommentare, die zeigen, dass Sie den Code und die Rekursion verstanden haben. Ansonsten wird die Aufgabe nicht gewertet.*
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 Sie hier ihre Funktion
``` python
def ist_potenz(a,b):
```
%% Cell type:code id: tags:
```
# Rufen Sie hier ihre Funktionen auf, um sie zu testen
``` 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
```
%% Cell type:code id: tags:
```
# Testaufruf, der die Tabelle oben erzeugen sollte
``` 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).
%% Cell type:code id: tags:
```
```
%% 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 anderen Start- und Endwerten aufrufen:
%% Cell type:code id: tags:
```
``` python
```
%% Cell type:markdown id: tags:
## Aufgabe 5 (Zusatz):
Nutzen Sie Rekursion (falls nicht schon in Hausaufgabe2 benutzt), um Ihre Schildkröte ein Kunstwerk malen zu lassen. Schauen Sie in Notebook 5 nach, um sich inspirieren zu lassen.
Diese Aufgabe ist freiwillig.
Sie können gerne wieder kreativ werden.
![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 10. Kapitel durchgearbeitet haben, da Iteration, Rekursion, Verzweigungen und Funktionen mit Rückgabewert benötigt werden.
- Geben Sie bitte Ihrem Notebook einen Namen, sodass es Ihnen und Ihrem Partner zugeordnet werden kann (z.B. nachname1_nachname2_hausaufgabe2.ipynb)
- Fügen Sie außerdem Kommentare / Docstrings zu jedem Code hinzu, mit denen Sie erklären, was die Funktion macht (Schleife, Bedingungen, etc. beschreiben). **Falls das nicht gemacht wird, wird der Code nicht bewertet.**
- 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.
### 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.
### 1a
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.
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
*(Dies ist [Aufgabe 2 im 7. Kapitel](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar07.ipynb#aufgabe-2).)*
Die eingebaute Funktion `eval` erwartet eine Zeichenkette und führt sie dann mit dem Python-Interpreter aus. Beispielsweise:
%% Cell type:code id: tags:
```
eval('1 + 2 * 3')
```
### 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.
%% Cell type:code id: tags:
```
import math
eval('math.sqrt(5)')
```
``` python
def is_number(s):
pass
%% Cell type:code id: tags:
```
eval('type(math.pi)')
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:
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.
Die Funktion sollte so lange laufen, bis der Nutzer `fertig` eingibt und dann sollte der Rückgabewert des letzten ausgeführten Ausdrucks ausgegeben werden.
### 1d
Schreiben Sie jeweils eine Funktion, die als Parameter eine Zeichenkette erwartet und alle Ziffern innerhalb einer Zeichenkette ausgibt.
%% Cell type:code id: tags:
```
# Implementieren Sie hier die Funktion eval_loop
```
``` python
def return_digits(s):
pass
%% Cell type:markdown id: tags:
## Aufgabe 3
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.")
```
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
%% Cell type:markdown id: tags:
\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}
### 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.
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.
Hinweis: Falls das Wort *USA* gefunden werden soll, sollen auch *usa, Usa, uSa*, usw. gefunden werden.
%% Cell type:code id: tags:
```
# Implementieren und testen Sie hier ihre Funktion
``` python
def count_occ(s, w):
pass
print(estimate_pi())
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:
## Aufgabe 4
## Aufgabe 2
Schreiben Sie jeweils eine Funktion, die als Argument eine Zeichenkette erwartet und
- prüft, ob das erste Zeichen der Zeichenkette ein Kleinbuchstaben ist.
- prüft, ob das erste und das letzte Zeichen Kleinbuchstaben sind.
- prüft, ob alle Zeichen der Zeichenkette Zahlen sind.
- alle Zahlen der Zeichenkette ausgibt.
- die Stelle ausgibt, an der eine Zahl gefunden wurde.
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.
Rufen Sie ihre Funktionen mit verschiedenen Parametern auf, um sie auf Funktionalität zu testen.
- 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:
```
```
``` python
def process_text(s):
pass
%% Cell type:markdown id: tags:
Die nachfolgenden Aufgaben können Sie erst lösen, wenn sie das notebook seminar09.ipynb durchgearbeitet haben
process_text(" The function Return-Digits(S) returns all digits of a string. BELIEVE ME. ... ")
```
%% Cell type:markdown id: tags:
## Aufgabe 5 - freiwillig
Diese Aufgabe basiert auf einem Rätsel welches im Radioprogramm [Car Talk](http://www.cartalk.com/content/puzzlers) gesendet wurde.
## Aufgabe 3
> Gib' mir ein Wort mit zwei aufeinanderfolgenden doppelten Buchstaben. Ich gebe Dir ein paar Wörter, die sich fast dafür qualifizieren (aber nur fast!) - beispielsweise das Wort Kommission, K-o-m-m-i-s-s-i-o-n. Es wäre gut, aber leider hat sich das "i" zwischen "mm" und "ss" eingeschlichen. Oder "Ballett" - wenn wir das "e" entfernen könnten, würde es klappen. Aber es gibt mindestens ein Wort, welches zwei aufeinanderfolgende Paare von (jeweils gleichen) Buchstaben hat und vielleicht ist es das einzige solche Wort. Welches Wort ist es?
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.
Schreiben Sie ein Programm, um das Wort zu finden. Die Lösung für englische Wörter (http://thinkpython2.com/code/cartalk1.py) findet sogar Wörter mit drei aufeinanderfolgenden Buchstabenpaaren (die es im Deutschen vermutlich nicht gibt, zumindest nicht in der hier verwendeten Wortliste).
%% Cell type:code id: tags:
```
# Implementieren Sie hier das Programm
```
%% Cell type:markdown id: tags:
## Augabe 6 - freiwillig
Ein ähnliches Problem:
![But the windows! What if there's a voyeur watchi-- wait, now I'm turned on too.](https://imgs.xkcd.com/comics/consecutive_vowels.png)
[Consecutive Vowels](https://xkcd.com/853/), Randall Munroe
Schreiben Sie ein Programm, welches das Wort mit den meisten hintereinander auftauchenden Vokalen in unserer Wortliste findet.
``` python
def del_elements(l, d):
pass
%% Cell type:code id: tags:
```
# Implementieren Sie hier das Programm
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
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/programmierspaß_spiele.ipynb
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
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
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 2. Ausgabe des Buches [Think Python](http://greenteapress.com/wp/think-python-2e/) von Allen B. Downey.
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:
<h1>Table of Contents<span class="tocSkip"></span></h1>
<div class="toc"><ul class="toc-item"><li><span><a href="#Lernziele-und-Ablauf-diese-Seminars" data-toc-modified-id="Lernziele-und-Ablauf-diese-Seminars-1"><span class="toc-item-num">1&nbsp;&nbsp;</span>Lernziele und Ablauf diese Seminars</a></span></li><li><span><a href="#Tipps" data-toc-modified-id="Tipps-2"><span class="toc-item-num">2&nbsp;&nbsp;</span>Tipps</a></span></li><li><span><a href="#Wiederkehrende-Abschnitte" data-toc-modified-id="Wiederkehrende-Abschnitte-3"><span class="toc-item-num">3&nbsp;&nbsp;</span>Wiederkehrende Abschnitte</a></span></li><li><span><a href="#Hinweise-zur-Benutzung-von-Jupyter" data-toc-modified-id="Hinweise-zur-Benutzung-von-Jupyter-4"><span class="toc-item-num">4&nbsp;&nbsp;</span>Hinweise zur Benutzung von Jupyter</a></span><ul class="toc-item"><li><span><a href="#Jupyter-Notebook-Grundlagen-und-Informationen" data-toc-modified-id="Jupyter-Notebook-Grundlagen-und-Informationen-4.1"><span class="toc-item-num">4.1&nbsp;&nbsp;</span>Jupyter Notebook Grundlagen und Informationen</a></span></li><li><span><a href="#Standardbrowser" data-toc-modified-id="Standardbrowser-4.2"><span class="toc-item-num">4.2&nbsp;&nbsp;</span>Standardbrowser</a></span><ul class="toc-item"><li><span><a href="#Anleitungen" data-toc-modified-id="Anleitungen-4.2.1"><span class="toc-item-num">4.2.1&nbsp;&nbsp;</span>Anleitungen</a></span></li></ul></li><li><span><a href="#Shortcuts" data-toc-modified-id="Shortcuts-4.3"><span class="toc-item-num">4.3&nbsp;&nbsp;</span>Shortcuts</a></span><ul class="toc-item"><li><span><a href="#Beispiel:-Markdown-Zelle-vs.-Code-Zelle" data-toc-modified-id="Beispiel:-Markdown-Zelle-vs.-Code-Zelle-4.3.1"><span class="toc-item-num">4.3.1&nbsp;&nbsp;</span>Beispiel: Markdown Zelle vs. Code Zelle</a></span></li></ul></li></ul></li><li><span><a href="#Exkurs:-Was-mir-an-Python-gefällt:" data-toc-modified-id="Exkurs:-Was-mir-an-Python-gefällt:-5"><span class="toc-item-num">5&nbsp;&nbsp;</span>Exkurs: Was mir an Python gefällt:</a></span></li></ul></div>
%% 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 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
- **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
### 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 = 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/seminar00_covid.ipynb deleted 100644 → 0
View file @ a91d1781
%% Cell type:markdown id: tags:
# Seminar Problemorientierte Programmierung
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 2. Ausgabe des Buches [Think Python](http://greenteapress.com/wp/think-python-2e/) von Allen B. Downey.
%% Cell type:markdown id: tags:
<h1>Table of Contents<span class="tocSkip"></span></h1>
<div class="toc"><ul class="toc-item"><li><span><a href="#Lernziele-und-Ablauf-diese-Seminars" data-toc-modified-id="Lernziele-und-Ablauf-diese-Seminars-1"><span class="toc-item-num">1&nbsp;&nbsp;</span>Lernziele und Ablauf diese Seminars</a></span></li><li><span><a href="#Tipps" data-toc-modified-id="Tipps-2"><span class="toc-item-num">2&nbsp;&nbsp;</span>Tipps</a></span></li><li><span><a href="#Wiederkehrende-Abschnitte" data-toc-modified-id="Wiederkehrende-Abschnitte-3"><span class="toc-item-num">3&nbsp;&nbsp;</span>Wiederkehrende Abschnitte</a></span></li><li><span><a href="#Hinweise-zur-Benutzung-von-Jupyter" data-toc-modified-id="Hinweise-zur-Benutzung-von-Jupyter-4"><span class="toc-item-num">4&nbsp;&nbsp;</span>Hinweise zur Benutzung von Jupyter</a></span><ul class="toc-item"><li><span><a href="#Jupyter-Notebook-Grundlagen-und-Informationen" data-toc-modified-id="Jupyter-Notebook-Grundlagen-und-Informationen-4.1"><span class="toc-item-num">4.1&nbsp;&nbsp;</span>Jupyter Notebook Grundlagen und Informationen</a></span></li><li><span><a href="#Standardbrowser" data-toc-modified-id="Standardbrowser-4.2"><span class="toc-item-num">4.2&nbsp;&nbsp;</span>Standardbrowser</a></span><ul class="toc-item"><li><span><a href="#Anleitungen" data-toc-modified-id="Anleitungen-4.2.1"><span class="toc-item-num">4.2.1&nbsp;&nbsp;</span>Anleitungen</a></span></li></ul></li><li><span><a href="#Shortcuts" data-toc-modified-id="Shortcuts-4.3"><span class="toc-item-num">4.3&nbsp;&nbsp;</span>Shortcuts</a></span><ul class="toc-item"><li><span><a href="#Beispiel:-Markdown-Zelle-vs.-Code-Zelle" data-toc-modified-id="Beispiel:-Markdown-Zelle-vs.-Code-Zelle-4.3.1"><span class="toc-item-num">4.3.1&nbsp;&nbsp;</span>Beispiel: Markdown Zelle vs. Code Zelle</a></span></li></ul></li></ul></li><li><span><a href="#Exkurs:-Was-mir-an-Python-gefällt:" data-toc-modified-id="Exkurs:-Was-mir-an-Python-gefällt:-5"><span class="toc-item-num">5&nbsp;&nbsp;</span>Exkurs: Was mir an Python gefällt:</a></span></li></ul></div>
%% 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.
Dieses Semester wird wie folgt ablaufen:
1. Suchen Sich sich einen Partner!
2. Sie arbeiten als Pair-Programming-Team die Jupyter-Notebooks durch.
- Planen Sie einen oder zwei **regelmäßige** Termine pro Woche ein, an denen Sie mit ihrem Partner die Aufgaben durcharbeiten.
- remote Pair-Programming Möglichkeiten werden Ihnen am Anfang des Semesters vorgestellt.
- Wechseln Sie sich alle 15 Minuten ab bzw. wechseln Sie Ihre Rollen (siehe Pair-Programming: Navigator_in <--> Fahrer_in).
3. Ich biete jeden Tag außer MITTWOCHS (Vorlesungstag) eine Online-Sprechstunde an. Suchen Sie sich einen Termin aus, an dem Sie regelmäßig anwesend sind. Trauen Sie sich zu fragen!
4. Jede Woche gebe ich bekannt, bis zu welcher Aufgabe Sie kommen sollen. Das ist von Woche zu Woche unterschiedlich, da Sie mit den Notebooks unterschiedlich viel Zeit brauchen.
## 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 im entsprechenden Notebook auf. Oft hilft das Aufschreiben eines Problems schon bei der Lösung eines Problems.
## 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. (Hier müssen Sie nichts verändern, es reicht, die Zelle auszuführen).
- **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
### 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)
%% 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:
```
# 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:
## 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:
```
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 = 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)
notebooks/seminar01.ipynb
View file @ 9a8e896d
This diff is collapsed.
notebooks/seminar02.ipynb
View file @ 9a8e896d
This diff is collapsed.
notebooks/seminar03.ipynb
View file @ 9a8e896d
This diff is collapsed.
notebooks/seminar04.ipynb
View file @ 9a8e896d
This diff is collapsed.
notebooks/seminar05.ipynb
View file @ 9a8e896d
This diff is collapsed.
notebooks/seminar06.ipynb
View file @ 9a8e896d
This diff is collapsed.
notebooks/seminar07.ipynb
View file @ 9a8e896d
This diff is collapsed.

Impressum | Datenschutzerklärung