Die Webseiten der Fachschaft Informatik am ERG Saalfeld

Subroutinen (Prozeduren und Funktionen)

Wenn in einem Programm bestimmte Programmteile mehrfach vorkommen ist meistens sinnvoll, diese Programmteile in ein Unterprogramm auszulagern und dieses Unterprogramm aufzurufen. Dadurch wird das Programm kürzer und damit (in den meisten Fällen) auch besser lesbar. Bei Änderungen / Anpassungen muss nur an einer Stelle geändert werden. Es gibt aber auch weitere Gründe für die Nutzung von Subroutinen (Prozeduren und Funktionen). Im Beispiel mit dem Primzahlsieb werden Subroutinen nur zur besseren Strukturierung eingesetzt. Ein weiterer Grund könnte sein, dass für die Umsetzung einer Aufgabe Funktionen gebraucht werden, die Python von Haus aus nicht bereitstellt. Dann stellt diese Subroutine einen Baustein für das Programm dar.

Prozeduren

Unterprogramme, die kein Ergebnis zurückliefern, nennt man Prozeduren.
Anmerkung: Prozeduren haben üblicherweise die Aufgabe, etwas auszugeben. Sie können aber auch globale Variable ändern.

Beispiel (Programm "Einmaleins")

Der Quelltext und die Ausgabe dazu sahen so aus:

for x in range(1,11):
  for y in range(1,11):
      z = x*y
      print(z, " ", end =" ")
  print("\n", end ="")

Ein möglicher Ansatz um die Ausgabe schöner zu formatieren geht sicherlich über die Nutzung des Tabulators. Allerdings wird dann die Zeile voll ausgefüllt. Es bleibt dann keine Möglichkeit, eine Tabellenbeschriftung (für die Zeile) zu ergänzen. Es soll deshalb hier ein Unterprogramm geschrieben werden, was die Zahl z immer als dreistellige Zahl ausgibt. Das bedeutet, ist z einstellig (also kleiner als 10), dann werden 2 Leerzeichen davor gesetzt. Ist z zweistellig (also kleiner als 100), dann wird ein Leerzeichen davor gesetzt. Andernfalls wird z genommen wie es ist.

Das Unterprogramm (die Subroutine) sieht dazu so aus:

def dreistellig():
  if z < 10:
      hilf = '  '+(str(z))
      print(hilf, end = "")
  elif z < 100:
      hilf = ' '+(str(z))
      print(hilf, end = "")
  else:
      hilf = str(z)
      print(hilf, end = "")

Wichtig: An die Subroutine greift direkt auf die globale Varable "z" zu. Die (lokale) Variable "hilf" im Unterprogramm gilt auch nur in dieser Subroutine. Sollte es im Hauptprogramm auch eine (globale!) Variable hilf geben, dann sind diese beiden Variablen völlig unabhängig voneinander und stören sich gegenseitig nicht. Bei der Programmausführung innerhalb der Subroutine ist dann nur die lokale Variable sichtbar. Eine globale Hilfsvariable ist dann nicht sichtbar.

Jetzt muss noch das (Haupt-)Programm für dieses Unterprogramm angepasst werden. Die Subroutine dreistellig() erwartet die Zahl in der globalen Variablen z. Also muss das Hauptprogramm diese Variable z bereitstellen. Außerdem gibt die Subroutine den formatierten Zahlenwert schon aus. Im Hauptprogramm werden also nur noch die Leerzeichen und der Zeilenumbruch erledigt. Damit ergibt sich unser Programm nun so:

def dreistellig():
  if z < 10:
      hilf = '  '+(str(z))
      print(hilf, end = "")
  elif z < 100:
      hilf = ' '+(str(z))
      print(hilf, end = "")
  else:
      hilf = str(z)
      print(hilf, end = "")


for x in range(1,11):
  for y in range(1,11):
      z = x*y
      dreistellig(), print("", end = "  ")
  print("\n", end = "")

Die Ausgabe sieht nun so aus:

Funktionen

Unterprogramme, die ein Ergebnis zurückliefern, nennt man Funktionen.
Anmerkung: Dieses Ergebnis kann auch eine Liste sein und in der Liste sind dann mehrere Elemente.

Beispiel

Es soll im Folgenden mit 2 Würfeln gespielt werden, wie z.B. beim bekannten Spiel Lügenmax. Allerdings soll es hier nur darum gehen solange zu würfeln, bis zweimal die gleiche Zahl gewürfelt wird. Die Würfe sollen zeilenweise ausgegeben werden.

Ein Wurf besteht also aus 2 Würfeln. Jeder einzelne Würfel wird so implementiert:

from random import randint
wuerfel1 = randint(1,6)
wuerfel2 = randint(1,6)

Den Wurf implementieren wir als Liste aus wuerfel1 und wuerfel2. Wir erhalten damit:

from random import randint
wuerfel1 = randint(1,6)
wuerfel2 = randint(1,6)

wurf = [wuerfel1,wuerfel2]

Wir schreiben das jetzt als Subroutinen. Alles was zurückgeben werden soll, wird hinter 'return' angegeben.

from random import randint

def wurf():
    wuerfel1 = randint(1,6)
    wuerfel2 = randint(1,6)

    wurf = [wuerfel1,wuerfel2]
    return wurf

Das Hauptprogramm sieht so aus:

while True:
    (w1,w2) = wurf()
    print(w1," ",w2)
    if w1 == w2:
        break

Das gesamte Programm sieht dann so aus:

from random import randint

def wurf():
    wuerfel1 = randint(1,6)
    wuerfel2 = randint(1,6)

    wurf = [wuerfel1,wuerfel2]
    return wurf

while True:
    (w1,w2) = wurf()
    print(w1," ",w2)
    if w1 == w2:
        break

Das Programm brachte bei mir folgende Ausgabe:

Aufgaben

Bringen Sie die beiden Programme einmaleins.py und wuerfeln.py zum Laufen.
Kommentieren Sie beide Programme (jede Zeile bzw. jeden Block).
Schreiben Sie im Programm einmaleins.py die Prozedur dreistellig zu einer Funktion um. Passen Sie das Hauptprogramm entsprechend an.
Geben Sie für alle Variablen im Programm wuerfeln.py an, ob diese globale oder lokale Variable sind.
Am Ende des Programms wuerfeln.py (also nach der Zeile mit 'while') soll die Variable wuerfel1 ausgegeben werden. Was erwarten Sie? Überprüfen Sie das!
Ergänzen Sie beide Programme um eine Überschrift (Unterstrichen, mit Leerzeile, eingerückt). Schreiben und verwenden Sie dazu eine Prozedur ueberschrift() .

zurück