Funktionsdefinitionen in Python 

Funktionsdefinitionen

Mit einer Funktionsdefinition  kann einem Ausdruck ein Name gegeben werden.

Wir erinnern an lambda-Bindungen (also Bindungen von lamda-Funktionen an gewöhnliche Bezeichner).

main.py

LKW = lambda: print( "Lastkraftwagen" )
LKW()

Protokoll

Lastkraftwagen

Eine alternative Schreibweise ist eine def-Definition (def-Funktionsdefinition).

main.py

def LKW(): print( "Lastkraftwagen" )
LKW()

Protokoll

Lastkraftwagen

Bei der Ausführung der Definitionsanweisung »def LKW(): print( "Lastkraftwagen" )« wird (wie bei der zuvor gezeigten Bindung an eine lambda-Funktion) die innere Anweisung »print( "Lastkraftwagen" )« nicht  ausgeführt, sondern nur unter dem Namen »LKW« abgelegt.

Mehrzeilige Definitionen

Es ist auch erlaubt, nach dem Doppelpunkt eine neue Zeile zu beginnen. Jedoch muß die zweite Zeile der Funktionsdefinition dann mehr Leerzeichen am Zeilenanfang haben als die erste Zeile der Funktionsdefinition.

main.py

def LKW(): 
    print( "Lastkraftwagen" )
LKW()

Protokoll

Lastkraftwagen

Suiten

Eine Suite  ist eine Folge von Anweisungen. Normalerweise wird dabei eine Anweisung pro Zeile geschrieben.

Beispiel einer Suite

print( "Lastkraftwagen" )
print( "Flugzeug" )

Das Wort „Suite“

Die deutsche Aussprache lautet /ˈsviːt/ (oder /ˈsviːtə/ oder /ˈswiːt/), die französische /ˈsɥit/, die englische /ˈswiːt/ (wie die von “sweet ”).

Das Wort bezeichnet außerhalb von Python  im Deutschen eine musikalische Komposition, die eine Folge von Sätzen ist, oder eine Zimmerflucht.

Es stammt vom lateinischen Verb "sequor" = „Ich folge“ ab.

Einrückung

Einrücken bedeutet: Die Zeile mit mehr Leerzeichen zu beginnen als die direkt davorstehende Zeile.

Üblich sind hier vier  Leerzeichen mehr.

Auch PEP 8 empfiehlt eine Einrückung mit vier  Leerzeichen.

ℛ Stilregel Empfohlen wird eine Einrückung mit vier  Leerzeichen.

Alle Zeilen der Suite einer Funktionsdefinition müssen gleich weit nach rechts eingerückt  sein.

Die Zeilen der Suite einer Funktionsdefinition müssen weiter nach rechts eingerückt  sein als die erste Zeile derselben Funktionsdefinition.

Funktionsdefinition

def LKW():
    print( "Lastkraftwagen" )
    print( "Personenkraftwagen" )
    print( "Kraftomnibus" )

Die Zeilen der Suite einer def-Funktionsdefinition müssen im Vergleich zur ersten Zeile der def-Funktionsdefinition eingerückt  sein (alle gleich weit).

Aufbau einer Funktionsdefinition

Das Schlüsselwort »def«, der Name (hier »LKW«), ein Paar runder Klammern »()« und ein Doppelpunkt »:« bilden den Kopf.

Danach folgt die Suite »print( "Lastkraftwagen" )«.

(Das folgende Syntaxdiagramm gibt das Zeilenende vor der Suite nicht wieder.)

Aufbau einer Funktionsdefinition

Anweisung
     .---.     .--------------------------.     .-.      .-.      .-.     .------------.
--->( def )--->| gewoehnlicher Bezeichner |--->( ( )--->( ) )--->( : )--->| Suite      |--->
     '---'     '--------------------------'     '-'      '-'      '-'     '------------'
                 Name                        
  '--------------------------------------------------------------------' '---------------'
                                   Kopf                                        Rumpf

Vor »def« darf nichts in derselben Zeile stehen außer eventuellen Leerzeichen.

main.py

x = 2; def LKW():
    print( "Lastkraftwagen" )

Protokoll (teilweise verkürzt und übersetzt)

Datei "main.py", Zeile 1
x = 2; def LKW():
         ^
Syntaxfehler: syntaktisch nicht korrekte Eingabe

Eine Suite kann auch mehrere Zeilen umfassen.

Die Suite endet direkt vor der ersten Zeile, die weniger weit nach rechts eingerückt ist als die Zeile der Suite, oder mit dem Ende der Quelldatei.

Das Hauptprogramm

Das Hauptprogramm  besteht aus allen Anweisungen, die keine def-Funktionsdefinitionen sind und nicht selber in einer Funktionsdefinition enthalten sind.

(def-Funktionsdefinitionen bezeichnet man im Gegensatz zum Hauptprogramm auch als Unterprogramme.)

Die Zeilen des Hauptprogramms (außerhalb einer def-Funktionsdefinition) dürfen nicht  eingerückt sein.

Bei der Eingabe in eine Konsole muß eine def-Funktionsdefinition mit einer Leerzeile  abgeschlossen werden.

main.py

def LKW():
    print( end='Last' )
    print( 'kraftwagen' )
LKW()

Protokoll

Lastkraftwagen

Eine einfache Anweisung  ist eine Anweisung einer Art von Anweisungen, die nicht direkt eine Suite enthalten können. Beispielsweise ist die Auswertungsanweisung eine einfache Anweisung.

Eine Verbundanweisung  ist eine Anweisung einer Art von Anweisungen, die direkt eine Suite enthalten können. Beispielsweise ist die Funktionsdefinition eine Verbundanweisung.

Bei der Eingabe in die Konsole muß die Suite mit einer Leerzeile abgeschlossen werden, bevor die Funktion verwendet werden kann. Falls die Funktionsdefinition in einer Skriptdatei steht, ist dies nicht notwendig.

Bibliotheken und Programme

Eine Bibliothek  ist ein Modul ohne  Hauptprogramm.

Eine Programm  ist ein Modul mit  Hauptprogramm.

Semantik der Funktionsdefinition

Eine Funktionsdefinition ist eine Anweisung. Sie gehört zu den Verbundanweisungen, da sie andere Anweisungen enthalten (zu einer neuen Anweisung verbinden) kann.

Beim Aufruf der Funktion werden die Anweisungen der Suite ausgeführt.

Beim Aufruf einer Funktion wird deren Suite ausgeführt. Der Wert des Aufrufs ist ‹None›.

main.py

def LKW():
    print( end='Last' )
    print( 'kraftwagen' )
x = LKW()
print( 'x =', x )

Protokoll

Lastkraftwagen
x = None

Zitat aus The Python Language Reference, Release 3.8.0a0

A function definition defines a user-defined function object

Testen von Funktionen in IDLE

Nachdem eine Funktionsdefinition im Editor-Fenster mit „Run Module (F5)“ ausgeführt wurde, kann die definierte Funktion dann auch (nach dem Ende der Ausführung des Moduls) im Shell-Fenster aufgerufen werden.

Übungsfragen

?   Erkennen des Hauptprogramms

Welche Zeilen bilden in das Hauptprogramm in dem folgenden Skript?

main.py

def usw():
    print( 'und so weiter' )


usw()

Das Hauptprogramm  besteht aus allen Anweisungen, die keine def-Funktionsdefinitionen sind und nicht selber in einer Funktionsdefinition enthalten sind.

?   Erkennen des Hauptprogramms (1)

Welche Zeilen bilden in das Hauptprogramm in dem folgenden Skript?

main.py

print( '*** Start ***' )
def usw():
    print( 'und so weiter' )


usw()

Das Hauptprogramm  besteht aus allen Anweisungen, die keine def-Funktionsdefinitionen sind und nicht selber in einer Funktionsdefinition enthalten sind.

?   Ausgabe einer Funktion

Welche Ausgabe erzeugt das folgende Skript?

Diese Frage soll alleine durch Lesen des Skriptes beantwortet werden, ohne das Skript ausführen zu lassen.

main.py

def usw():
    print( 'und so weiter' )


usw()

?   Ausgabe einer Funktion (1)

Welche Ausgabe erzeugt die Ausführung des folgenden Skripts?

Diese Frage soll alleine durch Lesen des Skriptes beantwortet werden, ohne das Skript ausführen zu lassen.

main.py

def usw():
    print( end='und so weiter' )


usw(); print( end=', ' ); usw(); print();

Übungsaufgaben

Bei allen Übungsaufgaben in diesem Kapitel sollen Funktionen mit »def« definiert werden und nicht mit »= lambda«.

/   Textausgabe

Schreiben Sie eine def-Definition einer Funktion namens »f« mit der Suite »print( 'Test' )«. Der Kopf und die Suite dieser Funktionsdefinition soll dabei jeweils auf einer Zeile stehen, so daß die gesamte Funktionsdefinition zwei  Zeilen umfaßt.

Bei einer Funktionsdefinition ist der Kopf  der Teil bis zum Doppelpunkt »:«, der sich hinter dem Klammerpaar befindet, (einschließlich) und die Suite  der ganze Rest hinter dem Doppelpunkt.

/   Textausgabe (1)

Schreiben Sie eine def-Definition einer Funktion namens »alpha«, welche das Wort »gamma« ausgibt. (Das heißt: Wenn nach der Funktionsdefinition der Ausdruck »alpha()« ausgewertet werden würde, sollte das Wort »gamma« ausgeben werden.)

/   Textausgabe (2)

Schreiben Sie eine def-Definition einer Funktion namens »f«. Die Suite der Funktionsdefinition soll aus den beiden Anweisungen »print( 'alpha' )« und »print( 'gamma' )« bestehen. Der Kopf dieser Funktionsdefinition soll dabei eine Zeile umfassen und die Suite zwei, so daß die Funktionsdefinitionen insgesamt drei Zeilen umfaßt.

/   Refaktor

Das folgende Programm enthält zwei Blöcke, die mit »bgcolor« beziehungsweise »begin_fill« beginnen (und jeweils mit »fillcolor( 0, random(), random() )« beziehungsweise »end_fill()« enden). Starten Sie das Programm zunächst und sehen Sie sich die Ausgabe an. Definieren Sie für jeden der beiden Blöcke jeweils eine Funktion, welche den Block als Suite enthält, und schreiben Sie dann zwei Aufrufe jener beiden neuen Funktionen vor »hideturtle«, so daß das Programm hinterher weiterhin ein Dreieck mit zufälligen Farben zeichnet.

(Bearbeiten Sie die weiter unten stehenden Aufgaben noch nicht „im voraus“.)

main.py

from turtle import *
from random import random
bgcolor( 0, random(), random() )
pensize( 5 )
pencolor( 0, random(), random() )
fillcolor( 0, random(), random() )
begin_fill()
forward( 99 ); left( 360/3 )
forward( 99 ); left( 360/3 )
forward( 99 ); left( 360/3 )
end_fill()
hideturtle()

/   Refaktor 1

Finden Sie nun für jede der beiden Funktionen möglichst beschreibende (aber nicht zu lange) Namen (auf deutsch oder auf englisch).

(Bearbeiten Sie die weiter unten stehenden Aufgaben noch nicht „im voraus“.)

/   Refaktor 2

Schreiben Sie eine weitere Funktion mit »forward( 99 ); left( 360/3 )« als Suite und ersetzen Sie dann die bisherigen drei Zeilen »forward( 99 ); left( 360/3 )« durch Aufrufe jener Funktion.

(Bearbeiten Sie die weiter unten stehende Aufgabe noch nicht „im voraus“.)

/   Refaktor 3 ⃗

Schreiben Sie nun alle Anweisungen gegen Ende des Programmes, die noch nicht in einer Funktionsdefinition enthalten sind, als Suite in die Definition einer Funktion »main« und schreiben Sie dann einen Aufruf jener Funktion ganz an das Ende des Programms (als eine nicht in einer Funktionsdefinition enthaltenen Anweisung).

Anpassungen früherer Aussagen ⃗

Früher hatten wir einmal gelernt: „Eine Zeile muß eine Anweisung sein.“.

Da eine Zeile aber auch mehrere  semikolongetrennte Anweisungen umfassen kann, wurde diese Aussage später angepaßt zu: „Eine Zeile kann eine Anweisung oder mehrere Anweisungen enthalten.“

Nun haben wir gelernt, daß eine Anweisung auch mehrere Zeilen  umfassen kann (wenn die Anweisung eine Verbundanweisung ist), so daß ab jetzt keine einfache allgemeine Aussage zu der Enthaltensein-Beziehung zwischen Zeilen und Anweisungen möglich ist. Manchmal umfaßt eine Zeile mehrere Anweisungen, manchmal umfaßt eine Anweisung mehrere Zeilen, oft besteht eine Zeile aus genau einer Anweisung.