Programmieren für Ingenieure

Wenn ein Teil deines Codes eine bestimmte Aufgabe erfüllt, die du häufiger in deinem Programm verwendest, kannst du diesen Code Abschnitt ein eine Funktion schreiben.
Eine neue Funktion definierst du mit dem Schlüsselwort „def“.
Danach kannst du der Funktion einen beliebigen Namen geben.
Für die Benennung von Funktionen folge ich der Pascal Case Konvention, die wir bereits in der Variablen Lektion kennengelernt haben (zum Beispiel: MeinVariablenName).
Auch dabei gibt es natürlich verschiedene Meinungen und Vorlieben, und du solltest vor allem darauf achten, dass du innerhalb deiner Programme nicht wechselst, sondern eine einheitliche Konvention einhältst.
Nach dem Namen schließt du den Definitionsteil der Funktion mit „():“ ab.
Den dazugehörigen Code schreibst du wie gewohnt mit Leerzeichen oder Tabs eingerückt in die darauffolgenden Zeilen.
Wenn du eine Funktion ausführen möchtest, dann gibst du einfach nur ihren Namen gefolgt von „()“ ein.

def NameDerFunktion():
    print(„Code meiner Funktion wird ausgeführt.“)

NameDerFunktion ()

### ERGEBNIS / AUSGABE ###
Code der Funktion wird ausgeführt.

Wenn dir das Verdächtig nach ähnlich zu der print() Funktion aussieht, die du schon häufiger genutzt hast, dann hast du ein sehr gutes Auge =)
Denn auch jedes Mal wenn wir print(„Mein Text den ich ausgeben möchte.“) nutzen, rufen wir eine bereits geschriebene und von Python bereitgestellte Funktion auf.
Ein auffälliger Unterschied ist, dass wir nach dem Funktionsnamen „print“ noch etwas in die Klammern schreiben können.
Das ist ein sogenannter Parameter.
Ein Parameter ist eine Variable, die du einer Funktion zur Ausführung mitgeben kannst.
Der Wert dieser Variable kann dann in der Funktion weiterverwendet werden.
Im Fall der print() Funktion kannst du ihr zum Beispiel eine String Variable mitgeben, deren Text sie dann in das Konsolenfenster schreibt.
Wenn du möchtest, dass deine Funktion eine Variable als Parameter entgegennehmen kann, kannst du den Namen der Variable in die Klammern der Funktionsdefinition schreiben.
Beim Funktionsaufruf musst du dann die Variable die du als Parameter übergeben möchtest innerhalb der Klammern angeben.

def SagHallo(name):
    print(f“Hallo {name} =)“)

SagHallo(„Mia“)
SagHallo(„Peter“)

### ERGEBNIS / AUSGABE ###
Hallo Mia =)
Hallo Peter =)

Deine Funktion kann auch mehrere Parameter entgegennehmen.
Die neuen Parameter kannst du sowohl bei der Definition als auch beim Aufruf der Funktion Komma separiert in den Klammern ergänzen.

def Addieren(zahl1, zahl2):
    print(zahl1 + zahl2)

Addieren(2, 3)

### ERGEBNIS / AUSGABE ###
5

Wenn du möchtest, dass deine Funktion nicht nur Code ausführt, sondern auch ein Ergebnis zurück liefert, kannst du das „return“ Schlüsselwort nutzen.
Nach „return“ kannst du den Namen einer Variable angeben, deren Wert als Rückgabewert zum Funktionsaufruf zurück gegeben wird.
Damit der Rückgabewert nicht einfach verloren geht, kannst du ihn in einer Variable speichern.

def Multiplizieren(zahl1, zahl2):
    ergebnis = zahl1 * zahl2
    return ergebnis

ergebnis = Multiplizieren(2, 3)
print(ergebnis)

### ERGEBNIS / AUSGABE ###
6

Und auch hier hast du die Möglichkeit gleich mehrere Rückgabewerte zurück zu geben indem du sie mit Komma separiert nach dem „return“ Schlüsselwort auflistest.
Beim Speichern der Rückgabewerte in Variablen solltest du darauf achten, dass du auch genauso viele Variablen wie Rückgabewerte angibst.

def RechteckFlaecheUndUmfang(laenge, breite):
„““DocStrings werden dazu genutzt die Funktionsweise einer Funktion zu beschreiben.
Diese zum Beispiel nimmt die Länge und Breite eines Rechtecks als Eingangsparameter
und gibt die Fläche und Umfang des Rechtecks als Rückgabewerte zurück.“““
    flaeche = laenge * breite
    umfang = 2 * (laenge + breite)
    return flaeche, umfang

laenge = 2
breite = 3
flaeche, umfang = RechteckFlaecheUndUmfang(laenge, breite)
print(f“Länge = {laenge}; Breite = {breite}; Fläche = {flaeche}; Umfang = {umfang}“)

### ERGEBNIS / AUSGABE ###
Länge = 2; Breite = 3; Fläche = 6; Umfang = 10

Sobald deine Programme etwas größer werden, empfehle ich dir, deine Funktionen gut zu dokumentieren.
Dies wird anderen Entwicklern und auch die selbst nach einigen Monaten mit anderen Projekten enorm helfen zu verstehen, was deine Funktionen genau machen.
Eine gute Methode zum Dokumentieren von Funktionen sind sogenannte Docstrings.
Diese kannst du direkt nach der Definition in der ersten Zeile der Funktion mit drei Anführungszeichen “““ am Anfang und Ende schreiben.
Viele IDEs werden dir auch die Text des Docstrings anzeigen, wenn du an einer anderen Stelle im Code mit der Maus über den Namen der Funktion hoverst.

Wenn du Fragen hast oder Probleme in dieser Lektion hattest, dann zögere bitte nicht bei Google oder mir nachzufragen.
Wenn du es geschafft hast deine eigenen Funktionen zu definieren, ihnen Parameter zu übergeben und ihre Rückgabewerte zu speichern, hast du eine weitere enorm wichtige Grundlage gelernt.
Herzlichen Glückwunsch zu diesem großen Schritt und ich freue mich schon sehr darauf, dich in der nächsten Lektion wiederzusehen =)