Zum Inhalt

Python

Funktionen und Module

Definition und Aufrufen

Eine Funktion ist ein Code, den man durch ihren Namen aufrufen kann. Mit einer Funktion kann man oft vermeiden, dass man Code doppelt schreiben muss. Zudem wird ein Programm dadurch übersichtlicher.

Funktionen werden mit def definiert und mit ihrem Namen aufgerufen, in der Klammer können bzw. müssen (je nach ihrer Definition) Argumente/Attribute/Variablenwerte/Parameter übergeben werden.

1
2
3
4
5
6
7
#!/usr/bin/env python3
def gruss(argument):
    n = argument.upper()
    print ('Sei gegrüßt ' + n + '!')

eingabe = input('Gibt bitte deinen Namen ein: ')
gruss(eingabe)

Docstrings

Guter Stil ist es, wenn man dokumentiert, was die Funktion leistet und wie sie aufzurufen ist. Die Beschreibung der Funktion zwischen den drei Anführungszeichen nennt man docstrings.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# funktion_gruss.py
#!/usr/bin/env python3

def gruss(name):
    """Begrüßung der Person.

    Das ist eine Funktion namens 'gruss'.
    Sie grüßt die im Argument übergebene Person.

    name: Ein String-Wert.

    >>> funktion_gruss.gruss('Max')
    Sei gegrüßt MAX!

    >>> funktion_gruss.gruss()
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: name 'gruss' is not defined
    """

    n = name.upper()
    print ('Sei gegrüßt ' + n + '!')

def gruss_2(name='Mustermann', alter='60'):
    """Funktions mit einem optionalen Argument.

    Dieser Funktion muss man kein Argument übergeben.

    >>> funktion_gruss.gruss_2('Max')
    Sei gegrüßt Max!

    >>> funktion_gruss.gruss_2()
    Sei gegrüßt Mustermann!
    """

    n = name.upper()
    print ('Sei gegrüßt ' + n + '!')

eingabe = input('Gibt bitte deinen Namen ein: ')
gruss(eingabe)

Demonstration dieses Skriptes (funktion_gruss.py) in der Python-Shell:

1
2
3
python3
>>> import funktion_gruss # D.i. der Dateiname ohne Dateiendung
>>> help(funktion_gruss.gruss)

Zur Definition von Argumenten

Die Definition einer Funktion mit Schlüsselwortargumenten (gruss_2) macht es evtl. leichter, die Funktion aufzurufen, weil man sich nicht merken muss, an welcher Stelle welches Argument steht, wie bei Funktionen mit positionsabhängigen Argumenten. Zudem funktioniert der Aufruf auch ohne ein Argument.

Module direkt starten und importieren

Beim Importieren eines Moduls wird sein Code ausgeführt. Wenn man das nicht will, die Datei aber mit python ....py direkt starten können will, muss man die letzten beiden Zeilen ersetzen durch:

1
2
3
if __name__ == "__main__":
    eingabe = input('Gibt bitte deinen Namen ein: ')
    gruss(eingabe)

Hintergrund: Beim Ausführen von Code bekommt er eine __name__-Variable zugewiesen, die dem Modulnamen entspricht. Beim Aufrufen mit python ....py heißt diese Variable __main__. Durch die drittletzte Zeile sagt man dem Interpreter also, dass er die letzten beiden Zeilen nur beim direkten Aufrufen mit python ....py ausführen soll, und beim Importieren ignorieren. Mehr zu Thema Module

Rückgabewerte

Funktionen können bei ihrer Ausführung etwas bearbeiten und die Bearbeitung zurück geben:

1
2
3
4
5
#!/usr/bin/env python3
def summe(a,b):
    c = a + b
    return c
print(summe(2,3))

Unbestimmte Anzahl an Argumente

Was man auch manchmal sieht, sind Argumente der Form **args oder *args. Unter **args verbirgt sich ein Dictionary, hinter *args ein Tupel. Das macht z.B. Sinn, wenn man durch eine Funktion Werte in eine Datei schreiben will, deren Anzahl variieren kann.

1
2
3
4
def verbinde(*args, trenner="."):
    return trenner.join(args)

verbinde('Eins','Zwei','Drei')

ergibt Eins.Zwei.Drei.

Anonyme Funktionen

Weil man das manchmal in Code sieht: Man kann auch Funktionen schreiben, ohne ihnen einen Namen zu geben; dann spricht man von anonymen Funktionen. Der Sinn ihrer Verwendung erschließt sich mir nicht wirklich, aber so sieht das z.B. aus:

1
2
3
4
5
>>> (lambda x: x**2)(3)
9
>>> p = lambda x: x**2
>>> print(p(3))
9
Beim letzten Beispiel ist meine Verwirrung komplett: man gibt da also doch einen Namen, naja, okay, kann man machen.

Geschwindigkeitsfunktion

Man kann mit der timeit-Funktion die Geschwindigkeit einer Funktion messen:

1
2
3
4
>>> import timeit
>>> l = list(range(20))
>>> min(timeit.repeat(lambda: l.copy()))
0.38122922903858125

Aufgabe

Programm der Programme

Programmiert in gruppenteiliger Teamarbeit gemeinsam ein Programm, das aus mehreren Modulen besteht, die jeweils eine mathematische Aufgabe lösen, also z.B. Flächenberechnungen, Hypothenusenlänge mit dem Satz des Pythagoras, Mitternachtsformel, Gegenseitige Lage von Geraden,..."

Tip

Im Ordner AlleProgramme könnte eine Datei namens __init__.py sein mit dem folgenden Inhalt:

1
2
3
4
import pkgutil
__path__ = pkgutil.extend_path(__path__, __name__)
for imp, module, ispackage in pkgutil.walk_packages(path=__path__, prefix=__name__+'.'):
    __import__(module)

Mit

1
2
>>> import AlleProgramme
>>> help(AlleProgramme)

kann man dann die Packages und mit help(AlleProgramme.beispiel) die Funktionen des Moduls beispiel inklusive ihres Docstrings anzeigen lassen.