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.

```python

!/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.

```python

funktion_gruss.py

!/usr/bin/env python3

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
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.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
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:

```bash 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:

python 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:

```python

!/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.

```python 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:

```python

(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:

```python

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:

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

Mit

```bash

import AlleProgramme help(AlleProgramme) ```

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