Funktionen

MERKE
Eine Funktion ist im Prinzip nicht anderes als “mehrere Einzelanweisungen, die du zu einem eigenen Befehl zusammenfasst”. Den Befehl kannst du dann immer wieder verwenden. Eine Funktion hat folgende Form:

def funktionsname(parameter):
  befehle
  return ergebnis

Beachte:

• Es gehöhrt nur der eingerückte Block zur Funktion.
• Die Funktion erhält als Eingabe einen Parameter. Mit dem kannst du innerhalb der Funktion arbeiten wie mit jeder anderen Variable auch.
• Mit dem Wort return wird definiert, welches Ergebnis die Funktion “ausspucken” soll. Ein return beendet die Funktion.

MERKE
Eine Funktion wird erst ausgeführt, wenn sie aufgerufen wird! Ein Funktionsaufruf hat die Form

variable = funktionsname(wert)

Dabei wird für den Parameter ein konkreter Wert eingesetzt. Es wird also die Funktion auf einen bestimmten Wert angewandt.

Beispiel: a = f(5) Lies das so: “a ist f von 5” oder anders gesagt “Speichere > in a den Wert, der bei f rauskommt, wenn man 5 einsetzt.”

def foo(a, b):
  if a:
    return b
  return b + 5

def foo(var)
  print("Hello " + var)

bar = foo("John")

Aufgabe 1
Versuch eine Funktion zu schreiben, die den Brennwert von Lebensmitteln von Kilo-Joule in Kilo-Kalorien umrechnet. Gib dieser den Namen convert_kJ_to_kcal. Das Verhältnis von Kilo-Joule zu Kilo-Kalorien lautet wie folgt:

$$ 4,187 kJ = 1 kcal $$

Aufgabe 2
Schreibe eine Funktion hours_to_mins, die Stunden in Minuten umrechnet. Rufe die Funktion dann zwei, drei mal mit verschiedenen Werten auf! Dabei soll jeweils so was ausgegeben werden wie z.B. "22 Stunden haben 1320 Minuten".

Aufgabe 3
Lust auf eine Runde Billard? Schreibe eine Funktion ballnumber_to_color, die die Nummer einer Billardkugel übergeben bekommt und dann die Farbe der Kugel (siehe Bild unten) zurückgibt. Wir beschränken uns jetzt mal auf die Kugeln 1-3.

Tipp: Du brauchst ein if-Statement und mehrere return-Statements.

Teste deine Funktion mit den Aufrufen

print("Die Farbe von Kugel 1 ist " + ballnumber_to_color(1))
print("Die Farbe von Kugel 2 ist " + ballnumber_to_color(2))
print("Die Farbe von Kugel 3 ist " + ballnumber_to_color(3))

Funktionen mit mehreren Parametern

MERKE
Eine Funktion kann auch mehr als einen Eingabewert haben. Man kann daher für eine Funktion beliebig viele Parameter > definieren, einfach so:

def funktionsname(parameter1, parameter2):
  ...

Achtung:

1. Es muss dann bei jedem Funktionsaufruf für jeden Parameter ein Wert übergeben werden.
2. Der erste Wert wird für den ersten Parameter eingesetzt, der zweite für den zweiten usw.
3. Werte für verschiedene Parameter können unterschiedliche Datentypen haben.

Beispiel: a = f(5, 42) Lies das so: “a ist f von 5 und 42” oder anders gesagt “Speichere in a den Wert, der bei f rauskommt, wenn man 5 für den ersten Parameter und 42 für den zweiten Parameter einsetzt.”

Aufgabe 4
Füge der Funktion convertkJ_to_kcal einen Parametershould_round hinzu, der entweder True oder False sein kann und angibt, ob das Ergebnis gerundet werden soll. Der Code innerhalb der Funktion ist schon angepasst. Du musst nur den _Kopf der Funktion, also ihre erste Zeile und den Funktionsaufruf ergänzen.

Tipp: Eine Zahl runden kannst du mit der Funktion round(zu_rundende_zahl).

Übung: Maximum Skills

Aufgabe 5
Im letzten Kapitel hast du schon die vordefinierte Funktion max kennengelernt, die das Maximum von zwei Zahlen bestimmt, zum Beipsiel a = max(3,4). Schreibe jetzt eine eigene Funktion my_max, die genau das gleiche tut. So etwas Ähnliches hast du schon im vorherigen Kapitel gemacht, diesmal geben wir allerdings keine Hinweistexte mehr aus. Die Funktion soll einfach eine Zahl zurückgeben. Teste die Funktion, indem du sie mit den Werten 1, 10, 10, 1 und 5, 5 aufrufst.

Übung: Maximum Skills mit input

Aufgabe 6 \

Ändere deine Code von gerade eben so, dass die Funktion nur einmal aufgerufen wird und bei diesem Funktionsaufruf keine festen Werte verwendet, sondern die zwei Zahlen mittels input() über das Terminal eingegeben werden. Achte auf die Datentypen!

Funktionen ohne Parameter und return

MERKE
Nicht jede Funktion liefert zwangsläufig ein Ergebnis. Manche zeigen z.B. auch nur Dinge am Bildschirm an und berechnen nichts. Entsprechend gibt es auch Funktionen ohne return-Statement.

Beispiel:

def greet(name):
  print("Halli hallo, " + name)

Würde man nun trotzdem versuchen, das Ergebnis dieser Funktion weiterzuverarbeiten, erhielte man … nichts, oder in Python ausgedrückt: None

Entsprechend macht so etwas wie ergebnis = greet("Laura") hier keinen Sinn. Die Funktion liefert ja kein Ergebnis!

MERKE
Es braucht auch nicht jede Funktion eine Eingabe. Manche kommen ohne Parameter aus. Die Klammern hinter dem Funktionsnamen bleiben dann sowohl bei der Definition der Funktion als auch bei Aufrufen einfach leer.

Beispiel

def greet_all():
  print("Hallo, Anna")
  print("Hallo, Ben")
  print("Hallo, Caro")
  print("Hallo, David")

Vielleicht fragst du dich, wofür so eine Funktion ohne Ein- und Rückgabewert gut sein soll. Schließlich hätte man die Befehle oben auch einfach “ganz normal” ins Programm schreiben können.

Der große Vorteil davon: Man spart Code! Anstatt die einzelnen Befehle immer wieder zu schreiben, kann man als “Abkürzung” einfach die Funktion aufrufen. Außerdem kann man ein Programm übersichtlich aufteilen. (Modularisierung)

Aufgabe 7
So, jetzt aber zu deiner Aufgabe: Schreibe eine Funktion get_movies ohne Parameter und Rückgabewert, die einfach nur 4-5 Namen von Kinofilmen (Nimm einfach die, die dir gerade einfallen.) jeweils mit einem print-Statement anzeigt.

Lokale vs. Globale Variablen

MERKE Eine Funktion ist eine geschlossen Einheit (Blackbox) mit Eingabe (Parameter) und Rückgabewert (return-Wert). In diese kann man “von außen”, d.h. mit Befehlen außerhalb der Funktion nicht hineinschauen. Insbesondere kann man nicht auf Werte von Parametern oder Variablen, die innerhalb der Funktion angelegt werden, zugreifen:.

def funktion(parameter):
  ...
funktion(…)
print(parameter) # das hier geht nicht! Kein Zugriff von
außen auf Parameter!

Die Variablen/Parameter innerhalb der Funktion gibt es also nur an einem bestimmten Ort (nämlich in der Funktion.) Man spricht daher von Lokalen Variablen.

MERKE
Anders herum funktioniert das aber schon: Eine Funktion kann “aus sich heraus” in das “äußere” Programm schauen und Variablen sowie andere Funktionen von dort benutzen:

spam = "Katze"
def funktion():
  print(spam) # hier innen kann man auf spam außen
zugreifen

funktion(…)
print(spam) # und hier sowieso

Man spricht von Globalen Variablen

Aufgabe 8
Verändere den Code so, dass greeting keine globale Variable mehr ist, sondern ein weiterer Parameter (und damit eine lokale Variable) der Funktion greet. Denk dabei dran: Erst beim Funktionsaufruf werden für alle Parameter (“Platzhalter”) konkrete Werte übergeben.

greeting = "Hello "

def greet(name):
  print(greeting + name)

greet("Hans")

Textbasiertes Spiel

Du machst das richtig gut! Mal sehen, ob in dir ein kleiner Nerd steckt…

Es ist Zeit für ein größeres Projekt:

Textadventures

Textadventure ist ein Genre von Computerspielen, das seit den 70ern populär ist. In einem Textadventure sieht der Spieler eine Textbeschreibung der Spielwelt und seiner aktuellen Situation und benutzt dann Texteingaben, um Aktionen durchzuführen, Rätsel zu lösen und im Spiel zu überleben.

Start und Ziel des Spiels

Implementiere ein Textadventure für folgendes Szenario: Der Spieler startet in einem dunklen Wald und soll die Prinzessin aus den Klauen eines Drachen retten, der sie in einer Burg festhält. Dazu braucht der Spieler das Schwert Excalibur (Das bekommt man von der Herrin am See.) und eine Rüstung. Es gibt also drei verschiedene Schauplätze. Welche Aktionen der Spieler am jeweiligen Ort zur Auswahl hat, hängt von der aktuellen Situation ab und davon, ob er das Schwert Excalibur bei sich hat oder nicht.

Spielweise

In Textadventures navigiert man mit dem gehe Befehl. Zum Beispiel:

gehe osten

Man kann auch mit Gegenständen interagieren: Um beispielsweise den Drachen zu töten, tippt man:

toete drachen

Solche “Befehle”, die der Nutzer dann zur Verfügung hat, legst natürlich du bei Entwicklung des Spiels im Programmcode selbst fest.

Beispiel:

Du bist in einem dunklen Wald. Ein Weg führt nach Westen und
Osten.
> gehe osten
Du stehst vor einer mächtigen Burg. Aus einem Fenster im
höchsten Turm der Burg winkt eine Prinzessin verzweifelt zu dir.
Ein Drache bewacht den Eingang der Burg.
> toete drache
Ohne Schwert hast du keine Chance gegen den Drachen. Er frisst
Dich auf, und Du bist tot.

Aufgabe 9
Implementiere eine Funktion für jeden Ort des Spiels (Wald, Burg, See). Um den Spieler an einen Ort “gehen” zu lassen, wird dann einfach die entsprechende Funktion aufgerufen.

Jede “Ortsfunktion” soll

• den Parameter has_sword bekommen, der anzeigt, ob der Nutzer beim erreichen des Ortes ein Schwert dabei hat.
• eine Beschreibung des Orts ausgeben.
• eine Aktion basierend auf der Eingabe des Spielers durchführen. Z.B. if command == "gehe osten": castle(...)
• wenn der Benutzer einen ungültigen Befehl eingibt mit Das verstehe ich nicht. antworten.

Wie wechsle ich den Ort?

Indem innerhalb der bisherigen Funktion die Funktion des nächsten Ortes aufgerufen wird.

Z.B. innerhalb der Funktion forest wird castle aufgerufen

Wie erhält/verliert der Nutzer das Schwert?

Indem beim nächsten Ortswechsel ein anderer Wert für has_sword übergeben wird:

1. Variante: Nutzer verliert das Schwert am aktuellen Ort. Dann nächster Ortswechsel z.B. castle(False)
2. Variante: Nutzer bekommt das Schwert am aktuellen Ort. Dann nächster Ortswechsel z.B. castle(True)
3. Variante: Es passiert nichts mit dem Schwert am aktuellen Ort. Dann nächster Ortswechsel z.B. castle(has_sword) D.h. die Variable wird unverändert weitergegeben.

Wie binde ich das Schwert ins Spiel ein?

Du kannst mit if prüfen, ob der Nutzer gerade ein Schwert hat. Der Rest ist deiner Kreativität überlassen. Beispiel: Trifft die Figur ohne Schwert auf den Drachen, dann stirbt sie und das Spiel ist aus.

Zusatzaufgabe

Aufgabe 10
Du bist schon fertig? Dann überleg dir noch ein paar zusätzliche Features für dein Textadventure.

Vorschlage 1: Beispielsweise kannst du dem Spieler eine Art Spielmenü anbieten, wenn er das Spiel starten, in dem er den Schwierigkeitsgrad des Spiels auswählen kann.

Vorschlag 2: Du kannst dem Spieler auch noch einen Prompt bauen in dem er in jedem Schritt auswählen kann was er als nächstes machen könnte:

Designvorschlag

Was möchtest du als nächstes tun?

[1] nach Osten gehen
[2] nach Westen gehe
[3] Schwert aufgeben

>

Der Spieler kann dann direkt hinter dem > die Zahl der aktion eingeben.