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 42 Insiderwissen
Pfeil 42.1 URLs im Standardbrowser öffnen – webbrowser
Pfeil 42.2 Interpretieren von Binärdaten – struct
Pfeil 42.3 Versteckte Passworteingabe
Pfeil 42.4 Kommandozeilen-Interpreter
Pfeil 42.5 Dateiinterface für Strings – io.StringIO
Pfeil 42.6 Generatoren als Konsumenten
Pfeil 42.6.1 Ein Decorator für konsumierende Generatorfunktionen
Pfeil 42.6.2 Auslösen von Exceptions in einem Generator
Pfeil 42.6.3 Eine Pipeline als Verkettung konsumierender Generatorfunktionen
Pfeil 42.7 Kopieren von Instanzen – copy
Pfeil 42.8 Die interaktive Python-Shell – IPython
Pfeil 42.8.1 Die interaktive Shell
Pfeil 42.9 Das Jupyter Notebook
Pfeil 42.10 Bildverarbeitung – Pillow
Pfeil 42.10.1 Bilddateien laden und speichern
Pfeil 42.10.2 Zugriff auf einzelne Pixel
Pfeil 42.10.3 Teilbereiche eines Bildes ausschneiden
Pfeil 42.10.4 Bilder zusammenfügen
Pfeil 42.10.5 Geometrische Bildtransformationen
Pfeil 42.10.6 Vordefinierte Bildfilter
Pfeil 42.10.7 Eigene Pixeloperationen
Pfeil 42.10.8 Bildverbesserungen
Pfeil 42.10.9 Zeichenoperationen
Pfeil 42.10.10 Interoperabilität
 
Zum Seitenanfang

42.6    Generatoren als Konsumenten Zur vorigen ÜberschriftZur nächsten Überschrift

In Abschnitt 23.2 haben Sie Generatoren kennengelernt. Generatoren sind spezielle Funktionen, die mehrere Werte nacheinander zurückgeben, sodass über sie iteriert werden kann.

Ein Beispiel ist der folgende Generator, der die ersten n Quadratzahlen erzeugt:

def square_generator(n):
for i in range(1,n+1):
yield i*i
for q in square_generator(3):
print(q)

Dieses Beispielprogramm gibt die Zahlen 1, 4 und 9 auf dem Bildschirm aus. Dabei nutzt jede for-Schleife das Iterator-Protokoll, sodass die zweite for-Schleife im Beispiel semantisch zu folgendem Programm äquivalent ist:

g = square_generator(3)
try:
while True:
v = next(g)
print(v)
except StopIteration:
pass

Es wird also zunächst eine Generatorinstanz g erzeugt, und anschließend wird so lange der nächste Wert mit next(g) gelesen, bis eine StopIteration-Exception geworfen wird, also keine Werte mehr übrig sind. Dabei liefert der Generator nach seiner Erzeugung Werte an die aufrufende Ebene, ohne dass diese Informationen an den Generator weitergeben kann – der Generator agiert als Produzent und die aufrufende Ebene als Konsument der Daten.

Es gibt in Python die Möglichkeit, diese Beziehung umzukehren, sodass ein Generator Daten von der aufrufenden Ebene empfangen kann und damit zum Konsumenten wird. Dazu hat ein Generator eine Methode send(wert), die einen Wert an eine Generatorinstanz sendet. Im Generator kann ein so gesendeter Wert empfangen werden, indem der Rückgabewert der yield-Anweisung gelesen wird. Das folgende Beispielprogramm implementiert einen konsumierenden Generator, der alle empfangenen Werte mit print ausgibt:

def printer():
while True:
wert = (yield)
print(wert)

p = printer()
next(p)

p.send(87)
p.send("Habicht")
p.send([4,3,2])

Das Programm erzeugt die folgende Ausgabe:

87
Habicht
[4, 3, 2]

Nach der Definition der Generatorfunktion printer wird mit p = printer() eine Generatorinstanz erzeugt, und der Aufruf next(p) lässt die Generatorinstanz bis zum ersten yield laufen. Dies ist deshalb notwendig, weil nur Daten an eine Generatorinstanz gesendet werden können, wenn diese an einer yield-Anweisung wartet. Nun senden wir mit p.send(87) den Wert 87 an den Generator, was dazu führt, dass dieser seine Arbeit dort wieder aufnimmt, wo er durch yield unterbrochen wurde, also in der Zeile wert = (yield). Entscheidend ist nun, dass die yield-Anweisung den gesendeten Wert annimmt, sodass nach dem Ausführen der Zeile die Referenz wert auf 87 zeigt. Anschließend erfolgt die Ausgabe, und die Schleife beginnt von Neuem, wodurch der Generator die Kontrolle wieder an die aufrufende Ebene abgibt und bei yield wartet.

Wird der Rückgabewert der yield-Anweisung verwendet, muss die Anweisung geklammert werden. Die Klammern können nur dann entfallen, wenn die yield-Anweisung als einziger Operand auf der rechten Seite einer Zuweisung steht, aber auch dann ist es guter Stil, trotzdem Klammern zu setzen. Beispiele für gültige yield-Anweisungen sind:

def yield_darf_nur_innerhalb_von_def_bloecken_stehen():
a = yield
a = yield 5
a = (yield) + 10
print((yield))
funktion(10, (yield 20))

Unzulässige yield-Anweisungen zeigen die folgenden Beispiele:

def yield_darf_nur_innerhalb_von_def_bloecken_stehen():
a = yield + 10
print(yield)
funktion(10, yield 20)
[»]  Hinweis

Wenn Sie Subgeneratoren mit yield from verwenden, werden die mit send gesendeten Werte bis zum am tiefsten verschachtelten Subgenerator durchgereicht.

 
Zum Seitenanfang

42.6.1    Ein Decorator für konsumierende Generatorfunktionen Zur vorigen ÜberschriftZur nächsten Überschrift

Um eine konsumierende Generatorfunktion beim Erzeugen automatisch zum ersten yield laufen zu lassen, eignet sich der folgende Decorator konsument. Wird printer in unserem Beispiel mit konsument dekoriert, entfällt der explizite Aufruf next(p).

def konsument(f):
def h_f(*args, **kwargs):
gen = f(*args, **kwargs)
next(gen)
return gen
return h_f

@konsument
def printer():
while True:
wert = (yield)
print(wert)

Mit diesem Decorator entfällt der explizite Aufruf next(p) nach dem Erzeugen des Generators.

 
Zum Seitenanfang

42.6.2    Auslösen von Exceptions in einem Generator Zur vorigen ÜberschriftZur nächsten Überschrift

Von der aufrufenden Ebene aus können Exceptions in einer Generatorfunktion ausgelöst werden, indem sie der Methode throw der Generatorinstanz übergeben werden. Innerhalb der Generatorfunktion tritt die Exception dann bei der yield-Anweisung auf, bei der der Generator angehalten wurde.

Das folgende Beispiel nutzt diese Möglichkeit, um bei einem Fehler Informationen zum internen Zustand eines Generators mit in den Traceback aufzunehmen.

def generator(n):
for i in range(1,n+1):
try:
yield i*i
except Exception as e:
raise Exception("Fehler beim Index {}".format(i))

g = generator(100)
next(g)
next(g)
g.throw(ValueError)

Das Beispiel ergibt folgende Ausgabe:

Traceback (most recent call last):
File "gen.py", line 4, in generator
yield i*i
ValueError

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
File "gen.py", line 11, in <module>
g.throw(ValueError)
File "gen.py", line 6, in generator
raise Exception("Fehler beim Index {}".format(i))
Exception: Fehler beim Index 2
[»]  Hinweis

Wenn Sie Subgeneratoren mit yield from verwenden, werden die mit throw ausgelösten Exceptions bis zum am tiefsten verschachtelten Subgenerator durchgereicht.

 
Zum Seitenanfang

42.6.3    Eine Pipeline als Verkettung konsumierender Generatorfunktionen Zur vorigen ÜberschriftZur nächsten Überschrift

Eine Anwendung konsumierender Generatorfunktionen ist die Konstruktion von Pipelines durch die Verkettung einzelner Bausteine. Als Beispiel betrachten wir eine Pipeline, die ein Signal, also eine Folge von Zahlenwerten, verarbeitet. Dabei gibt es zwei Arten von Bausteinen:

  1. Filterblöcke, die Zahlen empfangen können und diese an einen weiteren Block weitergeben
  2. Ausgabeblöcke, die Zahlen empfangen können und diese nicht weitergeben, sondern zum Beispiel auf dem Bildschirm ausgeben

Im folgenden Programm implementieren wir die beiden Filterblöcke filter_hebe(stufe, ziel) und filter_mittelwert(fenster, ziel):

@konsument
def filter_hebe(stufe, ziel):
while True:
ziel.send(stufe + (yield))

@konsument
def filter_mittelwert(fenster, ziel):
werte = []
while True:
werte.append((yield))
if len(werte) >= fenster:
ziel.send(sum(werte)/fenster)
werte.pop(0)

@konsument
def ausgabe():
while True:
print((yield))

p = ausgabe()
f = filter_hebe(10, p)
f = filter_mittelwert(2, f)

for d in [1, 3, 2, 4, 2, 1]:
f.send(d)

Der Block filter_hebe addiert zu jedem empfangenen Wert die Zahl stufe hinzu und schickt das Ergebnis an den Konsumenten ziel weiter. In dem zweiten Block filter_mittelwert wird der Mittelwert der letzten in fenster empfangenen Werte an ziel weitergeschickt. Dazu werden die letzten Werte in der Liste werte gespeichert.

Die Generatorfunktion ausgabe ist ein einfacher Ausgabenblock, der jeden empfangenen Wert mit print auf dem Bildschirm ausgibt.

Mit den folgenden Zeilen wird eine Signalverarbeitungspipeline aus drei Blöcken aufgebaut:

p = ausgabe()
f = filter_hebe(10, p)
f = filter_mittelwert(2, f)

Wird nun in der for-Schleife mit f.send(d) ein Wert in die Pipeline geschickt, wird dieser zunächst von filter_mittelwert verarbeitet. Nachdem genügend Werte von filter_mittelwert gesammelt worden sind (in diesem Beispiel 2), wird ihr Mittelwert an filter_hebe weitergesendet, dort um 10 vergrößert und an ausgabe geschickt, wo der Wert schließlich ausgegeben wird.

Das Beispielprogramm erzeugt also die folgende Ausgabe:

12.0
12.5
13.0
13.0
11.5

Sie können dieses Beispiel erweitern, indem Sie weitere Filter- oder Ausgabeblöcke definieren und diese in unterschiedlichen Reihenfolgen zu einer Pipeline verbinden.

 


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