Der Zweck von Funktionen ist, kompliziertere Abläufe, die mehrmals im Programm gebraucht werden in eine Einheit zu verpacken. Damit kann ein Programm übersichtlicher gestaltet werden. Auch kann damit die Korrektheit jeder einzelnen Funktion leichter überprüft werden.
Unterprogramme geben keine Werte zurück, z.B.
def hello(wer): # Definition des Unterprogramms, führt noch nichts aus! print("Hallo "+wer+"!") # Erst hier, wird das Unterprogramm zweimal aufgerufen hello("Python") # Gibt "Hallo Python!" aus (ohne Anführungszeichen) hello("C++")
Funktionen haben einen Rückgabewert, berechnen also etwas:
def quadrieren(x): return x*x print("%d hoch zwei ist %d" % (7, quadrieren(7)))
Beachten Sie, dass das “return” die Funktion sofort beendet.
Alle Variablen in einer Funktion sind nur dort sichtbar und haben nichts mit Variablen zu tun, die auch ausserhalb der Funktion existieren. Alle Werte müssen als Parameter übergeben werden.
# Direkt return a+b wäre natürlich effizienter und würde die Lesbarkeit erhöhen. def summe(a,b): a=a+b return a def produkt(a,b): a = a*b return a def kompliziert(a,b): a = summe(a,b) b = produkt(a,b) return b-a a = 5 b = 7 c = kompliziert(a,b) # Die Werte von a,b sind nicht verändert worden! print("a=%d, b=%d, c=%d" % (a,b,c))
Hinweis: Es gibt die Möglichkeit, in Funktionen auf globale Variablen zuzugreifen. Das sollte aber nach Möglichkeit vermieden werden. Wenn so etwas nötig ist, sollte wohl eine Klasse programmiert werden.
Sie knneen shcier die Tastache, dsas man Txet acuh gut lseen knan, wnen die Bucahtsben innreahlb der Woetrer vrecaustht wreden, voraesgeustzt, der esrte und ltezte Bcutshabe bielbt gliech. Zeil ist es, dieess Progrmam zu shbreicen und die eeiznlnen Aufagben in Fuotkinnen zu vaeprcken.
Für diese Aufgabe sind folgende Dinge zu erledigen:
Programmieren Sie eine Funktion summe(a), die die Summe über die Elemente eines Arrays berechnet. Testen Sie mit dem Array, bestehend aus den Zahlen von 1 bis 100.
Hinweis: Diese Aufgabe gibt auch als Aufgabe mit Klassen, inklusive Ausbaumöglichkeiten.
Ein Tic-Tac-Toe Feld kann mit einem 3×3-Array dargestellt werden. Wir verwenden 0,1,2 als Einträge (leer, Kreis, Kreuz). Hier ein Beispiel:
feld = [[0,1,1], [2,1,2], [0,2,2]]
Wobei feld[2][0] die rechte obere Ecke sein soll. Die Unter-Arrays stellen Spalten dar!
Schreiben Sie eine Funktion, die ein 3×3-Feld als Parameter bekommt, und einen String (inklusive Zeilenumbrüche “\n”) als return-Wert generiert.
Die Ausgabe soll (für obiges Array) wie folgt aussehen:
| X | ---+---+--- O | O | X ---+---+--- O | X | X
Hinweis: Verwenden Sie ein Array, um die möglichen Symbole festzulegen. Der Eintrag im Spielfeld-Array liefert dann den Index vom Symbol.
Hinweis: Diese Aufgabe gibt auch mit einer Klasse und Ausbaumöglichkeiten.
Gegeben ist ein String, der ein Sudoku darstellt. Die Regeln sind wie folgt:
Ihre Aufgabe ist es daraus ein 9×9 - Array mit Zahlen (nicht Strings) von 0-9 zu erzeugen, wobei der Eintrag 0 für ein leeres Feld steht. Die Unter-Arrays stellen Spalten dar!
Beispiel-Eingaben:
sudoku1 = "003020600900305001001806400008102900700000008006708200002609500800203009005010300" sudoku2 = "200080300\n060070084\n030500209\n000105408\n\n000000000\n402706000\n301007040\n720040060\n004010003" sudoku3 = "......9.7\r\n...42.18.\r\n...7.5.26\r\n1..9.4...\r\n.5.....4.\r\n...5.7..9\r\n92.1.8...\r\n.34.59...\r\n5.7......"
Ausgaben:
[[0, 9, 0, 0, 7, 0, 0, 8, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [3, 0, 1, 8, 0, 6, 2, 0, 5], [0, 3, 8, 1, 0, 7, 6, 2, 0], [2, 0, 0, 0, 0, 0, 0, 0, 1], [0, 5, 6, 2, 0, 8, 9, 3, 0], [6, 0, 4, 9, 0, 2, 5, 0, 3], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 8, 0, 0, 9, 0]] [[2, 0, 0, 0, 0, 4, 3, 7, 0], [0, 6, 3, 0, 0, 0, 0, 2, 0], [0, 0, 0, 0, 0, 2, 1, 0, 4], [0, 0, 5, 1, 0, 7, 0, 0, 0], [8, 7, 0, 0, 0, 0, 0, 4, 1], [0, 0, 0, 5, 0, 6, 7, 0, 0], [3, 0, 2, 4, 0, 0, 0, 0, 0], [0, 8, 0, 0, 0, 0, 4, 6, 0], [0, 4, 9, 8, 0, 0, 0, 0, 3]] [[0, 0, 0, 1, 0, 0, 9, 0, 5], [0, 0, 0, 0, 5, 0, 2, 3, 0], [0, 0, 0, 0, 0, 0, 0, 4, 7], [0, 4, 7, 9, 0, 5, 1, 0, 0], [0, 2, 0, 0, 0, 0, 0, 5, 0], [0, 0, 5, 4, 0, 7, 8, 9, 0], [9, 1, 0, 0, 0, 0, 0, 0, 0], [0, 8, 2, 0, 4, 0, 0, 0, 0], [7, 0, 6, 0, 0, 9, 0, 0, 0]]
Gegeben ist ein 9×9-Array (siehe vorhergenden Aufgabe), wobei die Unter-Arrays Spalten sind. Die Eintäge sind 0 bis 9 (0 heisst leer). Schreiben Sie eine Funktion, die ein schönes Sudoku in ASCII-Art als String produziert:
#===========#===========#===========# # | | 3 # | 2 | # 6 | | # #---+---+---#---+---+---#---+---+---# # 9 | | # 3 | | 5 # | | 1 # #---+---+---#---+---+---#---+---+---# # | | 1 # 8 | | 6 # 4 | | # #===========#===========#===========# # | | 8 # 1 | | 2 # 9 | | # #---+---+---#---+---+---#---+---+---# # 7 | | # | | # | | 8 # #---+---+---#---+---+---#---+---+---# # | | 6 # 7 | | 8 # 2 | | # #===========#===========#===========# # | | 2 # 6 | | 9 # 5 | | # #---+---+---#---+---+---#---+---+---# # 8 | | # 2 | | 3 # | | 9 # #---+---+---#---+---+---#---+---+---# # | | 5 # | 1 | # 3 | | # #===========#===========#===========#
Schreiben Sie eine Funktion permuationen(n), die alle Permutationen (Vertauschungen) der Zahlen 0 bis $n-1$ in einem Array generiert. Z.B. ist die Ausgabe von permutationen(4) folgende:
[[0, 1, 2, 3], [0, 1, 3, 2], [0, 2, 1, 3], [0, 2, 3, 1], [0, 3, 1, 2], [0, 3, 2, 1], [1, 0, 2, 3], [1, 0, 3, 2], [1, 2, 0, 3], [1, 2, 3, 0], [1, 3, 0, 2], [1, 3, 2, 0], [2, 0, 1, 3], [2, 0, 3, 1], [2, 1, 0, 3], [2, 1, 3, 0], [2, 3, 0, 1], [2, 3, 1, 0], [3, 0, 1, 2], [3, 0, 2, 1], [3, 1, 0, 2], [3, 1, 2, 0], [3, 2, 0, 1], [3, 2, 1, 0]]