< for-Schleife Inhalt Teilungsrest >

Unterprogramme

Unterprogramme sind Befehlsfolgen, welche einen Namen bekommen. Mit diesem Namen können Sie überall im Programm aufgerufen werden. Somit vermeidet man mit Unterprogrammen das Kopieren von Code und erhöht die Lesbarkeit.

Ein Unterprogramm ohne Parameter beginnt mit def gefolt von einem Namen und wird mit runden Klammern und einem Doppelpunkt. Also:
def sprechenderName( ):
Eingerückt folgen dann die Befehle des Unterprogramms.

Ein einfaches Unterprogramm

Hier wird das Unterprogramm sagHallo() definiert und im Programm 2 mal aufgerufen:

def sagHallo():
    print("*********");
    print("* Hallo *");
    print("*********");
    
sagHallo()
print()
sagHallo()

Die Ausgabe des Programms:

*********
* Hallo *
*********

*********
* Hallo *
*********

Parameterübergabe

Einem Unterprogramm können Werte beim Aufruf übergeben werden. Dies kennen wir bereits von print, range, input.
Bei der Definition des Unterprogramms gibt man die Werte zwischen den runden Klammern nach dem Namen an.

def add(a,b):
    x=a+b
    print(x)

Beim Aufruf des Programms muss die Anzahl der Werte exakt mit denen des Unterprogramms übereinstimmen.

add(2,3) # Alles ok 2 Werte
add(2) # Fehler TypeError: add() missing 1 required positional argument: 'b'
add(1,2,3) # Fehler TypeError: add() takes 2 positional arguments but 3 were given

Rückgabe

Ein Unterprogramm kann einen Wert zurückliefern. Beim Aufruf des Unterprogramms kann dieser z.B. einer Variablen zugewiesen werden:
x = berechne(2,1)
Hier würde x das Ergebnis, welches berechne(2,1) zurückgibt speichern.

Im Unterprogramm muss das Ergebnis mit dem Schlüsselwort return zurückgegeben werden. Ein return beendet das Unterprogramm sofort.

def min(a,b):
    if a<b:
        return a
    else:
        return b

Dieses Unterprogramm min würde im Code wie folgt verwendet:

x = min(3,9)
y = min(2,1)
print(x,y)

Hier wird 3, 1 ausgegeben.

Mehrere Werte zurückgeben

Manchmal braucht man mehrere Rückgabewerte, z.B. Name und Alter, Anzahl und Bezeichnung, x und y.
Dies bietet Python mit Tupeln: Man gibt mehrere Werte mit Kommata getrennt an und packt diese in runde Klammern.
Beim Aufruf

def getitem(i):
    if i==0:
        return (3, 'Toasts')
    else:
        return (2, 'Burger')

Beim Aufruf sieht das so aus:

(anzahl,name) = getitem(0)
print("Von",name,"haben wir",anzahl,"Stück")

Ausgabe: Von Toasts haben wir 3 Stück

Auslagern von Unterprogrammen

Für die, die Interesse haben:

Aufgaben

Schreiben Sie ein Unterprogramm zahlen(), welches die Zahlen von 1 bis 10 ausgibt.
```
def zahlen():
    for i in range(1,11):
        print(i)
```
Schreiben Sie ein Unterprogramm dreiecksFläche, welches die Länge der Grundseite g und die zugehörige Höhe h übergeben bekommt.
Das Unterprogramm gibt die Fläche A=0.5*g*h zurück.
Testen Sie Ihr Unterprogramm indem Sie es aufrufen.
```
def dreiecksFläche(g,h):
    return 0.5*g*h
    
f0 = dreiecksFläche(3,1)
print(f0)
print(dreiecksFläche(7,4))
```
```
>>> %Run dreieck.py
1.5
14.0
```
Schreiben Sie ein Unterprogramm liesint(s), welches eine Eingabe vom Benutzer einliest und diese als int zurückgibt.
Der Parameter s soll bei der Eingabe angezeigt werden.
```
def liesint(s):
    e = input(s)
    return int(e)
```
Anwendungsmöglichkeit:
```
g = liesint("Grundseite: ")
h = liesint("Höhe: ")
f0 = dreiecksFläche(g,h)
print(f0)
```
Schreiben Sie ein Unterprogramm ascii(s). Der Parameter s ist ein String und es soll der ASCII (Unicode) von jedem Zeichen ausgegeben werden.
Das Unterprogramm muss also mit einer Schleife über jeden Buchstaben gehen und mit ord(char) bekommen Sie den ASCII bzw. Unicode des Buchstabens char.
```
def ascii(s):
    for c in s:
        print(ord(c))
```
Anwendungsmöglichkeit:
```
text = "Hallo!"
ascii(text)
```
Ausgabe:
```
72
97
108
108
111
33
```
Mit ord(c) bekommt man den ASCII-Code eines Buchstabens und
mit chr(a) bekommt man den Buchstaben für den ASCII-Code.
Schreiben Sie ein Unterprogramm encrypt(s, shift), welches
1. Für jedes Zeichen den ASCII-Code holt und in der Variable a speichert
2. Jetzt wird zu a die Zahl in shift addiert
3. Nun wird mit b=chr(a) der veränderte ASCII-Code wieder zu einem Buchstabe
4. Geben Sie b ohne Zeilenumbruch aus.
5. Am Ende des Unterprogramms soll ein Zeilenumbruch erfolgen.
Nun kann mit encrypt("geheim", 4) der Text verschlüsselt ausgegeben werden.
Wenn Sie diesen Text kopieren und mit encrypt("kilimq", -4) entschlüsseln, dann erhalten sie wieder "geheim".
```
def encrypt(s, shift):
    for c in s:
        a = ord(c)
        a = a+shift
        b = chr(a)
        print(b, end="")
    print()
```