Rheinwerk Computing < openbook >

 
Inhaltsverzeichnis
1 Einleitung
2 Die Programmiersprache Python
Teil I Einstieg in Python
3 Erste Schritte im interaktiven Modus
4 Der Weg zum ersten Programm
5 Kontrollstrukturen
6 Dateien
7 Das Laufzeitmodell
8 Funktionen, Methoden und Attribute
9 Informationsquellen zu Python
Teil II Datentypen
10 Das Nichts – NoneType
11 Operatoren
12 Numerische Datentypen
13 Sequenzielle Datentypen
14 Zuordnungen
15 Mengen
16 Collections
17 Datum und Zeit
18 Aufzählungstypen – Enum
Teil III Fortgeschrittene Programmiertechniken
19 Funktionen
20 Modularisierung
21 Objektorientierung
22 Ausnahmebehandlung
23 Iteratoren
24 Kontextobjekte
25 Manipulation von Funktionen und Methoden
Teil IV Die Standardbibliothek
26 Mathematik
27 Kryptografie
28 Reguläre Ausdrücke
29 Schnittstelle zu Betriebssystem und Laufzeitumgebung
30 Kommandozeilenparameter
31 Dateisystem
32 Parallele Programmierung
33 Datenspeicherung
34 Netzwerkkommunikation
35 Debugging und Qualitätssicherung
36 Dokumentation
Teil V Weiterführende Themen
37 Anbindung an andere Programmiersprachen
38 Distribution von Python-Projekten
39 Grafische Benutzeroberflächen
40 Python als serverseitige Programmiersprache im WWW – ein Einstieg in Django
41 Wissenschaftliches Rechnen
42 Insiderwissen
43 Von Python 2 nach Python 3
A Anhang
Stichwortverzeichnis

Download:
- Beispielprogramme, ca. 464 KB

Jetzt Buch bestellen
Ihre Meinung?

Spacer
<< zurück
Python 3 von Johannes Ernesti, Peter Kaiser
Das umfassende Handbuch
Buch: Python 3

Python 3
Pfeil 19 Funktionen
Pfeil 19.1 Schreiben einer Funktion
Pfeil 19.2 Funktionsobjekte
Pfeil 19.3 Funktionsparameter
Pfeil 19.3.1 Optionale Parameter
Pfeil 19.3.2 Schlüsselwortparameter
Pfeil 19.3.3 Beliebige Anzahl von Parametern
Pfeil 19.3.4 Reine Schlüsselwortparameter
Pfeil 19.3.5 Entpacken einer Parameterliste
Pfeil 19.3.6 Seiteneffekte
Pfeil 19.4 Namensräume
Pfeil 19.4.1 Zugriff auf globale Variablen – global
Pfeil 19.4.2 Zugriff auf den globalen Namensraum
Pfeil 19.4.3 Lokale Funktionen
Pfeil 19.4.4 Zugriff auf übergeordnete Namensräume – nonlocal
Pfeil 19.5 Anonyme Funktionen
Pfeil 19.6 Annotationen
Pfeil 19.7 Rekursion
Pfeil 19.8 Eingebaute Funktionen
Pfeil 19.8.1 abs(x)
Pfeil 19.8.2 all(iterable)
Pfeil 19.8.3 any(iterable)
Pfeil 19.8.4 ascii(object)
Pfeil 19.8.5 bin(x)
Pfeil 19.8.6 bool([x])
Pfeil 19.8.7 bytearray([source, encoding, errors])
Pfeil 19.8.8 bytes([source, encoding, errors])
Pfeil 19.8.9 chr(i)
Pfeil 19.8.10 complex([real, imag])
Pfeil 19.8.11 dict([source])
Pfeil 19.8.12 divmod(a, b)
Pfeil 19.8.13 enumerate(iterable)
Pfeil 19.8.14 eval(expression, [globals, locals])
Pfeil 19.8.15 exec(object, [globals, locals])
Pfeil 19.8.16 filter(function, iterable)
Pfeil 19.8.17 float([x])
Pfeil 19.8.18 format(value, [format_spec])
Pfeil 19.8.19 frozenset([iterable])
Pfeil 19.8.20 globals()
Pfeil 19.8.21 hash(object)
Pfeil 19.8.22 help([object])
Pfeil 19.8.23 hex(x)
Pfeil 19.8.24 id(object)
Pfeil 19.8.25 input([prompt])
Pfeil 19.8.26 int([x, base])
Pfeil 19.8.27 len(s)
Pfeil 19.8.28 list([sequence])
Pfeil 19.8.29 locals()
Pfeil 19.8.30 map(function, [*iterable])
Pfeil 19.8.31 max(iterable, {default, key}), max(arg1, arg2, [*args], {key})
Pfeil 19.8.32 min(iterable, {default, key}), min(arg1, arg2, [*args], {key})
Pfeil 19.8.33 oct(x)
Pfeil 19.8.34 ord(c)
Pfeil 19.8.35 pow(x, y, [z])
Pfeil 19.8.36 print([*objects], {sep, end, file, flush})
Pfeil 19.8.37 range([start], stop, [step])
Pfeil 19.8.38 repr(object)
Pfeil 19.8.39 reversed(sequence)
Pfeil 19.8.40 round(x, [n])
Pfeil 19.8.41 set([iterable])
Pfeil 19.8.42 sorted(iterable, [key, reverse])
Pfeil 19.8.43 str([object, encoding, errors])
Pfeil 19.8.44 sum(iterable, [start])
Pfeil 19.8.45 tuple([iterable])
Pfeil 19.8.46 type(object)
Pfeil 19.8.47 zip([*iterables])
 
Zum Seitenanfang

19.6    Annotationen Zur vorigen ÜberschriftZur nächsten Überschrift

Die Elemente einer Funktionsschnittstelle, also die Funktionsparameter und der Rückgabewert, lassen sich mit Anmerkungen, sogenannten Annotationen, versehen:

def funktion(p1: Annotation1, p2: Annotation2) -> Annotation3:
Funktionskörper

Bei der Definition einer Funktion kann hinter jeden Parameter ein Doppelpunkt geschrieben werden, gefolgt von einer Annotation. Eine Annotation darf dabei ein beliebiger Python-Ausdruck sein. Die Angabe einer Annotation ist optional. Hinter der Parameterliste kann eine ebenfalls optionale Annotation für den Rückgabewert der Funktion geschrieben werden. Diese wird durch einen Pfeil (->) eingeleitet. Erst hinter dieser Annotation folgt der Doppelpunkt, der den Funktionskörper einleitet.

Annotationen ändern an der Ausführung einer Funktion nichts, man könnte sagen: Dem Python-Interpreter sind Annotationen egal. Das Interessante an ihnen ist, dass man sie über das Attribut __annotations__ des Funktionsobjekts auslesen kann. Da Annotationen beliebige Ausdrücke sein dürfen, kann der Programmierer hier also eine Information pro Parameter und Rückgabewert »speichern«, auf die er zu einem späteren Zeitpunkt – beispielsweise wenn die Funktion mit konkreten Parameterwerten aufgerufen wird – zurückkommt.

Dabei werden die Annotationen über das Attribut __annotations__ in Form eines Dictionarys zugänglich gemacht. Dieses Dictionary enthält die Parameternamen bzw. "return" für die Annotation des Rückgabewertes als Schlüssel und die jeweiligen Annotation-Ausdrücke als Werte. Für die oben dargestellte schematische Funktionsdefinition sieht dieses Dictionary also folgendermaßen aus:

funktion.__annotations__ = 
{
"p1" : Annotation1,
"p2" : Annotation2,
"return" : Annotation3
}

Mit Function Annotations könnten Sie also beispielsweise eine Typüberprüfung an der Funktionsschnittstelle durchführen. Dazu definieren wir zunächst eine Funktion samt Annotationen:

def strmult(s: str, n: int) -> str:
return s*n

Die Funktion strmult hat die Aufgabe, einen String s n-mal hintereinander geschrieben zurückzugeben. Das geschieht durch Multiplikation von s und n.

Wir schreiben jetzt eine Funktion call, die dazu in der Lage ist, eine beliebige Funktion, deren Schnittstelle vollständig durch Annotationen beschrieben ist, aufzurufen bzw. eine Exception zu werfen, wenn einer der übergebenen Parameter einen falschen Typ hat:

def call(f, **kwargs):
for arg in kwargs:
if arg not in f.__annotations__:
raise TypeError("Parameter '{}'"
" unbekannt".format(arg))
if not isinstance(kwargs[arg], f.__annotations__[arg]):
raise TypeError("Parameter '{}'"
" hat ungültigen Typ".format(arg))
ret = f(**kwargs)
if type(ret) != f.__annotations__["return"]:
raise TypeError("Ungültiger Rückgabewert")
return ret

Die Funktion call bekommt ein Funktionsobjekt und beliebig viele Schlüsselwortparameter übergeben. Dann greift sie für jeden übergebenen Schlüsselwortparameter auf das Annotation-Dictionary des Funktionsobjekts f zu und prüft, ob ein Parameter dieses Namens überhaupt in der Funktionsdefinition von f vorkommt und – wenn ja – ob die für diesen Parameter übergebene Instanz den richtigen Typ hat. Ist eines von beidem nicht der Fall, wird eine entsprechende Exception geworfen.

Wenn alle Parameter korrekt übergeben wurden, wird das Funktionsobjekt f aufgerufen und der Rückgabewert gespeichert. Dessen Typ wird dann mit dem Datentyp verglichen, der in der Annotation für den Rückgabewert angegeben wurde; wenn er abweicht, wird eine Exception geworfen. Ist alles gut gegangen, wird der Rückgabewert der Funktion f von call durchgereicht:

>>> call(strmult, s="Hallo", n=3)
'HalloHalloHallo'
>>> call(strmult, s="Hallo", n="Welt")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Parameter 'n' hat ungültigen Typ
>>> call(strmult, s=13, n=37)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Parameter 's' hat ungültigen Typ

Um die Überprüfung auf den Rückgabewert testen zu können, muss natürlich die Definition der Funktion strmult verändert werden.

 


Ihre Meinung

Wie hat Ihnen das Openbook gefallen? Wir freuen uns immer über Ihre Rückmeldung. Schreiben Sie uns gerne Ihr Feedback als E-Mail an kommunikation@rheinwerk-verlag.de.

<< zurück
 Zum Rheinwerk-Shop
Zum Rheinwerk-Shop: Python 3 Python 3
Jetzt Buch bestellen

 Buchempfehlungen
Zum Rheinwerk-Shop: Einstieg in Python
Einstieg in Python


Zum Rheinwerk-Shop: Python. Der Grundkurs
Python. Der Grundkurs


Zum Rheinwerk-Shop: Algorithmen mit Python
Algorithmen mit Python


Zum Rheinwerk-Shop: Objektorientierte Programmierung
Objektorientierte Programmierung


Zum Rheinwerk-Shop: Raspberry Pi. Das umfassende Handbuch
Raspberry Pi. Das umfassende Handbuch


Zum Rheinwerk-Shop: Roboter-Autos mit dem Raspberry Pi
Roboter-Autos mit dem Raspberry Pi


Zum Rheinwerk-Shop: Neuronale Netze programmieren mit Python
Neuronale Netze programmieren mit Python


 Lieferung
Versandkostenfrei bestellen in Deutschland, Österreich und der Schweiz
InfoInfo

 
 


Copyright © Rheinwerk Verlag GmbH 2020
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das Openbook denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt.
Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.

 
[Rheinwerk Computing]

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de

Cookie-Einstellungen ändern