Commit bd61cb6b authored by Axel Dürkop's avatar Axel Dürkop
Browse files

Updates

parent e2e1440e
......@@ -2,7 +2,7 @@
title= "Bedingte Anweisungen und Verzweigungen"
date= 2019-04-02T12:50:13+01:00
draft= false
weight = 0
weight = 40
# Table of content (toc) is enabled by default. Set this parameter to true to disable it.
# Note: Toc is always disabled for chapter pages
......
+++
title= "Funktionen mit Rückgabewert"
date= 2020-11-26T12:50:13+01:00
draft= false
weight = 80
# Table of content (toc) is enabled by default. Set this parameter to true to disable it.
# Note: Toc is always disabled for chapter pages
disableToc = false
# If set, this will be used for the page's menu entry (instead of the `title` attribute)
menuTitle = ""
# The title of the page in menu will be prefixed by this HTML content
pre= ""
# The title of the page in menu will be postfixed by this HTML content
post = ""
# Set the page as a chapter, changing the way it's displayed
chapter= false
# Hide a menu entry by setting this to true
hidden = false
# Display name of this page modifier. If set, it will be displayed in the footer.
LastModifierDisplayName = "Axel Dürkop"
# Email of this page modifier. If set with LastModifierDisplayName, it will be displayed in the footer
LastModifierEmail = "axel.duerkop@tuhh.de"
+++
Funktionen können auch das Ergebnis ihrer Arbeit zurückgeben. Ein Beispiel:
```python
def setup():
size(100, 200)
def draw():
if check_mouse_position():
print("Getroffen!")
else:
print("")
def check_mouse_position():
if mouseX > 50:
return True
else:
return False
```
Die Funktion `check_mouse_position()` fungiert als Helferin. Sie prüft, ob eine Bedingung erfüllt ist oder nicht. Entsprechend liefert sie einen Wahrheitswert zurück. In der `draw()` wird davon Gebrauch gemacht: Sofern `check_mouse_position()` den Wahrheitswert `True` zurückliefert, wird "Getroffen!" auf der Konsole ausgegeben.
Zugegeben, die Funktion ist nicht sonderlich hilfreich in diesem Moment. Man hätte auch direkt die Überprüfung der Mausposition in der `draw()` auswerten können. Aber da Programme in der Regel wachsen und langsam komplexer werden, ist es klug, von vornherein eine Funktion vorzubereiten, deren Inhalt mitwachsen kann.
### Funktionen mit Parameterübergabe und Rückgabewert
Selbstverständlich können Funktionen auch einen Wert zurückgeben, der aus übergebenen Parametern resultiert. Dieser Fall kommt häufig vor. Ein Beispiel:
```python
def berechne_bildpunkte(w, h):
return w * h
result = berechne_bildpunkte(300, 300)
print(result)
```
Die Funktion nimmt zwei Parameter an, deren Produkt gebildet wird. Das Ergebnis wird zurückgegeben. Dort, wo die Funktion aufgerufen wurde, kommt nun dieses Ergebnis an und wird der Variablen `result` zugewiesen. Im weiteren Verlauf des Programms kann `result` dann verwendet werden.
+++
title= "Funktionen"
date= 2020-11-26T12:50:13+01:00
draft= false
weight = 60
# Table of content (toc) is enabled by default. Set this parameter to true to disable it.
# Note: Toc is always disabled for chapter pages
disableToc = false
# If set, this will be used for the page's menu entry (instead of the `title` attribute)
menuTitle = ""
# The title of the page in menu will be prefixed by this HTML content
pre= ""
# The title of the page in menu will be postfixed by this HTML content
post = ""
# Set the page as a chapter, changing the way it's displayed
chapter= false
# Hide a menu entry by setting this to true
hidden = false
# Display name of this page modifier. If set, it will be displayed in the footer.
LastModifierDisplayName = "Axel Dürkop"
# Email of this page modifier. If set with LastModifierDisplayName, it will be displayed in the footer
LastModifierEmail = "axel.duerkop@tuhh.de"
+++
Funktionen machen es möglich, eine Reihe von Anweisungen mehrfach auszuführen. Damit kann vermieden werden, dass derselbe Code mehrfach geschrieben oder gar mit *copy and paste* vervielfältigt wird. Dieses Konzept ist nicht nur ein Merkmal von Python, auch in anderen Sprachen sind Funktionen zu finden. Funktionen können auch aus Daten neue Daten berechnen und stellen ein wesentliches Werkzeug für die Strukturierung von Programmen dar.
### Eingebaute Funktionen
In den vorherigen Kapiteln sind schon einige Funktionen verwendet worden, die in Python eingebaut sind oder die von Processing für Python zur Verfügung gestellt werden.
```python
# Beispiele für Processing-Funktionen, die mit Python verwendet werden können.
size(200, 300) # Funktion für die Definition der Leinwandgröße
print(x) # Funktion zur Ausgabe von Daten auf der Konsole
```
Weitere Funktionen sind auf der Referenzseite von [Processing ](http://py.processing.org/reference) einzusehen.
Häufig ist es so, dass die Funktionen einer Programmiersprache zwar eine Reihe von Standardaufgaben abdecken, komplexere Programme aber individuelle Lösungen und damit auch neue, individuelle Funktionen benötigen. Daher ist es auch in Python möglich, eigene Funktionen zu definieren und ihnen das gewünschte Verhalten "einzubauen".
### Eigene Funktionen definieren
Die Definition von Funktionen in Python ist denkbar einfach. Genaugenommen haben wir das bisher schon oft getan:
```python
# Einmalige Ausführung von Grundeinstellungen für das Programm
def setup():
fullScreen()
ellipseMode(CENTER)
# Wiederholte Ausführung (Endlosschleife)
def draw():
ellipse(mouseX, mouseY, 50, 50)
```
Hierbei handelt es sich um zwei Funktionen, die, wenn sie definiert sind, beim Start eines Programms ausgeführt werden. Alle anderen Funktionen, die wir definieren, müssen ausdrücklich aufgerufen werden.
`mousePressed()` ist eine weitere Systemfunktion von Processing, mit der sich der Mausklick abfragen lässt:
```python
# Einmalige Ausführung bei Mausklick
def mousePressed():
fill(random(255))
```
Mit dem Schlüsselwort `def` wird die *Definition* einer Funktion eingeleitet. Zusammen mit dem *Namen* der Funktion und möglichen *Parametern* bildet diese erste Zeile die *Funktionssignatur*.
Eingerückt folgt dann der Code, der beim Aufruf der Funktion ausgeführt werden soll, der *Funktionsrumpf*. Er kann aus beliebig vielen Zeilen bestehen. Eine goldene Regel lautet:
**Wichtig!** Eine Funktion kann zwar viele Zeilen Code enthalten. Sie sollte aber genau eine Aufgabe erledigen.
Da es möglich ist, beliebig viele Funktionen zu definieren, wächst deren Anzahl in einem Programm, wenn es komplexer wird. Der Name der Funktion ist frei wählbar, solange er den Regeln des [PEP 0008](https://www.python.org/dev/peps/pep-0008/#function-names) folgt. Neben den syntaktischen Anforderungen ist eine Sache sicherlich besonders hervorzuheben:
**Wichtig!** Der Name der Funktion sollte aussagen, was die Aufgabe der Funktion ist. Daher ist `zeichne_kreuz()` aussagekräftiger als `kreuz()`.
Im folgenden Beispiel wird eine Funktion definiert, die in alle vier Ecken der Leinwand einen Punkt zeichnet.
```python
def zeichne_eckpunkte():
point(0, 0)
point(width - 1, 0)
point(0, height - 1)
point(width - 1, height - 1 )
```
Die Ausführung des Programms zeigt kein Ergebnis. Es fehlt noch der *Aufruf* der Funktion.
```python
zeichne_eckpunkte()
```
**Wichtig!** Funktionen in Python werden nur ausgeführt, wenn sie aufgerufen werden.
### Lokale und globale Variablen
Damit man Variablen *innerhalb* von Funktionen **ändern** kann, die *außerhalb* definiert wurden, müssen sie mit `global` für die jeweilige Funktion verfügbar gemacht werden. Andernfalls kommt es zu einer Fehlermeldung:
![](../images/fehler-zugriff-variable.png)
Mit `global` funktioniert die Aktualisierung von `x`:
```python
x = 0
def draw():
global x
x = x + 1
```
Die theoretischen Grundlagen für dieses Vorgehen werden im Kapitel [Variablen](../../programmiergrundlagen/variablen) genauer ausgeführt.
### Empfohlene Videos zum Thema
* [Funktionen](https://www.youtube.com/watch?v=Uzb_ajpcMUo&feature=youtu.be&list=PLD20BEE125C1FC7B1) erklärt von [openscreencast](https://www.youtube.com/channel/UC_oJHQiMx9dNkbt2Wz9nicQ)
\ No newline at end of file
+++
title= "Funktionen mit Parametern"
date= 2020-11-26T12:50:13+01:00
draft= false
weight = 70
# Table of content (toc) is enabled by default. Set this parameter to true to disable it.
# Note: Toc is always disabled for chapter pages
disableToc = false
# If set, this will be used for the page's menu entry (instead of the `title` attribute)
menuTitle = ""
# The title of the page in menu will be prefixed by this HTML content
pre= ""
# The title of the page in menu will be postfixed by this HTML content
post = ""
# Set the page as a chapter, changing the way it's displayed
chapter= false
# Hide a menu entry by setting this to true
hidden = false
# Display name of this page modifier. If set, it will be displayed in the footer.
LastModifierDisplayName = "Axel Dürkop"
# Email of this page modifier. If set with LastModifierDisplayName, it will be displayed in the footer
LastModifierEmail = "axel.duerkop@tuhh.de"
+++
Beim Aufruf von Funktionen kann wahlweise eine Liste von *Parametern* übergeben werden. Hierbei handelt es sich um Werte beliebigen Datentyps, die beim Aufruf mit Kommata getrennt in die Klammern geschrieben werden:
```python
# Funktionsaufruf
zeichne_kreuz(50, 60)
```
Hier wird eine Funktion mit Namen `zeichne_kreuz()` aufgerufen, der zwei Parameter vom Typ `integer` übergeben werden. In der Funktionsdefinition von `zeichne_kreuz()` wird festgelegt, wie diese Werte verarbeitet werden:
```python
def zeichne_kreuz(x, y):
line(x-20, y, x+20, y)
line(x, y-20, x, y+20)
```
Die übergebenen Parameter werden in den lokalen Variablen `x` und `y` gespeichert.
Für die Arbeit mit Processing sind Funktionen dieser Art sehr hilfreich, da sie die Berechnung der Position von Objekten *relativ zu den Parametern* durchführen.
\ No newline at end of file
+++
title= "[04] Freitag, 27. November 2020"
date= 2020-11-26T12:50:13+01:00
draft= false
# Table of content (toc) is enabled by default. Set this parameter to true to disable it.
# Note: Toc is always disabled for chapter pages
disableToc = false
# If set, this will be used for the page's menu entry (instead of the `title` attribute)
menuTitle = ""
# The title of the page in menu will be prefixed by this HTML content
pre= ""
# The title of the page in menu will be postfixed by this HTML content
post = ""
# Set the page as a chapter, changing the way it's displayed
chapter= false
# Hide a menu entry by setting this to true
hidden = false
# Display name of this page modifier. If set, it will be displayed in the footer.
LastModifierDisplayName = ""
# Email of this page modifier. If set with LastModifierDisplayName, it will be displayed in the footer
LastModifierEmail = ""
+++
## Funktionen
Wenn Sie die vorangegangenen Inhalte und Übungen absolviert haben, verfügen Sie schon über einen recht wirkungsvollen Grundwortschatz in Python. Heute erweitern Sie diesen um ein Konzept, dass als *Funktionen* gefasst und im Zusammenhang mit objektorientierter Programmierung noch einmal anders als *Methode* bezeichnet wird.
Funktionen erweitern die Gestaltungsmöglichkeiten in Processing enorm, weil sich mehrere oder gar viele Codezeilen, die immer wieder zum Einsatz kommen, unter einem Namen *kapseln* lassen. Und damit vermehren sich auch gleichzeitig die kreativen Möglichkeiten.
### Funktionen definieren
{{% notice aufgabe %}}
1. Lesen Sie zunächst [den Abschnitt "Funktionen"](../../python/processingpy/programmiergrundlagen/funktionen) in diesem Skript.
1. Recherchieren Sie die Regeln für Funktionsnamen [in der Python-Dokumentation](https://www.python.org/dev/peps/pep-0008/#function-and-variable-names).
2. Probieren Sie aus, wie Processing reagiert, wenn eine der beiden Funktionen `setup()` und `draw()` fehlen.
3. Definieren Sie eine einfache Funktion. Probieren Sie dann aus, was passiert, wenn der Aufruf einer Funktion vor ihrer Definition erfolgt.
2. Definieren Sie eine Funktion, die in der Mitte der Leinwand einen Stern aus zwei Dreiecken zeichnet. Geben Sie der Funktion einen sprechenden Namen.
3. Realisieren Sie ein eigenes Malwerkzeug mithilfe der Funktion.
1. Posten Sie Ihre Leinwand in Mattermost.
{{% /notice %}}
### Funktionen mit Parametern
Eine einfache Funktion wie die, die Sie in der vorangegangenen Aufgabe definiert haben, ließe sich mit einem Job vergleichen, der ohne jede Hilfsmittel ausgeführt werden kann. Bspw. könnten Sie einer Person zurufen: "Mach das Fenster auf!" oder "oeffne_fenster()". Dazu braucht es keine weiteren Angaben, die Sache ist klar. Sie könnten auch einem Tischler sagen: "baue_stuhl()", und er würde es machen. Allerdings bräuchte er dazu das Holz. Wenn er selber welches hat -- davon würde man bei einem Tischler ausgehen -- besteht seine Funktion darin, mit dem Holz den Stuhl zu bauen. Sie könnten aber auch den gefällten Kirschbaum aus dem Garten mitbringen und sagen: "baue_stuhl(kirschbaum)" und ihm damit das Material übergeben, aus dem der Stuhl gefertigt werden soll.
{{% notice aufgabe %}}
1. Lesen Sie nun [den Abschnitt "Funktionen mit Parametern"](../../python/processingpy/programmiergrundlagen/funktionen_mit_parametern)
1. Definieren Sie eine Funktion `schreibe()`, der Sie einen beliebigen String als ersten und einen Integer (Ganzzahl) als zweiten Parameter übergeben können. Gestalten Sie die Funktion so, dass der übergebene String in der Anzahl des zweiten Parameters ausgegeben wird.
1. Posten Sie Ihre Leinwand in Mattermost.
{{% /notice %}}
### Funktionen mit Rückgabewert
Wenn Sie dem Tischler den Kirschbaum aushändigen, erwarten Sie, dass er einen Stuhl daraus baut. Zu dem Auftrag gehört es, dass Sie den Stuhl nach getaner Arbeit auch ausgehändigt bekommen. Es wäre unrealistisch, wenn alle Tischler die Produkte ihrer Aufträge selbst behielten...
Mit manchen Funktionen ist es ebenso. Sie nützen im Gesamtzusammenhang des Programms erst etwas, wenn sie das Produzierte oder Berechnete aus zurückgeben.
{{% notice aufgabe %}}
1. Lesen Sie [den Abschnitt "Funktionen mit Rückgabewert"](../../python/processingpy/programmiergrundlagen/funktionen-mit-rueckgabe)
1. Definieren Sie eine Funktion `rechne()`, die einen Wert aus Ihrem Hauptprogramm übergeben bekommt, bspw. einen Zählerstand. Denken Sie sich aus, was mit diesem Wert in `rechne()` berechnet wird. Nutzen Sie den Rückgabewert der Funktion für das Zeichnen einer geometrischen Form.
1. Posten Sie Ihre Leinwand in Mattermost.
1. Überlegen Sie: Wofür sind Funktionen mit Rückgabewert gut zu gebrauchen?
{{% /notice %}}
### Funktionen werden zu Methoden
In der objektorientierten Programmierung, die in der nächsten Sitzung folgt, werden Funktionen erneut aufgegriffen. In dem Zusammenhang heißen sie *Methoden* und sind das, was Objekte "können".
## Arbeitsaufträge zum 04. Dezember 2020
{{% notice aufgabe %}}
1. Schreiben Sie ein Programm, in dem (möglichst) alle Konzepte vorkommen, die Sie bisher kennengelernt haben.
{{% /notice %}}
{{% notice aufgabe %}}
1. Malen Sie ein Rechteck auf die Leinwand, von dem Sie behaupten, es sei ein Button, den man klicken kann.
2. Schreiben Sie ein Funktion, die prüft, ob ein Mausklick auf den Button stattgefunden hat. Kapseln Sie diese Prüfung in einer Funktion.
3. Zeigen Sie bei Klick auf den Button das Bild einer Tierart an, die Sie mögen.
{{% /notice %}}
### Abgabe
Geben Sie Ihre Arbeit spätestens am **Donnerstag, 03.12.2020**, [in GitLab](https://www3.tuhh.de/itbh/informatik-202021/veranstaltungsskript/organisation/using-gitlab-erste-schritte/) ab. Sie erhalten Feedback zu Ihrer Arbeit.
#### GitLab - keine Mails
**Wenn Sie zum ersten Mal mit GitLab arbeiten, beachten Sie bitte die Hinweise auf der Seite [Using GitLab](https://www3.tuhh.de/itbh/informatik-202021/veranstaltungsskript/organisation/using-gitlab-erste-schritte/) und folgen Sie den Arbeitsschritten im Video dort.**
## Zusammenfassung der Aufträge
- Fertigstellung der Aufgaben aus der Sitzung
### Abgabetermin
Alles ist bis **Donnerstag, 03.12.2020,** zu erledigen.
\ No newline at end of file
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment