Python programmieren lernen für Dummies
Author: John Paul Mueller
Date: 2015-08-27T22:00:00+00:00
Keywords: Computers; Software Development & Engineering; General; Programming
Description: Der Einstieg in die Programmierung kann ganz leicht sein, das beweist Ihnen dieses Buch! Schritt fï¿1⁄2r Schritt fï¿1⁄2hrt Sie John Paul Mueller in die Grundlagen der beliebten Programmiersprache Python ein und zeigt Ihnen, wie Sie Ihren Computer dazu bringen, das zu tun, was Sie wollen. Downloaden und installieren Sie Python, lernen Sie die Programmiersprache kennen und schreiben Sie Ihre ersten eigenen Befehle und Anwendungen. Auï¿1⁄2erdem erfahren Sie, wie Sie Informationen managen und modifizieren, Schleifen schreiben, Fehler beheben und mit Listen und Strings arbeiten. Zusï¿1⁄2tzlich erha
Publisher: John Wiley & Sons

Bibliografische Information der Deutschen Nationalbibliothek

Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.

1. Auflage 2015

© 2015 WILEY-VCH Verlag GmbH & Co. KGaA, Weinheim

Original English language edition Beginning Programming With Python For Dummies © 2014 by Wiley Publishing, Inc.

All rights reserved including the right of reproduction in whole or in part in any form. This translation published by arrangement with John Wiley and Sons, Inc. This EBook published under license with the original publisher John Wiley and Sons, Inc.

Copyright der englischsprachigen Originalausgabe Beginning Programming With Python For Dummies © 2014 by Wiley Publishing, Inc.

Alle Rechte vorbehalten inklusive des Rechtes auf Reproduktion im Ganzen oder in Teilen und in jeglicher Form. Dieses E-Book wird mit Genehmigung des Original-Verlages John Wiley and Sons, Inc. publiziert.

Wiley, the Wiley logo, Für Dummies, the Dummies Man logo, and related trademarks and trade dress are trademarks or registered trademarks of John Wiley & Sons, Inc. and/or its affiliates, in the United States and other countries. Used by permission.

Wiley, die Bezeichnung »Für Dummies«, das Dummies-Mann-Logo und darauf bezogene Gestaltungen sind Marken oder eingetragene Marken von John Wiley & Sons, Inc., USA, Deutschland und in anderen Ländern.

Das vorliegende Werk wurde sorgfältig erarbeitet. Dennoch übernehmen Autoren und Verlag für die Richtigkeit von Angaben, Hinweisen und Ratschlägen sowie eventuelle Druckfehler keine Haftung.

Coverfoto: Eric Isselee/Shutterstock

Korrektur: Petra Heubach-Erdmann, Jürgen Edmann

Satz: inmedialo Digital- und Printmedien UG, Plankstadt

Print ISBN: 978-3-527-71148-2
ePub ISBN: 978-3-527-69246-0
mobi ISBN: 978-3-527-69243-9

Über den Autor

John Paul Mueller ist Autor zahlreicher Bücher über Themen wie Netzwerke, künstliche Intelligenz und vor allem Programmierung (z. B. »C++ Das Lehrbuch für Dummies«) sowie von zahlreichen Artikeln für Zeitschriften wie DevSource, InformIT, Visual C++ Developer, Hard Core Visual Basic, asp.netPRO u. v. m. Genau genommen sind es inzwischen 95 Bücher und über 300 Artikel. Er hat auch einen Blog, den finden Sie unter http://blog.johnmuellerbooks.com

Inhaltsverzeichnis

Einleitung

Über dieses Buch

Törichte Annahmen über den Leser

Symbole in diesem Buch

Über das Buch hinaus

Wie geht es weiter?

Teil I
Die ersten Schritte mit Python

1 Sprechen Sie mit Ihrem Computer!

Warum wollen Sie sich mit Ihrem Computer unterhalten?

Eine Anwendung – nur eine Form der Kommunikation

Das alltägliche Prozedere

Arbeitsabläufe aufschreiben

Anwendungen als gewöhnliche Arbeitsabläufe verstehen

Computer nehmen alles wörtlich

Was ist eine Anwendung eigentlich

Computer haben ihre eigene Sprache

Den Menschen helfen, mit dem Computer zu sprechen

Warum Python so cool ist

Warum man Python verwenden sollte

Wie Sie persönlich von Python profitieren können

Welche Organisationen verwenden Python?

Nützliche Python-Programme finden

Python mit anderen Sprachen vergleichen

2 Sich ein eigenes Python zulegen

Die gewünschte Version herunterladen

Python installieren

Mit Windows arbeiten

Mit dem Mac arbeiten

Mit Linux arbeiten

Auf Python auf Ihrem System zugreifen

Mit Windows

Mit dem Mac

Mit Linux

Ihre Installation ausprobieren

3 Mit Python arbeiten

Python in der Kommandozeile starten

Python starten

Die Kommandozeile nutzbringend einsetzen

Python-Umgebungsvariablen nutzbringend einsetzen

Einen Befehl eingeben

Dem Computer sagen, was er machen soll

Dem Computer mitteilen, dass Sie fertig sind

Sich das Ergebnis anschauen

Die Hilfe verwenden

In den Hilfemodus wechseln

Um Hilfe bitten

Den Hilfemodus verlassen

Sich unmittelbar Hilfe holen

Python in der Kommandozeile beenden

4 Ihre erste Anwendung schreiben

Die Integrierte Entwicklungsumgebung IDLE kennenlernen

IDLE starten

Die Standardbefehle verwenden

Die Farbcodierung verstehen

Die Hilfe in der GUI aufrufen

IDLE konfigurieren

Eine Anwendung erstellen

Ein neues Fenster öffnen

Den Befehl eingeben

Die Datei speichern

Die Anwendung ausführen

Den Nutzen von Einrückungen verstehen

Kommentare einfügen

Kommentare verstehen

Kommentare als Erinnerungsstützen verwenden

Mit Kommentaren den Code von der Ausführung abhalten

Laden und Ausführen existierender Anwendungen

Die Kommandozeile oder das Terminalfenster verwenden

Das Editierfenster benutzen

Das Python-Shell-Fenster oder die Python-Kommandozeile verwenden

IDLE schließen

Teil II
Mit der Programmierung loslegen

5 Informationen speichern und ändern

Informationen speichern

Variablen als Aufbewahrungsboxen betrachten

Den richtigen Behälter zur Datenspeicherung verwenden

Pythons grundlegende Datentypen

Daten in Variablen ablegen

Numerische Datentypen verstehen

Boolesche Werte verstehen

Den Datentyp String verstehen

Mit Datum und Zeit arbeiten

6 Informationen verwalten

Pythons Sicht auf die Daten steuern

Vergleiche machen

Wie Computer Vergleiche machen

Mit Operatoren arbeiten

Operatoren definieren

Vorrangsregeln für Operatoren

Erstellen und Verwenden von Funktionen

Funktionen als Codepäckchen

Die Wiederverwendbarkeit von Code ist wichtig

Eine Funktion definieren

Auf Funktionen zugreifen

Informationen an Funktionen übergeben

Informationen von Funktionen zurückgeben lassen

Rückgabewerte vergleichen

Benutzereingaben

7 Entscheidungen treffen

Einfache Entscheidungen mit der »if«-Anweisung ausführen

Die »if«-Anweisung

Die »if«-Anweisung in einer Anwendung verwenden

Mit der »if...else«-Anweisung Optionen auswählen

Die »if…else«-Anweisung

Die »if…else«-Anweisung in einer Anwendung verwenden

Die »if…elif«-Anweisung in einer Anwendung verwenden

Verschachtelte Entscheidungsanweisungen verwenden

Mehrere »if«- oder »if…else«-Anweisungen verwenden

Weitere Entscheidungstypen miteinander kombinieren

8 Sich wiederholende Aufgaben ausführen

Daten mit der »for«-Anweisung verarbeiten

Die »for«-Anweisung

Eine einfache »for«-Schleife erstellen

Die Ausführung mit der »break«-Anweisung steuern

Die Ausführung mit der »continue«-Anweisung steuern

Die »pass«-Klausel

Die Ausführung mit der »else«-Anweisung steuern

Daten mit der »while«-Anweisung verarbeiten

Die »while«-Anweisung

Die »while«-Anweisung in einer Anwendung verwenden

Schleifen verschachteln

9 Mit Fehlern umgehen lernen

Warum versteht mein Python mich nicht?

Fehlerquellen erkennen

Klassifizieren, wann Fehler auftreten

Fehlertypen unterscheiden

Ausnahmen abfangen

Die grundlegende Ausnahmebehandlung

Ausnahmebehandlung: vom Spezifischen zum weniger Spezifischen

Verschachtelte Ausnahmebehandlung

Ausnahmen auslösen

Ausnahmen unter außergewöhnlichen Umständen auslösen

Fehlerinformationen an den Aufrufer übergeben

Benutzerdefinierte Ausnahmen erzeugen und verwenden

Die »finally«-Klausel verwenden

Teil III
Häufig benötigte Programmieraufgaben

10 Mit Modulen arbeiten

Code gruppieren

Module importieren

Die »import«-Anweisung verwenden

Die »from…import«-Anweisung verwenden

Module finden

Sich den Modulinhalt anschauen

Die Python Module Documentation verwenden

Die pydoc-Anwendung öffnen

Die Links für den Schnellzugriff verwenden

Einen Suchbegriff eingeben

Die Ergebnisse anschauen

11 Mit Zeichenketten arbeiten

Zeichenketten sind anders

Ein Zeichen durch Zahlen definieren

Zeichen zur Erstellung von Zeichenketten verwenden

Zeichenketten mit Sonderzeichen erstellen

Zeichen auswählen

Aus Zeichenketten Kleinholz machen

Einen Wert in einer Zeichenkette finden

Zeichenketten formatieren

12 Listen verwalten

Informationen in einer Anwendung strukturieren

Eine Struktur mit Listen erstellen

Wie Computer Listen sehen

Listen erstellen

Auf Listen zugreifen

Listen durchlaufen

Listen bearbeiten

Listen durchsuchen

Listen sortieren

Mit dem Counter-Objekt arbeiten

13 Verschiedene Sorten von Daten sammeln

So funktionieren Collections

Mit Tupeln arbeiten

Mit Dictionaries arbeiten

Erstellung und Verwendung eines Dictionarys

Die »switch«-Anweisung durch ein Dictionary ersetzen

Stapel mithilfe von Listen erstellen

Mit Warteschlangen arbeiten

Mit Deques arbeiten

14 Klassen erstellen und verwenden

Klassen als Strukturierungshilfe

Komponenten einer Klasse

Eine Klassendefinition schreiben

Die integrierten Klassenattribute

Mit Methoden arbeiten

Mit Konstruktoren arbeiten

Mit Variablen arbeiten

Methoden mit variablen Parameterlisten verwenden

Operatoren überladen

Eine Klasse erstellen

Die Klasse in einer Anwendung verwenden

Eine Klasse erweitern, um neue Klassen zu schaffen

Eine Kindklasse schreiben

Die Klasse in einer Anwendung testen

Teil IV
Fortgeschrittene Programmieraufgaben

15 Daten in Dateien speichern

Wie die permanente Datenspeicherung funktioniert

Daten für die permanente Speicherung erstellen

Eine Datei erstellen

Dateiinhalte lesen

Dateiinhalte aktualisieren

Eine Datei löschen

16 Eine E-Mail versenden

Das passiert, wenn man eine E-Mail versendet

E-Mails als herkömmliche Briefe betrachten

Die Bestandteile des Umschlags

Die Bestandteile einer Nachricht

Eine E-Mail-Nachricht erstellen

Eine Textnachricht versenden

Eine HTML-Nachricht versenden

Sich die E-Mail-Ausgabe anschauen

Teil V
Der Top-Ten-Teil

17 Zehn tolle Quellen zum Thema Programmierung

Mit der Python-Online-Dokumentation arbeiten

Das LearnPython.org-Tutorial

Eine Webanwendung mit Python programmieren

Zusätzliche Bibliotheken beschaffen

Schneller Anwendungen mit einer IDE erstellen

Ihre Syntax einfacher prüfen

XML sinnvoll einsetzen

Die üblichen Anfängerfehler in Python vermeiden

Unicode verstehen

Machen Sie Ihre Python-Anwendung flott

18 Zehn Wege, mit Python Geld zu verdienen

In der Qualitätssicherung arbeiten

IT-Mitarbeiter in einer kleinen Firma werden

Spezialskripte für Anwendungen schreiben

Ein Netzwerk administrieren

Programmierkenntnisse vermitteln

Leuten dabei helfen, einen bestimmten Ort zu finden

Data Mining verwenden

Mit eingebetteten Systemen arbeiten

Wissenschaftliche Aufgaben erledigen

Datenanalyse in Echtzeit ausführen

19 Zehn interessante Tools

Programmfehler mit dem Roundup Issue Tracker dokumentieren

Eine virtuelle Umgebung mit VirtualEnv erstellen

Ihre Anwendung mit PyInstaller installieren

Eine Entwicklerdokumentation mit pdoc erzeugen

Anwendungscode mit PyCharm entwickeln

Ihre Anwendung mit pydbgr debuggen

Eine interaktive Umgebung mit IPython betreten

Anwendungen mit PyUnit testen

Ihren Code mit Isort aufräumen

Versionskontrolle mit Mercurial verwenden

20 Zehn Bibliotheken, die Sie kennen sollten

Eine sichere Umgebung mit PyCrypo entwickeln

Auf Datenbanken mit SQLAlchemy zugreifen

Die Welt mit Google Maps bereisen

Eine Benutzeroberfläche mit TkInter erstellen

Eine nette tabellarische Datendarstellung mit PrettyTable erstellen

Ihre Anwendung mit Sound mit PyAudio bereichern

Bilder mit PyQtGraph bearbeiten

Informationen mit IRLib finden

Eine interoperable Java-Umgebung mit JPype erstellen

Auf lokale Netzwerkressourcen mit Twisted Matrix zugreifen

Mit Bibliotheken auf Ressourcen im Internet zugreifen

Stichwortverzeichnis

Einleitung

Schnell! Mit welcher Programmiersprache werden Sie im Handumdrehen Anwendungen auf jedem bekannten System schreiben können? Geben Sie auf? Ja, genau, es handelt sich um Python. Das Tolle an Python ist, dass Sie tatsächlich eine Anwendung auf einem System schreiben und sie auf jeder anderen Zielplattform verwenden können. Im Gegensatz zu anderen Programmiersprachen, die versprachen, Plattformunabhängigkeit anzubieten, ermöglicht Python diese Unabhängigkeit tatsächlich. Im Falle von Python ist halt das Versprechen genauso gut wie das Ergebnis, was am Ende herauskommt.

Python legt den Schwerpunkt auf die Lesbarkeit des Codes und eine sparsame Syntax, mit der Sie Anwendungen mit weniger Zeilen Code schreiben können, als das in anderen Sprachen der Fall ist. Außerdem ist Python aufgrund seiner Eigenschaften in sehr vielen Bereichen vertreten, in denen Sie auch Quereinsteiger, also keine reinen Programmierer, finden. Manche Leute sehen Python als Skriptsprache an, aber eigentlich ist es viel mehr als das. (Kapitel 18 stellt Ihnen nur einen Bruchteil der Jobs vor, in denen Sie mit Python arbeiten können.)

Über dieses Buch

In Python programmieren lernen für Dummies dreht sich alles um den schnellen Einstieg in Python. Sie möchten die Sprache sicherlich schnell erlernen, um ein Ergebnis für Ihre eigentliche Arbeit zu produzieren, egal worum es sich dabei handelt. Anders als bei anderen Büchern zeigt Ihnen dieses Buch von Anfang an, wie sich Python von anderen Sprachen unterscheidet und wie es Ihnen dabei helfen kann, praktische Aufgaben für einen Job zu erledigen, der nicht unbedingt mit Programmierung zusammenhängen muss. Durch die Übung mit Praxisbeispielen und das Ausführen wirklich nützlicher Aufgaben bekommen Sie von Anfang an ein Verständnis dafür, wie der Hase läuft. Sie bekommen sogar beigebracht, wie Sie Python auf Ihrem eigenen System installieren können.

Wenn Sie Python einmal ordentlich auf der von Ihnen genutzten Plattform installiert haben, können Sie mit den Grundlagen beginnen und sich Stück für Stück vorarbeiten. Sobald Sie die Beispiele in diesem Buch durchgearbeitet haben, können Sie mit Python einfache Programme schreiben und Dinge erledigen, wie das Versenden einer E-Mail. Nein, Sie werden noch kein Experte sein, aber Sie werden Python so einsetzen können, dass Sie den Anforderungen in Ihrer Arbeitsumgebung gerecht werden. Damit Sie die in diesem Buch vorgestellten Konzepte noch besser verstehen können, werden die folgenden Formatierungen verwendet:

Kursiv formatierte Wörter in einem einzugebenden Text bedeuten, dass Sie diese durch etwas ersetzen sollen, dass für Ihren speziellen Fall funktioniert. Wenn Sie zum Beispiel lesen »Geben Sie IhrName ein und drücken Sie die Eingabetaste«, müssen Sie IhrName durch Ihren eigentlichen Namen ersetzen.

Webadressen, Programmcode und Texte, die Sie wie im Buch angegeben, eintippen sollen, sind mit monofont formatiert. Wenn Sie eine digitale Version dieses Buches auf einem Gerät mit Internetzugang lesen, können Sie auf die Webadresse klicken, um zu der entsprechenden Website zu gelangen, zum Beispiel dieser hier: http://www.wiley-vch.de/dummies.

Menüpunkte oder Buttons, auf die Sie klicken beziehungsweise die Sie auswählen sollen, zum Beispiel SPEICHERN, OK oder ABBRECHEN, werden in Kapitälchen geschrieben. Befehlssequenzen werden folgendermaßen getrennt: DATEI|DATEI NEU. In diesem Fall müssen Sie zuerst das Dateimenü öffnen und dann den Eintrag DATEI NEU in diesem Menü auswählen. Als Ergebnis sehen Sie dann die neu erzeugte Datei.

Törichte Annahmen über den Leser

Es ist für Sie sicher schwer zu glauben, dass ich schon etwas über Sie zu wissen glaube – ich habe Sie schließlich noch nie im Leben gesehen! Obwohl einige der Annahmen tatsächlich töricht sind, habe ich die folgenden Annahmen über Sie getroffen, um einen Grundstein für das Buch zu setzen.

Es ist wichtig, dass Sie sich mit dem System, das Sie benutzen wollen, auskennen, da Ihnen dieses Buch in dieser Hinsicht leider nichts bieten kann. (Kapitel 2 enthält eine Anleitung zur Installation von Python auf verschiedenen Systemen.) Damit Sie in diesem Buch so viele Informationen wie möglich über Python nachlesen können, behandelt dieses Buch keine plattformspezifischen Probleme. Sie müssen schon vor dem Lesen dieses Buches wissen, wie Sie Anwendungen installieren und verwenden und ganz allgemein mit dem von Ihnen gewählten System arbeiten können.

Dieses Buch nimmt ebenfalls an, dass Sie in der Lage sind, im Internet zu finden, was Sie suchen. Überall im Buch finden Sie zahlreiche Referenzen auf Online-Material, das Sie beim Lernen von Python unterstützen soll. Natürlich sind diese Quellen nur dann nützlich, wenn Sie sie tatsächlich finden und verwenden können.

Symbole in diesem Buch

Beim Lesen dieses Buches sehen Sie immer wieder an den Seitenrändern Symbole, die auf interessante (oder nicht, je nachdem) Informationen hinweisen. Dieser Abschnitt beschreibt kurz alle Symbole in diesem Buch.

Tipps sind etwas Feines, da sie Ihnen dabei helfen, Zeit zu sparen oder eine Aufgabe ohne viel Zusatzaufwand zu erledigen. Die Tipps in diesem Buch sind Zeitsparmaßnahmen oder Hinweise auf andere Quellen, die Sie sich anschauen können, um das Maximum aus Python herauszuholen.

Ich möchte wirklich nicht wie ein Elternteil mit erhobenem Zeigefinger oder ein Paranoider klingen, aber Sie sollten alles, was mit einem Warnsymbol versehen ist, vermeiden. Andernfalls könnte es Ihnen zum Beispiel passieren, dass Ihr Programm lediglich die Benutzer verwirrt und diese dann nicht damit arbeiten wollen.

Immer, wenn Sie dieses Symbol sehen, werden Sie einen Tipp oder eine Vorgehensweise für Fortgeschrittene finden. Vielleicht werden Ihnen diese Leckerbissen nützlicher Informationen zum Lesen zu langweilig vorkommen. Aber sie könnten auch die Lösung enthalten, nach der Sie gerade suchen, um ein Programm zum Laufen zu bringen. Sie können diese Informationsschnipsel überspringen, wann immer Sie mögen.

Auch wenn Sie sonst nichts von einem Kapitel oder einem Abschnitt behalten haben, sollten Sie sich die Informationen, die mit diesem Symbol markiert wurden, wieder ins Gedächtnis rufen. Dieser Text enthält normalerweise einen grundlegenden Vorgang oder eine Information, die Sie kennen sollten, wenn Sie erfolgreich Python-Programme schreiben wollen.

Über das Buch hinaus

Dieses Buch ist nicht der Weisheit letzter Schluss für Ihre Erfahrungen als Python-Programmierer – es ist erst der Anfang. Ich stelle Ihnen Online-Inhalte zur Verfügung, um dieses Buch flexibler zu machen und Ihren Bedürfnissen besser anzupassen. Auf diesem Wege kann ich auch auf Fragen, die Sie mir vielleicht per E-Mail schicken (bitte nur auf Englisch), eingehen und Ihnen mitteilen, wie Updates von Python oder von verwendeten Bibliotheken den Inhalt dieses Buches beeinflussen. Um genau zu sein, bekommen Sie Zugriff auf die folgenden coolen Zugaben:

Aktualisierungen: Manchmal ändern sich Dinge. Es könnte ja nun sein, dass ich eine anstehende Änderung, während ich dieses Buch schrieb, nicht mit meiner Kristall-kugel habe kommen sehen. In der Vergangenheit bedeutete dies, dass das Buch veraltet und weniger nützlich war. Aber nun finden Sie Aktualisierungen des Buches unter www.dummies.com/extras/beginningprogrammingwithpython.

Zusätzlich sollten Sie sich auch mal die Blogeinträge mit Antworten auf die Leserfragen und Demos für äußerst praktische Methoden aus dem Buch anschauen.

Begleitdateien: Mal ehrlich – wer möchte schon sämtlichen Code in diesem Buch abtippen? Die meisten Leser ziehen es vor, ihre Zeit lieber mit dem Durcharbeiten der Beispiele als mit dem Abtippen des Codes zu verbringen. Glücklicherweise steht der Code zum Download zur Verfügung, sodass Sie einfach nur das Buch lesen müssen, um etwas über Programmiertechniken für Python zu lernen. Zu jedem Beispiel im Buch ist auch genau angegeben, welche Beispieldatei Sie benutzen können. Sie finden diese Dateien unter http://www.wiley-vch.de/publish/dt/books/ISBN3-527-71148-1.

Wie geht es weiter?

Nun wird es endlich Zeit, dass Ihr Programmierabenteuer mit Python beginnt! Wenn Sie ein totaler Programmieranfänger sind, sollten Sie mit Kapitel 1 beginnen und sich mit dem Tempo durch das Buch arbeiten, mit dem Sie so viel Informationen wie möglich aufnehmen können.

Wenn Sie ein Anfänger sind, die Zeit drängt und Sie so schnell wie möglich mit Python anfangen wollen, können Sie auch direkt zu Kapitel 2 blättern. Seien Sie sich aber bewusst, dass manche Themen weiter hinten im Buch dann etwas verwirrend sein können. Sie können auch direkt mit Kapitel 3 beginnen, wenn Sie Python schon installiert haben. Werfen Sie aber zumindest einen kurzen Blick in Kapitel 2, damit Sie wissen, welche Voraussetzungen es für die Beispiele im Buch gibt.

Leser, die mit Python schon mal in Berührung gekommen sind, können Zeit sparen, indem sie direkt Kapitel 5 aufschlagen. Sollten Sie Fragen haben, können Sie jederzeit zu vorherigen Kapiteln zurückkehren. Trotzdem ist es wichtig, dass Sie verstanden haben, wie ein Beispiel funktioniert, bevor Sie sich dem nächsten Beispiel zuwenden. Jedes Beispiel enthält wichtige Lektionen und Sie könnten grundlegende Inhalte verpassen, wenn Sie zu viele Informationen überschlagen.

Teil I

Die ersten Schritte mit Python

In diesem Teil . . .

Finden Sie heraus, worum es beim Programmieren geht und warum Sie dafür Python brauchen.

Laden Sie sich Ihr eigenes Python herunter und installieren Sie es auf Ihrem System.

Arbeiten Sie mit der interaktiven Umgebung, die Python Ihnen zur Verfügung stellt.

Erstellen Sie mit Python Ihre erste Anwendung.

Verstehen Sie, warum es sinnvoll ist, Ihre Anwendung mit Kommentaren zu versehen.

1

Sprechen Sie mit Ihrem Computer!

In diesem Kapitel

Sprechen Sie mit Ihrem Computer

Erstellen Sie Programme, um mit Ihrem Computer zu sprechen

Werden Sie verstehen, was ein Programm so macht und warum Sie es
erstellen möchten

Denken Sie darüber nach, warum Sie Python als Programmiersprache
verwenden wollen

Eine Unterhaltung mit einem Computer führen? Das hört sich eher an wie das Drehbuch zu einem Science-Fiction-Film. Die Besatzung der Enterprise in Star Trek hat zum Beispiel regelmäßig mit ihrem Computer gesprochen. Und der Computer hat auch oft geantwortet. Seit dem Aufkommen von Apples Siri (www.apple.com/de/ios/siri) und anderer interaktiver Software jedoch scheint eine solche Unterhaltung schon nicht mehr so unglaublich.

Den Computer um Informationen zu bitten, ist eine Sache, ihn mit Befehlen zu füttern, eine andere. Dieses Kapitel diskutiert, warum Sie Ihrem Computer überhaupt etwas befehlen wollen und was Sie davon haben. Sie werden auch feststellen, dass Sie für diese spezielle Kommunikationsform eine spezielle Sprache benötigen und warum Sie dafür Python benutzen sollten. Das hauptsächliche Fazit, das Sie aus diesem Kapitel ziehen sollten, ist, dass Programmieren einfach nur eine Art der Kommunikation ist, die anderen Formen der Kommunikation, die Sie schon mit Ihrem Computer pflegen, ähnelt.

Warum wollen Sie sich mit Ihrem Computer unterhalten?

Sich mit einer Maschine zu unterhalten, scheint zunächst einmal ziemlich langweilig. Es ist aber notwendig, da ein Computer ja nicht Gedanken lesen kann – noch nicht. Auch wenn der Computer tatsächlich Ihre Gedanken lesen könnte, würde er ja trotzdem mit Ihnen kommunizieren. Ohne den Austausch von Informationen zwischen der Maschine und Ihnen kann nichts vonstattengehen. Aktivitäten wie
das Lesen Ihrer E-Mails
etwas über Ihren Urlaub schreiben
das beste Geschenk der Welt finden
sind alles Beispiele für Kommunikation, die zwischen Ihrem Computer und Ihnen passiert. Die grundlegende Idee ist, dass Kommunikation notwendig ist, um Ergebnisse zu produzieren – das trifft natürlich auch auf Kommunikation zu, die zwischen Ihrem Computer und anderen Rechnern oder Menschen stattfindet.

Solange Sie nicht genauer darüber nachdenken, ist die Kommunikation in den meisten Fällen für Sie transparent. Wenn Sie beispielsweise online einen Chatroom betreten, haben Sie den Eindruck, dass Sie direkt mit einer anderen Person kommunizieren. Tatsächlich kommunizieren Sie aber mit Ihrem Computer, Ihr Computer spricht über den Chatroom mit dem Computer der anderen Person und dieser Computer kommuniziert wiederum mit seinem Menschen. Abbildung 1.1 zeigt Ihnen, was tatsächlich im Hintergrund passiert.

Abbildung 1.1: Die Kommunikation mit Ihrem Computer ist für Sie transparent, solange Sie nicht genauer darüber nachdenken.

Schauen Sie sich die Wolke in der Mitte von Abbildung 1.1 an. Die Wolke könnte alles Mögliche enthalten. Wie Sie aber natürlich wissen, enthält sie auf jeden Fall andere Computer, die weitere Anwendungen ausführen. Diese Computer ermöglichen es Ihnen und Ihren Freunden, miteinander zu chatten. Nun denken Sie einmal daran, wie einfach der gesamte Vorgang scheint, wenn Sie ein Chatprogramm verwenden. Obwohl all diese komplexen Dinge im Hintergrund passieren, kommt es Ihnen doch so vor, als wenn Sie sich einfach nur mit Ihrem Freund unterhalten, aber der Vorgang an sich ist für Sie transparent.

Eine Anwendung – nur eine Form der Kommunikation

Die Kommunikation mit dem Computer erfolgt durch die Verwendung von Anwendungen. Sie verwenden zum Beispiel eine Anwendung, um Ihre E-Mails zu beantworten, eine andere, um Sachen zu kaufen, und wieder eine andere, um eine Präsentation zu erstellen. Eine Anwendung (Programm oder auch manchmal App genannt) ist eine Methode, um dem Computer menschliche Ideen so zu präsentieren, dass er sie verstehen kann. Außerdem werden durch eine Anwendung die Werkzeuge festgelegt, die Daten spezifisch für die Kommunikation aufbereiten. Daten, die den Inhalt einer Präsentation repräsentieren, unterscheiden sich von Daten, die benötigt werden, um ein Geschenk für Ihre Mutter zu kaufen. Die Art und Weise, wie Sie die Daten anschauen, verwenden und verstehen, ist für jede Aufgabe verschieden. Also müssen Sie auch verschiedene Anwendungen benutzen, um mit den Daten so zu interagieren, dass der Computer und Sie diese verstehen können.

Sie können quasi für jeden Bedarf, den Sie sich heutzutage vorstellen können, eine Anwendung schreiben. In der Tat haben Sie wahrscheinlich Zugriff auf Anwendungen, von denen Sie noch nicht einmal wissen, wofür man sie braucht. Programmierer erstellen seit vielen Jahren fleißig Millionen von Anwendungen. Daher ist es vielleicht erst einmal nicht leicht nachzuvollziehen, warum Sie eine neue Anwendung schreiben sollten, um mit Ihrem Computer zu kommunizieren. Letzten Endes finden Sie die Antwort, wenn Sie darüber nachdenken, welche Daten Sie haben und wie Sie damit interagieren wollen. Manche Daten kommen vielleicht nicht so häufig vor, sodass es Programmierern bisher nicht in den Sinn kam, dafür eine Anwendung zu schreiben, oder die Daten liegen in einer Form vor, die keine Anwendung aktuell unterstützt. Also haben Sie keine Möglichkeit, Ihrem Computer die Daten zu präsentieren, ohne nicht selbst eine eigene Anwendung dafür zu schreiben.

Der folgende Abschnitt beschreibt Anwendungen mit dem Hintergedanken, dass Sie mit ganz spezifischen Daten auf eine spezielle Art und Weise arbeiten. Zum Beispiel könnten Sie Zugriff auf eine Datenbank für eine Videobibliothek haben, aber keine Möglichkeit, auf eine für Sie sinnvolle Weise damit zu arbeiten. Sowohl die Daten als auch Ihre Zugriffsanforderungen sind sehr speziell – also keimt in Ihnen der Gedanke, eine Anwendung zu schreiben, die sowohl den Daten als auch Ihren Bedürfnissen gerecht wird.

Das alltägliche Prozedere

Ein Arbeitsablauf oder Prozess ist einfach eine Menge aus Schritten, denen Sie folgen, um eine Aufgabe auszuführen. Wenn Sie sich zum Beispiel einen Toast machen, führen Sie vielleicht den folgenden Ablauf aus:

1. Sie holen das Brot und die Butter aus dem Kühlschrank.

2. Sie öffnen die Brottüte und holen zwei Scheiben Toast heraus.

3. Sie stecken das Kabel des Toasters in die Steckdose.

4. Sie positionieren je eine Scheibe Brot in einen Schlitz.

5. Sie drücken den Toasterhebel herunter, um den Toastvorgang zu starten.

6. Sie warten, bis der Toastvorgang abgeschlossen ist.

7. Sie holen den Toast aus dem Toaster.

8. Sie legen die Toastscheiben auf einen Teller.

9. Sie bestreichen den Toast mit Butter.

Ihre Vorgehensweise unterscheidet sich vielleicht von der hier vorgestellten, aber es ist sehr unwahrscheinlich, dass Sie den Toast mit Butter bestreichen, bevor Sie ihn toasten. Natürlich müssen Sie vorher den Toast aus der Verpackung holen, bevor Sie ihn toasten (den Toast mitsamt Verpackung und allem Drum und Dran in den Toaster zu stecken, könnte zu unerwünschten Ergebnissen führen …). Die meisten Leute denken gar nicht über das Toastmachen nach. Aber trotzdem verwenden sie einen solchen Arbeitsablauf, auch wenn sie nicht darüber nachdenken.

Ohne einen Ablaufplan können Computer Aufgaben nicht ausführen. Sie müssen dem Computer sagen, welche Schritte er ausführen soll, in welcher Reihenfolge er sie ausführen soll, und Sie müssen ihn auf alle Ausnahmen, die auftreten und zu einem Fehler führen können, vorbereiten. All diese Informationen (und noch mehr) sind in einer Anwendung beschrieben. Kurz gefasst ist eine Anwendung einfach ein aufgeschriebener Arbeitsablauf, den Sie verwenden, um dem Computer zu sagen, was er machen soll, wann er es machen soll und wie er es machen soll. Da Sie Arbeitsabläufe ja schon Ihr Leben lang verwenden, müssen Sie dieses Wissen nur noch auf die Dinge anwenden, die ein Computer über bestimmte Aufgaben wissen muss.

Arbeitsabläufe aufschreiben

Als ich in der Grundschule war, gab uns unsere Lehrerin die Aufgabe, etwas über das Toastmachen zu schreiben. Nachdem wir alle unsere Aufsätze abgegeben hatten, holte sie einen Toaster und ein paar Brote hervor. Jeder Aufsatz wurde dann vorgelesen und demonstriert. Keine der von uns beschriebenen Vorgehensweisen funktionierte wie vorgesehen, produzierte aber sehr lustige Ergebnisse. In meinem Fall vergaß ich, die Lehrerin zu bitten, die Verpackung zu entfernen. Also versuchte sie pflichtbewusst, das Brot mitsamt der Verpackung in den Toaster zu stecken. Diese Lektion ist bei mir hängen geblieben. Prozeduren aufzuschreiben, kann ziemlich schwer sein, da wir zwar genau wissen, was wir machen wollen, aber oft Schritte auslassen – wir nehmen einfach an, dass die andere Person auch genau weiß, was wir machen wollen.

Viele alltägliche Lebenssituationen drehen sich um Arbeitsabläufe. Denken Sie nur an die Checkliste, die Piloten vor einem Start verwenden. Ohne einen standardisierten Prozess könnte das Flugzeug abstürzen. Das Aufschreiben eines Arbeitsablaufs braucht seine Zeit, ist aber machbar. Vielleicht müssen Sie mehrere Anläufe starten, um einen voll funktionsfähigen Arbeitsablauf aufzuschreiben, aber wahrscheinlich werden Sie eine solche erstellen können. Es reicht aber nicht nur, den Arbeitsablauf aufzuschreiben – Sie müssen den Arbeitsablauf auch von jemandem testen lassen, der mit der zu bewältigenden Aufgabe nicht vertraut ist. Arbeitet man mit Computern, ist der Computer das perfekte Testobjekt.

Anwendungen als gewöhnliche Arbeitsabläufe verstehen

Ein Computer verhält sich genauso wie die Grundschullehrerin in meinem Beispiel aus dem vorherigen Abschnitt. Wenn Sie eine Anwendung schreiben, schreiben Sie einen Prozess auf, der eine vom Computer auszuführende Schrittfolge definiert, um irgendeine von Ihnen vorgegebene Aufgabe zu erfüllen. Lassen Sie einen Schritt aus, werden die Ergebnisse nicht wie erwartet. Der Computer versteht nicht, was Sie meinen, oder, dass Sie dachten, dass er manche Sachen automatisch macht. Der Computer weiß nur, dass Sie ihm einen Prozess vorgegeben haben und dass er diesen Prozess ausführen soll.

Computer nehmen alles wörtlich

Die Leute gewöhnen sich wahrscheinlich an die Arbeitsabläufe, die Sie für sie erstellen. Sie kompensieren automatisch Mängel in Ihrem Ablauf oder machen sich zu den Dingen, die Sie vergessen haben, Notizen. Mit anderen Worten: Die Leute kompensieren Probleme der Prozesse, die Sie erstellt haben.

Wenn Sie mit der Programmierung beginnen, werden Sie frustriert sein, da Computer Aufgaben präzise ausführen und Ihre Anweisungen wörtlich nehmen. Sagen Sie beispielsweise dem Computer, dass ein bestimmter Wert gleich 5 sein soll, wird der Computer nach einem Wert suchen, der exakt 5 ist. Ein Mensch könnte eine 4,9 sehen und wissen, dass das doch gut genug ist. Aber Computer denken nicht so. Ein Computer sieht den Wert 4,9 und entscheidet, dass dieser nicht genau gleich 5 ist. Kurz gefasst sind Computer unflexibel, nicht intuitiv und einfallslos. Wenn Sie einen Arbeitsablauf für einen Computer definieren, wird der Computer jedes Mal präzise das tun, was Sie von ihm verlangen, und Ihren Prozess nie ändern oder entscheiden, dass Sie ihm ja eigentlich etwas anderes aufgetragen hatten.

Was ist eine Anwendung eigentlich

Wie schon erwähnt, bieten Anwendungen die Möglichkeit, menschliche Ideen so auszudrücken, dass ein Computer sie verstehen kann. Um dieses Ziel zu erreichen, benötigt die Anwendung einen oder mehrere Arbeitsabläufe, die dem Computer sagen, wie Aufgaben zur Verarbeitung und Anzeige von Daten auszuführen sind. Sie sehen am Bildschirm zum Beispiel Text in Ihrem Textverarbeitungsprogramm. Aber damit Sie diese Informationen sehen können, braucht der Computer Vorgaben, wie er Daten von der Festplatte lesen, diese in eine Form bringen, die Sie verstehen können, und schließlich am Bildschirm anzeigen kann. Die folgenden Abschnitte beschreiben die Eigenschaften einer Anwendung detaillierter.

Computer haben ihre eigene Sprache

Die menschliche Sprache ist komplex und schwierig zu verstehen. Sogar Anwendungen wie Siri haben nur sehr begrenzte Möglichkeiten zu verstehen, was Sie sagen. Mit der Zeit haben Computer gelernt, menschliche Sprache als Eingabe zu verarbeiten und bestimmte gesprochene Wörter als Befehle zu interpretieren. Aber Computer verstehen die menschliche Sprache im Wesentlichen immer noch nicht so richtig. Die Schwierigkeit der menschlichen Sprache kann man gut am Beispiel der Arbeit von Anwälten darstellen. Wenn Sie sich ein Dokument in Juristendeutsch anschauen, liest sich das wie das reinste Kauderwelsch. Ziel dieser Sprache ist es jedoch, keinerlei Spielraum für Interpretationen zu lassen. Anwälte haben trotzdem selten Erfolg, dieses Ziel vollständig zu erreichen, da die menschliche Sprache einfach zu ungenau ist.

Wenn man sich nun anschaut, was Sie aus den vorigen Abschnitten dieses Kapitels wissen, könnten Computer sich niemals auf die menschliche Sprache verlassen, um die von Ihnen definierten Prozesse zu verstehen. Computer nehmen alles wörtlich, sodass Sie völlig unvorhersehbare Ergebnisse bekommen würden, wenn Sie Anwendungen in menschlicher Sprache schreiben würden. Darum verwenden Menschen spezielle Sprachen, Programmiersprachen genannt, um mit Computern zu kommunizieren. Mit diesen speziellen Sprachen können Sie Prozesse definieren, die sowohl präzise als auch durch Computer und Menschen gleichermaßen zu verstehen sind.

Computer sprechen eigentlich gar keine Sprache. Sie verwenden Binärcodes, um Schalter intern umzulegen und mathematische Berechnungen durchzuführen. Computer verstehen noch nicht einmal Buchstaben – sie verstehen nur Zahlen. Eine spezielle Anwendung macht aus der computerspezifischen Sprache, die Sie zum Definieren von Arbeitsabläufen benötigen, Binärcodes. Aber für die Zwecke dieses Buches brauchen Sie sich nicht allzu viel Gedanken zu machen über die internen Details, wie Computer auf der Binärebene funktionieren. Trotzdem ist es interessant zu wissen, dass Computer in Form von Mathematik und Zahlen kommunizieren, und nicht wirklich mit einer Sprache.

Den Menschen helfen, mit dem Computer zu sprechen

Es ist wichtig, dass Sie sich immer des Zwecks einer Anwendung bewusst sind, während Sie sie schreiben. Eine Anwendung hilft den Menschen, sich mit dem Computer auf bestimmte Weise zu unterhalten. Jede Anwendung benutzt irgendwelche Daten, die der Anwendung als Eingabe übergeben, gespeichert, verändert und ausgegeben werden, sodass die Menschen, die die Anwendung benutzen, ein gewünschtes Ergebnis bekommen. Ob es sich nun um ein Spiel oder eine Tabellenkalkulation handelt, die Grundidee ist dieselbe. Computer arbeiten mit Daten, die ihnen von Menschen zur Verfügung gestellt werden, um ein gewünschtes Ergebnis zu erhalten.

Wenn Sie eine Anwendung programmieren, entwickeln Sie eine neue Methode, wie Menschen mit Computern kommunizieren können. Der von Ihnen neu erstellte Ansatz ermöglicht es anderen Menschen, Daten auf neue Art zu betrachten. Die Kommunikation zwischen Mensch und Computer sollte so einfach sein, dass das Programm eigentlich in den Hintergrund tritt. Denken Sie an Programme, die Sie in der Vergangenheit verwendet haben. Die besten Anwendungen helfen Ihnen dabei, sich auf die Daten zu konzentrieren, mit denen Sie arbeiten. Zum Beispiel fesselt Sie ein Spiel nur dann, wenn Sie sich darauf konzentrieren können, einen Planeten zu retten oder ein Raumschiff zu fliegen, und nicht auf die Anwendung, die Ihnen das Spielen ermöglicht.

Einer der besten Wege, an die Entwicklung einer Anwendung heranzugehen, ist, sich anzuschauen, wie andere Leute Programme schreiben. Aufzuschreiben, was Sie an anderen Programmen mögen oder nicht so gut finden, hilft Ihnen herauszufinden, wie Ihre Programme aussehen und funktionieren sollen. Folgende Dinge können Sie sich fragen, wenn Sie mit diesen Anwendungen arbeiten:

Was finde ich an der Anwendung verwirrend?

Welche Funktionen waren einfach zu bedienen?

Welche Funktionen waren schwierig zu verwenden?

Wie hat mir die Anwendung geholfen, mit meinen Daten zu arbeiten?

Wie würde ich die Arbeit mit den Daten einfacher gestalten?

Was möchte ich mit meiner Anwendung besser machen, was das vorhandene Programm nicht kann?

Professionelle Entwickler stellen noch viele andere Fragen bei der Erstellung einer Anwendung, aber diese Fragen sind für den Anfang gut, da sie Ihnen einen Denkanstoß geben sollen, dass Anwendungen ein Hilfsmittel für Menschen sind, mit dem Computer zu sprechen. Wenn Sie sich jemals über ein Programm geärgert haben, wissen Sie schon, wie sich andere Leute fühlen werden, wenn Sie nicht die richtigen Fragen vor der Programmierung Ihrer Anwendung stellen. Kommunikation ist der wichtigste Baustein jeder Anwendung, die Sie erstellen.

Sie können auch schon mal damit beginnen, über die Art und Weise, wie Sie arbeiten wollen, nachzudenken. Schreiben Sie Prozesse für die Dinge auf, die Sie so tun. Es ist sinnvoll, den jeweiligen Prozess in Schritte einzuteilen und zu jedem Schritt alles aufzuschreiben, was Ihnen dazu einfällt. Wenn Sie damit fertig sind, bitten Sie jemand anders, den Prozess auszuprobieren, damit Sie sehen, ob er wirklich funktioniert. Es wird Sie sicherlich überraschen, dass Sie trotz intensiver Bemühungen sehr schnell Schritte vergessen können.

Das schlechteste Programm der Welt beginnt normalerweise mit einem Programmierer, der nicht weiß, was die Anwendung tun soll, warum sie etwas Besonderes ist, welche Aufgabe sie erfüllen soll oder für wen sie ist. Wenn Sie eine Anwendung schreiben, versichern Sie sich, dass Sie wissen, warum Sie sie erstellen und was Sie damit erreichen wollen. Einen Plan in der Tasche zu haben, hilft dabei, den Spaß am Programmieren nicht zu verlieren. Während Sie an Ihrem neuen Programm arbeiten, wird sich ein Ziel nach dem anderen erfüllen, bis die Anwendung fertig ist. Diese können Sie dann Ihren Freunden zeigen (die natürlich alle denken, wie cool es ist, dass Sie dieses Programm geschrieben haben).

Warum Python so cool ist

Heutzutage gibt es viele Programmiersprachen. Tatsächlich kann ein Student an der Universität ein ganzes Semester lang Computersprachen studieren und kennt sie dann immer noch nicht alle. (Genau das habe ich während meiner Studienzeit getan.) Eigentlich könnte man meinen, dass Programmierer mit all diesen Programmiersprachen zufrieden sein könnten und einfach eine auswählen, um mit dem Computer zu sprechen. Aber trotzdem denken sie sich immer wieder neue aus.

Programmierer denken sich aus gutem Grund neue Sprachen aus. Jede Sprache hat etwas Besonderes zu bieten – etwas, dass sie außergewöhnlich gut kann. Außerdem entwickeln sich Programmiersprachen auch weiter, um mit dem Fortschritt der Computertechnologie Schritt zu halten. Da das Schreiben einer Anwendung sich hauptsächlich um effiziente Kommunikation dreht, können die meisten Programmierer mehrere Sprachen, sodass sie sich die richtige Sprache für eine bestimmte Aufgabe heraussuchen können. Die eine Sprache ist vielleicht besser geeignet, Daten aus einer Datenbank abzurufen, während Sie mit einer anderen besonders gut Benutzeroberflächen erstellen können.

Wie bei jeder anderen Programmiersprache auch macht Python einige Dinge außergewöhnlich gut und Sie sollten wissen, welche Dinge das sind, bevor Sie Python einsetzen. Sie werden vielleicht verblüfft sein, welche wirklich coolen Sachen Sie mit Python machen können. Bei der Verwendung einer Programmiersprache hilft es, ihre Stärken und Schwächen zu kennen. Außerdem können Sie sich Frust ersparen, wenn Sie die Sprache nicht für Dinge verwenden, die man damit nicht so gut machen kann. Die folgenden Abschnitte helfen Ihnen dabei, solche Entscheidungen für Python zu treffen.

Warum man Python verwenden sollte

Die meisten Programmiersprachen werden mit bestimmten Zielen im Hinterkopf erfunden. Diese Ziele helfen dabei, die Charakteristika der Sprache zu definieren und zu bestimmen, was man mit der Sprache tun können soll. Es ist nicht wirklich möglich, eine Programmiersprache zu erfinden, die alles kann, da Programmierer miteinander in Konflikt stehende Ziele und Anforderungen bei der Programmierung haben. Bei Python war das Hauptziel, eine Programmiersprache zu erfinden, die Programmierer effizient und produktiv macht. Mit diesem Grundgedanken im Hinterkopf zähle ich im Folgenden ein paar Gründe auf, warum Sie Python zur Anwendungsentwicklung benutzen sollten:

Kürzere Entwicklungszeiten: Python-Code ist normalerweise zwei bis zehn Mal kürzer als vergleichbarer Code, der mit Sprachen wie C/C++ und Java geschrieben wurde. Das bedeutet, dass Sie weniger Zeit für die Erstellung Ihres Programms brauchen, aber mehr Zeit dafür haben, es zu benutzen.

Einfach zu lesen: Eine Programmiersprache ist wie jede andere Sprache – Sie müssen sie lesen können, damit Sie verstehen, was sie macht. Python-Code ist tendenziell einfacher zu lesen als mit anderen Sprachen geschriebener Code. Das bedeutet, dass Sie weniger Zeit brauchen, den Code zu interpretieren, und mehr Zeit dafür haben, wichtige Änderungen vorzunehmen.

Schneller zu erlernen: Die Erfinder von Python wollten eine einfacher zu erlernende Programmiersprache mit weniger sonderbaren Regeln erschaffen. Im Grunde wollen Programmierer ja Anwendungen schreiben und nicht obskure und schwierige Sprachen lernen.

Sie sollten wissen, dass Python zwar eine beliebte Sprache ist, aber längst nicht die beliebteste. Tatsächlich belegt sie nur Rang acht auf Seiten wie TIOBE (www.tiobe.com/index.php/content/paperinfo/tpci/index.html), eine Organisation, die (unter anderem) Nutzungsstatistiken verfolgt. Wenn Sie eine Sprache erlernen wollen, nur um einen Job zu bekommen, ist Python eine gute Wahl, aber C/C++, Java oder Visual Basic sind da die besseren Alternativen. Wählen Sie eine Sprache aus, die Sie mögen und die Ihren Anwendungsentwicklungsanforderungen entspricht, aber wählen Sie sie auch danach aus, was Sie damit erreichen wollen. Python war 2007 und 2010 die Sprache des Jahres und 2011 die viertbeliebteste Sprache. Also ist sie gar nicht schlecht, wenn Sie einen Job suchen, aber nicht unbedingt die beste Wahl. Es wird Sie vielleicht überraschen, dass viele Universitäten in den USA Python verwenden, um den Studenten Programmieren beizubringen, und dass Python dafür die beliebteste Sprache geworden ist. Wenn Sie mehr darüber erfahren wollen, lesen Sie am besten meinen (englischen) Blogeintrag http://blog.johnmuellerbooks.com/2014/07/14/python-as-a-learning-tool.

Wie Sie persönlich von Python profitieren können

Letztendlich können Sie jede Programmiersprache dazu verwenden, jede beliebige Anwendung zu schreiben. Setzen Sie aber die falsche Programmiersprache für eine Aufgabe ein, werden Sie die Arbeit daran hassen und das Ergebnis wird langsam und fehleranfällig sein – aber Sie würden die Aufgabe irgendwie lösen können. Natürlich wollen die meisten von uns schreckliche und qualvolle Erfahrungen vermeiden. Also sollte man wissen, welche Anwendungen die Leute normalerweise mit Python schreiben (auch wenn es Leute gibt, die Python auch für andere Zwecke einsetzen):

Anwendungsbeispiele erstellen: Entwickler müssen oft einen Prototyp, ein erstes Beispiel für eine Anwendung, erstellen, bevor sie die Ressourcen aufwenden, das eigentliche Programm zu schreiben. Da in Python Produktivität besonders groß geschrieben wird, können Sie es gut verwenden, um schnell Prototypen für eine Anwendung zu erstellen.

Browser-basierte Skripte programmieren: Auch wenn JavaScript wahrscheinlich die beliebteste Sprache für Browser-basierte Anwendungsskripte ist, folgt ihr Python doch dicht auf dem zweiten Platz. Python bietet Funktionen an, die JavaScript nicht hat (für weitere Informationen finden Sie hier einen Vergleich: https://blog.glyphobet.net/essay/2557) und durch seine hohe Effizienz können Sie Browser-basierte Programme schneller erstellen (ein klarer Vorteil in der heutigen schnelllebigen Welt).

Mathematische, naturwissenschaftliche und ingenieurstechnische Anwendungen entwerfen: Besonders interessant ist, dass Python Ihnen Zugriff auf ein paar wirklich coole Bibliotheken bietet, um mathematische, naturwissenschaftliche und ingenieurstechnische Programme einfacher zu schreiben. Die zwei beliebtesten Bibliotheken sind NumPy (www.numpy.org) und SciPy (www.scipy.org). Mit diesen Bibliotheken können Sie solche Anwendungen wesentlich schneller schreiben.

Mit XML arbeiten: Die eXtensible Markup Language (XML) ist die Grundlage für die meisten Datenverwaltungslösungen vieler Internet- und Desktopanwendungen. Bei anderen Sprachen wurde XML eher dazugebastelt, während es bei Python einen Platz in der ersten Reihe hat. Wenn Sie beispielsweise mit einem Webdienst arbeiten müssen, der wichtigsten Methode, Informationen über das Internet auszutauschen (oder irgendeiner anderen XML-intensiven Anwendung), ist Python eine gute Wahl.

Mit Datenbanken interagieren: Die Industrie ist sehr von Datenbanken abhängig. Python ist nicht wirklich eine Abfragesprache wie die Structured Query Language (SQL) oder Language Integrated Query (LINQ), aber man kann mit ihr sehr gut mit Datenbanken arbeiten. Sie macht das Herstellen von Verbindungen zur Datenbank und die Arbeit mit den Daten ziemlich einfach.

Benutzeroberflächen erstellen: Bei Python haben Sie nicht so wie bei anderen Sprachen wie C# einen integrierten Designer, wo Sie Elemente aus einer Palette mit Werkzeugen auf eine Benutzeroberfläche ziehen können. Python bietet jedoch eine große Auswahl an Frameworks für grafische Benutzeroberflächen (englisch: Graphical User Interfaces, GUIs) – Erweiterungen, die die Erstellung von Benutzeroberflächen viel einfacher machen (mehr Informationen finden Sie unter https://wiki.python.org/moin/GuiProgramming). Manche dieser Frameworks liefern Designer mit, die die Erstellung von Benutzeroberflächen vereinfachen. Der Punkt ist, dass Python nicht nur eine Methode zur Erstellung einer Benutzeroberfläche anbietet – Sie können sich die Methode aussuchen, die Ihren Bedürfnissen am besten gerecht wird.

Welche Organisationen verwenden Python?

Python erfüllt die Aufgaben, für die es konzipiert wurde, ziemlich gut. Und das ist auch der Grund, warum viele große Firmen und Organisationen Python zur Programmierung von Anwendungen (allgemein zur Entwicklung) verwenden. Ein Grund mehr, Python zu nutzen, da diese Organisationen die Sprache unterstützen und Geld dafür ausgeben, sie zu verbessern. Im Folgenden finden Sie eine Liste von Organisationen, die Python häufig einsetzen und auch, wofür sie sie einsetzen:

Alice Educational Software – Carnegie Mellon University (www.cmu.edu/corporate/news/2007/features/alice.shtml): Lernsoftware

Fermilab (www.fnal.gov): Wissenschaftliche Anwendungen

Go.com (http://go.com): Browser-basierte Anwendungen

Google (www.google.de): Suchmaschine

Industrial Light & Magic (www.ilm.com, ja, genau, die Firma, die die Special Effects für Star Wars gemacht hat!): Alles, was so an Programmierung anfällt.

Lawrence Livermore National Library (www.llnl.gov): Wissenschaftliche Anwendungen

National Space and Aeronautics Administration (NASA) (www.nasa.gov): Wissenschaftliche Anwendungen

New York Stock Exchange (https://nyse.nyx.com): Browser-basierte Anwendungen

Redhat (www.redhat.com): Installationswerkzeuge für Linux

Yahoo! (www.yahoo.com): Teile von Yahoo!-Mail

YouTube (www.youtube.com): Grafikengine

Zope (www.zope.com): Plattform zur Erstellung von Webanwendungen (Content Management Systeme)

Dies sind nur ein paar der vielen Organisationen, die Python intensiv nutzen. Eine Liste mit weiteren Firmen finden Sie hier: www.python.org/about/success. Die Anzahl der Erfolgsgeschichten ist so riesig geworden, dass diese Liste wahrscheinlich auch nicht vollständig ist und man sie in Kategorien einteilen musste, damit sie übersichtlicher wird.

Nützliche Python-Programme finden

Vielleicht haben Sie auf Ihrem Computer schon eine Anwendung, die in Python geschrieben wurde, und wissen es noch nicht einmal. Python wird in der Industrie in sehr vielen Anwendungsbereichen eingesetzt. Die Programme reichen von kleinen Konsolenanwendungen bis hin zu ausgewachsenen CAD/CAM-Plattformen. Manche Programme laufen auf mobilen Geräten, während andere auf großen Firmenservern ausgeführt werden. Zusammengefasst gibt es nichts, was Sie mit Python nicht tun können, aber es hilft, sich anzuschauen, was andere so damit gemacht haben. Es gibt viele Seiten im Internet, wo Sie das nachschauen können, aber am besten schauen Sie hier nach: https://wiki.python.org/moin/Applications.

Als Python-Programmierer wollen Sie natürlich auch wissen, welche Entwicklungswerkzeuge es für Python gibt, die Ihnen die Arbeit erleichtern. Ein Entwicklungswerkzeug bietet Ihnen einen gewissen Automatisierungsgrad beim Schreiben von Programmen, die dem Computer sagen, was er zu tun hat. Mit einem oder mehreren Entwicklungswerkzeugen müssen Sie weniger tun, um eine funktionierende Anwendung zu erstellen. Zwar geben Entwickler gerne die Liste ihrer Lieblingswerkzeuge preis, aber eine richtig umfangreiche Liste mit Werkzeugen unterteilt in Kategorien finden Sie hier: www.python.org/about/apps.

Natürlich beschreibt dieses Kapitel auch ein paar Werkzeuge, wie NumPy und SciPy (zwei naturwissenschaftliche Bibliotheken). Im restlichen Buch werden auch noch ein paar andere Tools erwähnt. Merken Sie sich am besten Ihre Lieblingswerkzeuge für den späteren Einsatz.

Python mit anderen Sprachen vergleichen

Es ist gefährlich, eine Sprache mit einer anderen zu vergleichen, da die Auswahl einer Sprache Geschmackssache und persönliche Vorliebe und keine exakte Wissenschaft ist. Also, bevor ich von den vehementen Verteidigern der anderen Sprachen attackiert werde, sollten Sie wissen, dass auch ich eine Vielzahl Sprachen verwende und es bei allen eine gewisse Überschneidung gibt. Die beste Sprache der Welt gibt es nicht, nur die beste Sprache für eine bestimmte Anwendung. Denken Sie daran, wenn Sie die folgenden Abschnitte lesen. Diese bieten einen Überblicksvergleich zwischen Python und anderen Sprachen. (Vergleiche mit weiteren Sprachen finden Sie unter https://wiki.python.org/moin/LanguageComparisons).

C#

Viele Leute behaupten, dass Microsoft einfach Java abgekupfert hat, um C# zu erstellen. Dennoch hat C# ein paar Vorteile gegenüber Java (und auch ein paar Nachteile). Die (unangefochtene) Hauptabsicht, C# zu entwickeln, war es, eine bessere C/C++-Sprache zu schaffen – eine, die leichter zu erlernen und zu verwenden ist. Aber wir wollten ja hier über C# und Python diskutieren. Vergleicht man Python mit C#, bietet Python die folgenden Vorteile:

Deutlich einfacher zu erlernen

Der Code ist schlanker (prägnanter)

Vollständig quelloffen

Bessere Plattformunabhängigkeit

Verwendung verschiedener Entwicklungsumgebungen sehr einfach möglich

Einfacher mit Java und C/C++ zu erweitern

Verstärkte Unterstützung für wissenschaftliche Projekte und Ingenieursaufgaben

Java

Lange Jahre suchten Programmierer nach einer Sprache, mit der sie ein Programm nur einmal schreiben müssen und dann überall ausführen können. Java ist dafür gedacht, auf jedem Betriebssystem gut zu funktionieren. Um dieses Wunder möglich zu machen, bedient es sich einiger Tricks, über die Sie weiter hinten in diesem Buch noch etwas erfahren werden. Was Sie für den Moment nur wissen müssen, ist, dass Java dermaßen erfolgreich damit war, überall gut zu funktionieren, dass andere Sprachen ihm nacheifern wollten (mit unterschiedlichem Erfolg). Trotzdem hat Python gegenüber Java ein paar wichtige Vorteile:

Deutlich einfacher zu erlernen

Der Code ist schlanker (prägnanter)

Erweitertes Variablenmodell (Variablen sind temporäre Aufbewahrungsorte für Daten im Computerspeicher). Basierend auf den Anwendungsbedürfnissen können die Variablen verschiedene Arten von Daten während der Laufzeit enthalten (auch Dynamische Typisierung genannt).

Kürzere Entwicklungszeiten

Perl

Perl war ursprünglich ein Akronym für Practical Extraction and Report Language (was so viel heißt wie zweckmäßige Extraktions- und Berichtssprache). Heutzutage nennen die Leute sie einfach nur noch Perl – Punkt. Die Wurzeln von Perl erkennt man heute noch daran, dass es eine überragende Vorstellung bei der Abfrage von Daten aus einer Datenbank und deren Präsentation in Berichtsform abgibt. Natürlich wurde Perl so erweitert, dass es sehr viel mehr als das kann – Sie können damit alle möglichen Anwendungen schreiben. (Ich habe es zum Beispiel zum Schreiben einer Webdienst-Anwendung verwendet.) Im Vergleich mit Python werden Sie feststellen, dass Python in folgenden Dingen besser ist:

Einfacher zu erlernen

Einfacher zu lesen

Besserer Schutz von Daten

Bessere Java-Integration

Weniger plattformspezifische Eigenheiten

2

Sich ein eigenes Python zulegen

In diesem Kapitel

Besorgen Sie sich Ihr eigenes Python

Installieren Sie Python

Suchen und benutzen Sie Python auf Ihrem System

Vergewissern Sie sich, dass Ihre Installation wie gewünscht funktioniert

Für das Schreiben von Anwendungen brauchen Sie andere Anwendungen, es sei denn, Sie möchten sich wirklich in die tiefsten Gefilde Ihres Rechners begeben und Programme in Maschinencode schreiben – wenn überhaupt möglich, ist das ein ausgesprochen schwieriges Unterfangen, das sogar eingefleischte Programmierer scheuen würden. Wenn Sie eine Anwendung mit der Programmiersprache Python schreiben wollen, brauchen Sie ein Programm dafür. Diese Programme helfen Ihnen bei der Arbeit mit Python, indem sie Python-Code erzeugen, Ihnen bei Bedarf hilfreiche Informationen zur Verfügung stellen und den von Ihnen geschriebenen Code ausführen. Dieses Kapitel unterstützt Sie dabei, sich die Python-Software herunterzuladen, sie auf Ihrer Festplatte zu installieren und die installierten Anwendungen zu finden, sodass Sie Ihre Installation testen können.

Die gewünschte Version herunterladen

Jede Plattform (eine Kombination aus Computer-Hardware und Betriebssystem) hat spezielle Regeln, die sie befolgt, wenn sie Anwendungen ausführt. Die Python-Anwendung versteckt diese Details vor Ihnen. Sie schreiben Code, der auf jeder Plattform, die Python unterstützt, läuft, und die Python-Software übersetzt den Code in etwas, dass die Plattform verstehen kann. Damit diese Übersetzung jedoch ausgeführt werden kann, müssen Sie eine Python-Software haben, die auf Ihrer speziellen Plattform läuft. Python unterstützt die folgenden Betriebssysteme:

Application System 400 (AS/400)

BeOS

Hewlett-Packard Unix (HP-UX)

Linux

Mac OS X (wird mit dem Betriebssystem installiert)

Microsoft Disk Operating System (MS DOS)

MorphOS

Operating System 2 (OS/2)

Operating System 390 (OS/390) und z/OS

PalmOS

Playstation

Psion

QNX

RISC OS (ehemals Acorn)

Series 60

Solaris

Virtual Memory System (VMS)

Windows 32 Bit (XP und später)

Windows 64 Bit

Windows CE/Pocket PC

Wow, so viele verschiedene Betriebssysteme! Die Beispiele in diesem Buch wurden auf Windows-, Mac-OS-X- und Linux-Plattformen getestet. Trotzdem könnten die Beispiele auch unter den anderen Betriebssystemen laufen, da sie keinen plattformspezifischen Code enthalten. Schreiben Sie mir doch eine E-Mail an John@JohnMuellerBooks.com (bitte auf Englisch), ob die Beispiele auch auf Ihrem System, das kein Windows, Mac OS X oder Linux ist, funktionieren. Die aktuelle Python-Version zum Zeitpunkt des Schreibens dieses Buches ist 3.4.2 (im Oktober 2014 erschienen). Ich beschreibe alle Python-Aktualisierungen in meinem Blog unter http://blog.johnmuellerbooks.com. Sie finden dort auch die Antworten auf Ihre Python-Fragen zum Buch.

Damit Sie die richtige Version für Ihr System finden, müssen Sie unter https://www.python.org/downloads/release/python-342 schauen. Der tatsächliche Download-Bereich findet sich ganz unten auf der Seite, also müssen Sie sich bis dahin vorscrollen. Sie sollten eine Webseite ähnlich der in Abbildung 2.1 sehen. Der hauptsächliche Teil dieser Seite enthält Links zu Windows-, Mac-OS-X- und Linux-Downloads. Diese Links stellen Ihnen die in diesem Buch verwendete Standardinstallation zur Verfügung. Die plattformspezifischen Links auf der linken Seite der Webseite bieten Ihnen alternative Python-Pakete, wenn Sie diese mal benötigen sollten. Brauchen Sie beispielsweise einen umfangreicheren Editor als den aus dem Standard-Python-Paket, finden Sie diesen in einem der alternativen Pakete.

Brauchen Sie Python für ein anderes System als die dort aufgeführten, können Sie auf den Link OTHER PLATFORMS (weitere Systeme) am Ende der Seite unter DOWNLOADS klicken. Sie sehen dann eine Liste weiterer Python-Installationsdateien für andere Betriebssysteme, wie in Abbildung 2.2 gezeigt. Viele dieser Python-Versionen werden von Freiwilligen gewartet und nicht von den Leuten, die die Versionen für Windows, Mac OS X und Linux programmieren. Kontaktieren Sie diese Menschen ruhig, wenn Sie Fragen zur Installation haben, denn sie wissen mit Sicherheit am besten, wie Sie Python auf Ihrem System installieren können.

Abbildung 2.1: Die Download-Seite von Python enthält Links für alle möglichen Systeme.

Abbildung 2.2: Freiwillige haben Python für alle möglichen Systeme verfügbar gemacht.

Python installieren

Nachdem Sie Python heruntergeladen haben, wird es Zeit, es auf Ihrem System zu installieren. Die heruntergeladene Datei enthält alles, was Sie für den Anfang brauchen:

Einen Python-Interpreter

Hilfedateien (Dokumentation)

Zugriff auf die Kommandozeile

Die Integrierte Entwicklungsumgebung IDLE (Integrated DeveLopment Enviroment)

Ein Programm für die Deinstallation (nur bei Betriebssystemen, die es brauchen)

Dieses Buch nimmt an, dass Sie eines der Standard-Python-Setups unter www.python.org/downloads/release/python-342 verwenden. Die folgenden Abschnitte beschreiben, wie Sie Python auf den drei in diesem Buch berücksichtigten Systemen, Windows, Mac OS X und Linux, installieren.

Mit Windows arbeiten

Der Installationsprozess auf einem Windows-System folgt dem gleichen Schema, das auch bei anderen Anwendungen verwendet wird. Die Hauptaufgabe besteht erst einmal darin, die heruntergeladene Datei zu finden, damit Sie mit dem Installationsvorgang beginnen können. Das folgende Vorgehen sollte für alle Windows-Systeme gleich gut funktionieren, unabhängig davon, ob Sie ein 32-Bit- oder ein 64-Bit-System haben.

1. Suchen Sie die heruntergeladene Datei auf Ihrem System.

Der Name der Datei kann sich ändern, aber normalerweise heißt sie python-3.4.2.msi bei 32-Bit-Systemen und python-3.4.2.amd64.msi bei 64-Bit-Systemen. Die Versionsnummer ist ein Teil des Dateinamens. In diesem Fall bezieht sich der Name auf Version 3.4.2, der Version, die für dieses Buch verwendet wird.

2. Doppelklicken Sie auf die Installationsdatei.

(Es könnte sein, dass ein Dialogfenster DATEI ÖFFNEN – SICHERHEITSWARNUNG erscheint, das Sie fragt, ob Sie diese Datei ausführen möchten. Klicken Sie auf AUSFÜHREN, wenn Sie dieses Dialogfenster sehen.) Es erscheint ein Dialogfenster so ähnlich wie das in Abbildung 2.3. Das exakte Aussehen des Dialogfensters hängt davon ab, welche Version des Python-Installationsprogramms Sie heruntergeladen haben.

3. Wählen Sie aus, für wen Sie das Programm installieren wollen (dieses Buch verwendet die Standardeinstellung INSTALL FOR ALL USERS, also für alle Benutzer installieren).

Der Installationsassistent bittet Sie nun, wie in Abbildung 2.4 zu sehen, den Namen eines Installationsverzeichnisses für Python anzugeben. Sie sparen sich Zeit und Aufwand, wenn Sie das schon vorgegebene Verzeichnis nehmen. Aber natürlich können Sie Python installieren, wo immer Sie möchten.

Abbildung 2.3: Der Installationsvorgang beginnt mit der Frage, wer Zugriff auf Python haben soll.

Abbildung 2.4: Wählen Sie einen Installationsort für Ihre Python-Version aus.

Die Windows-Ordner \Programme (dies ist nur ein Verweis; dieser zeigt auf den tatsächlichen Ordner Program Files) oder Programme (x86) (Verweis auf \Program Files (x86)) zu verwenden, ist aus zwei Gründen problematisch. Zum einen enthalten die eigentlichen Ordnernamen Leerzeichen, sodass man auf sie aus der Anwendung heraus schwieriger zugreifen kann. Zum anderen erfordern diese Ordner normalerweise Zugriff durch einen Benutzer mit Administratorrechten, sodass Sie sich ständig mit der Benutzerkontensteuerung von Windows herumschlagen müssen, wenn Sie Python in einem der beiden installieren.

4. Geben Sie, wenn nötig, den Namen des Zielordners ein und klicken Sie auf NEXT (Weiter).

Python bittet Sie nun, die Installation an Ihre Bedürfnisse anzupassen, wie in Abbildung 2.5 zu sehen.

Sie können später Zeit sparen, wenn Sie die Option ADD PYTHON.EXE TO PATH aktivieren. Mit dieser Funktion können Sie Python bequem über die Kommandozeile ausführen. Machen Sie sich über den Gebrauch dieser Funktion jetzt nicht allzu viele Gedanken, aber es ist schon gut, wenn diese installiert ist. Das Buch geht davon aus, dass Sie dieses Feature aktiviert haben. Machen Sie sich auch über die anderen Features, die Sie in Abbildung 2.5 sehen, keine Gedanken. Diese sind alle standardmäßig aktiviert und somit steht Ihnen nach der Installation der maximale Funktionsumfang von Python zur Verfügung.

Abbildung 2.5: Passen Sie die Installation an Ihre Bedürfnisse an.

5. (Optional) Klicken Sie auf die [Pfeil_u]-Schaltfläche neben der Option ADD PYTHON.EXE TO PATH und wählen Sie dann die Option WILL BE INSTALLED ON LOCAL DRIVE (Von Arbeitsplatz ausführen) aus.

6. Klicken Sie auf NEXT (Weiter).

Nun startet der Installationsprozess. Zwischendurch wird Ihnen vielleicht ein Dialogfenster der Benutzerkontensteuerung angezeigt, das Sie fragt, ob Sie die Installation durchführen wollen. Wenn Sie dieses Dialogfenster sehen, klicken Sie einfach auf JA. Die Installation wird fortgesetzt und dann sehen Sie ein Dialogfenster, das Ihnen die erfolgreiche Installation bestätigt.

7. Klicken Sie auf FINISH (Beenden).

Nun ist Python bereit für die erste Nutzung.

Mit dem Mac arbeiten

Auf Ihrem Mac-Betriebssystem ist Python wahrscheinlich schon installiert. Normalerweise hat diese Version jedoch schon ein paar Jährchen auf dem Buckel – je nachdem, wie alt die Version Ihres Betriebssystems ist. Für die Zwecke dieses Buches ist diese Version jedoch völlig ausreichend. Sie werden mit dem Buch die Grenzen der Python-Programmiertechnologie nicht bis ans Limit ausreizen, sondern einfach mit Python ganz entspannt Ihre ersten Programmiererfahrungen sammeln.

Die Leopard-Version von OS X (10.5) enthält eine ziemlich alte Python-Version 2.5.1. Gerade diese Version enthält nicht die Integrierte Entwicklungsumgebung IDLE. Ein paar Beispiele in diesem Buch werden daher mit dieser Version nicht richtig funktionieren. Der (englische) Artikel unter https://wiki.python.org/moin/MacPython/Leopard verrät Ihnen mehr darüber, wie Sie mit diesem Problem umgehen können. Die aktuellste Version von Mac OS X zur Zeit der Fertigstellung dieses Buchs ist Yosemite (oder 10.10) und enthält Python 2.7, mit dem Sie die Beispiele in diesem Buch gut durcharbeiten können.

Je nachdem, wie Sie Python nutzen, möchten Sie Ihre Python-Version vielleicht irgendwann aktualisieren. Dazu gehört auch, dass Sie die Tools der GNU Compiler Collection (GCC) installieren, sodass Python auf die internen Ressourcen, die es braucht, Zugriff hat. Die folgenden Schritte helfen Ihnen, eine neue Python-Version auf Ihrem Mac-OS-X-System zu installieren.

1. Öffnen Sie mit Ihrem Browser die Seite www.python.org/downloads/release/python-342.

Hier finden Sie Informationen über die neueste Python-Version, wie in Abbildung 2.1 zu sehen.

2. Klicken Sie auf die für Ihr OS-X-System geeignete Version:

a. Die Python 3.4.2 Mac OS X 32-bit i386 / PPC-Installationsdatei für 32-Versionen für Mac OS X ab Version 10.5 (für Intel-Prozessoren und Power PC-Prozessoren geeignet)

b. Die Python 3.4.2 Mac OS X 64-bit/32-bit-Installationsdatei für 64-Bit- und 32-Bit-Versionen für Mac OS X ab Version 10.6 und Intel-Prozessoren

Die Python-Installationsdatei wird heruntergeladen. Sie müssen etwas Geduld mitbringen: Der Download benötigt mehrere Minuten. Die meisten Webbrowser bieten die Möglichkeit, den Download-Prozess zu überwachen, sodass Sie schnell sehen, wie lange das Herunterladen dauert.

3. Doppelklicken Sie auf die heruntergeladene pkg-Datei.

Diese heißt für Version 3.4.2 ab Version 10.6 zum Beispiel python-3.4.2-macosx10.6.pkg, aber der Name kann je nach Version unterschiedlich sein. Es erscheint ein Willkommen-Dialog, der Ihnen etwas über diese spezielle Python-Version verrät.

4. Klicken Sie dreimal auf FORTFAHREN.

Das Installationsprogramm zeigt Ihnen die neuesten Hinweise zu Python an, Lizenzinformationen (klicken Sie auf AKZEPTIEREN, wenn Sie nach den Lizenzinformationen gefragt werden) und schließlich ein Dialogfenster zum Speicherort.

5. Wählen Sie den Datenträger (Festplatte oder andere Speichermedien), den Sie für die Python-Installation benutzen wollen, und klicken Sie auf FORTFAHREN.

Das Dialogfenster INSTALLATIONSTYP erscheint. Dieses Dialogfenster bietet Ihnen zwei Anpassungsmöglichkeiten:

• Klicken Sie auf ANPASSEN, um den Funktionsumfang von Python auf Ihrem System zu ändern.

• Klicken Sie auf ORT FÜR DIE INSTALLATION ÄNDERN, um den Speicherort, an den das Installationsprogramm Python packt, zu ändern.

Dieses Buch geht davon aus, dass Sie die Standardinstallation durchführen und dass Sie den Installationsort nicht geändert haben. Diese Optionen stehen Ihnen jedoch bei Bedarf zur Verfügung.

6. Klicken Sie auf INSTALLIEREN.

Der Installationsassistent könnte Sie nach dem Administrator-Passwort fragen. Geben Sie, falls benötigt, den Administrator-Namen und das Passwort in das Dialogfenster ein und klicken Sie auf OK. Es wird ein Installationsdialog angezeigt. Die Inhalte dieses Dialogfensters ändern sich mit dem Installationsfortschritt, sodass Sie jederzeit wissen, was das Installationsprogramm gerade macht.

Nachdem die Installation beendet ist, erscheint ein Dialogfenster, das Ihnen die erfolgreiche Installation bestätigt.

7. Klicken Sie auf SCHLIESSEN.

Python kann nun verwendet werden.

Mit Linux arbeiten

Manche Linux-Distributionen haben Python schon vorinstalliert. Haben Sie beispielsweise eine Distribution, die auf dem Red Hat Paketmanager (RPM) basiert (wie SUSE, Ubuntu, Red Hat, Yellow Dog, Fedora Core und CentOS), ist Python schon auf Ihrem System installiert und Sie müssen nichts weiter unternehmen.

Je nachdem, welche Linux-Distribution Sie verwenden, variiert auch die Python-Version und bei manchen Systemen ist die Integrated DeveLopment Environment (IDLE) nicht dabei. Haben Sie eine ältere Python-Version (2.5.1 oder früher), möchten Sie sich vielleicht eine neuere Version installieren, damit Sie auch IDLE verwenden können. Viele Beispiele im Buch verwenden IDLE.

Es gibt zwei verschiedene Methoden, um Python unter Linux zu installieren. Die folgenden Abschnitte beschreiben beide Methoden. Die erste Methode funktioniert für jede Linux-Distribution; die zweite Methode verlangt spezielle Voraussetzungen, die erfüllt sein müssen.

Die Standard-Linux-Installation

Die Standard-Linux-Installation funktioniert auf jedem System. Sie müssen dafür aber mit dem Terminal arbeiten und Befehle eingeben, um sie auszuführen. Manche dieser Befehle können bei den unterschiedlichen Distributionen variieren. Sie finden dazu sehr hilfreiche zusätzliche Informationen unter http://docs.python.org/3/install.

1. Öffnen Sie www.python.org/downloads/release/3.4.2 mit Ihrem Browser.

Sie finden dort Informationen zur neuesten Python-Version, wie in Abbildung 2.1 zu sehen.

2. Klicken Sie auf den Linux-Link und dann auf den entsprechenden Link, um die Quelldateien herunterzuladen:

a. Python 3.4.2 XZ compressed source tarball (beliebige Linux-Version).

b. Python 3.4.2 Gzipped source tarball (bessere Komprimierung und schnellerer Download).

3. Wenn Sie gefragt werden, ob Sie die Datei öffnen oder speichern wollen, wählen Sie SPEICHERN.

Die Python-Quelldateien werden heruntergeladen. Haben Sie Geduld: Die Quelldateien brauchen ein oder zwei Minuten für den Download.

4. Doppelklicken Sie auf die heruntergeladene Datei.

Der Archivmanager öffnet sich. Nachdem die Dateien extrahiert wurden, sehen Sie den Ordner Python 3.4.2 im Fenster des Archivmanagers.

5. Extrahieren Sie das Verzeichnis irgendwo auf Ihrem System, zum Beispiel in Ihrem home-Verzeichnis.

Der Archivmanager extrahiert die Dateien in den Unterordner Python 3.4.2 in Ihr home-Verzeichnis.

6. Öffnen Sie ein Terminal-Fenster.

Das Terminal-Fenster erscheint. Haben Sie auf Ihrem System vorher noch nie Software erstellt, müssen Sie build-essential, SQLite und bzip2 installieren, sonst schlägt die Python-Installation fehl. Haben Sie das schon, können Sie die Schritte 7 bis 9 überspringen.

7. Geben Sie sudo apt-get install build-essential ein und drücken Sie [Enter].

Linux installiert Build Essential, das man zum Erstellen von Paketen braucht (für weitere Informationen siehe https://packages.debian.org/squeeze/build-essential).

8. Geben Sie sudo apt-get install libsqlite3-dev ein und drücken Sie [Enter].

Linux installiert SQLite, das Python für die Arbeit mit Datenbanken benötigt (für weitere Informationen siehe https://packages.debian.org/squeeze/libsqlite3-dev).

9. Geben Sie sudo apt-get install libbz2-dev ein und drücken Sie [Enter].

Linux installiert bzip2, das Python für die Arbeit mit Archiven benötigt (für weitere Informationen siehe https://packages.debian.org/squeeze/libbz2-dev).

10. Geben Sie CD Python 3.4.2 in das Terminal-Fenster ein und drücken Sie [Enter].

Terminal macht Python 3.4.2 zum aktuellen Verzeichnis.

11. Geben Sie ./configure ein und drücken Sie [Enter].

Das Skript prüft zunächst den Built-Typ des Systems und führt dann einige Aufgaben aus, je nachdem, welches System Sie haben. Dieser Vorgang kann ein oder zwei Minuten dauern, da eine lange Liste abgearbeitet werden muss.

12. Geben Sie make ein und drücken Sie [Enter].

Linux führt das make-Skript aus, um die Python-Software zu erstellen. Der make-Prozess kann bis zu einer Minute dauern – das hängt von der Geschwindigkeit Ihres Systems ab.

13. Geben Sie sudo make altinstall ein und drücken Sie [Enter].

Das System fragt Sie eventuell nach dem Administrator-Passwort. Geben Sie Ihr Passwort ein und drücken Sie [Enter]. Nun passieren einige weitere Dinge, da das System nun Python auf Ihrem System installiert.

Die grafische Linux-Installation verwenden

Alle Linux-Distributionen unterstützen die Standard-Installation, die im vorigen Abschnitt erklärt wurde. Es gibt aber auch ein paar Linux-Versionen der Debian-basierten Linux-Distributionen, wie Ubuntu 12.x und später, die auch eine Installation über die grafische Benutzeroberfläche anbieten. Sie müssen das Administratorgruppen-Passwort (sudo-Passwort) haben, um diese Methode auszuführen, also sollten Sie es besser zur Hand haben. Die folgenden Schritte beschreiben die grafische Installation für Ubuntu, aber die Methode ist für die anderen Distributionen ähnlich:

1. Öffnen Sie das Ubuntu Software-Center. (Der Ordner heißt auf anderen Systemen eventuell Synaptics.)

Sie bekommen eine Liste der beliebtesten Software angezeigt, die zum Download und zur Installation angeboten werden.

2. Wählen Sie den Punkt Entwicklungswerkzeuge links aus der Kategorienliste aus.

Es werden alle Entwicklungswerkzeuge, darunter auch Python, angezeigt.

3. Wählen Sie den Eintrag Python aus.

Das Ubuntu-Software-Center zeigt Ihnen eine lange Liste mit Tools an, die alle etwas mit Python zu tun haben.

4. Suchen Sie den Eintrag Python (v3.4) und klicken Sie darauf.

Sie können hier noch ein paar Details zu Python nachlesen und schließlich Python auch installieren.

5. Klicken Sie auf INSTALLIEREN.

Ubuntu startet die Installation. Ein Fortschrittsbalken zeigt den Status des Downloads und der Installation an. Wenn die Installation beendet ist, wird aus der Schaltfläche INSTALLIEREN die Schaltfläche ENTFERNEN.

6. Schließen Sie das Ubuntu Software-Center.

Es wird ein Python-Symbol zu Ihrem Desktop hinzugefügt. Python kann nun verwendet werden.

Auf Python auf Ihrem System zugreifen

Nachdem Sie Python nun auf Ihrem System installiert haben, müssen Sie wissen, wie Sie es finden. Python bemüht sich, Ihnen diesen Schritt zu vereinfachen, indem es bestimmte Dinge tut, wie zum Beispiel den Pfad zur Python-Anwendung zur Umgebungsvariable Path während der Installation hinzuzufügen. Trotzdem müssen Sie wissen, wie Sie auf die Anwendung zugreifen können. Dies wird in den folgenden Abschnitten beschrieben.

Mit Windows

Eine Windows-Installation erstellt ein neues Verzeichnis im Startmenü, das Ihre Python-Installation enthält. Sie können mit START|ALLE PROGRAMME|PYTHON 3.4 darauf zugreifen. Die zwei wichtigsten Elemente zur Programmierung einer neuen Anwendung sind in diesem Ordner IDLE (PYTHON GUI) und PYTHON (COMMAND LINE).

Ein Wort zu den Screenshots

Während Sie sich durch das Buch arbeiten, werden Sie entweder IDLE oder die Python-Kommandozeile verwenden, um mit Python zu interagieren. Der Name der grafischen Benutzeroberfläche (Graphical User Interface, kurz GUI), IDLE, ist auf allen drei Plattformen exakt derselbe und Sie werden auch keinen besonderen Unterschied in der Darstellung sehen. Die Unterschiede, die es gibt, sind wirklich gering, und Sie sollten diese bei der Arbeit mit dem Buch ignorieren. Dieses Buch enthält aus Gründen der Konsistenz nur Screenshots, die auf einem Windows-System gemacht wurden.

Auch das Kommandozeilen-Tool funktioniert auf allen drei Systemen genau gleich. Das Aussehen kann etwas stärker variieren als bei IDLE, da die Kommandozeile auf jedem System etwas anders aussieht. Die Befehle, die Sie dort eingeben, sind aber auf jeder Plattform gleich. Die Ausgabe ist auch die gleiche. Wenn Sie sich einen Screenshot anschauen, achten Sie am besten immer nur auf den Inhalt und nicht auf das Aussehen der Kommandozeile.

Wenn Sie auf IDLE (PYTHON GUI) klicken, wird eine grafische Benutzeroberfläche, wie in Abbildung 2.6 gezeigt, aufgerufen. Wenn Sie diese Anwendung starten, gibt IDLE ein paar Informationen aus, sodass Sie wissen, dass Sie das richtige Programm geöffnet haben. Zum Beispiel sehen Sie die Versionsnummer von Python (in diesem Fall 3.4.2). Sie bekommen auch mitgeteilt, auf welchem System Sie Python ausführen.

Abbildung 2.6: Verwenden Sie IDLE, wenn Sie vom Komfort einer grafischen Benutzeroberfläche profitieren wollen.

PYTHON (COMMAND LINE) öffnet eine Kommandozeile und führt den Python-Befehl aus, wie in Abbildung 2.7 zu sehen. Auch hier werden automatisch Informationen wie die Python-Version und das zugrunde liegende System angezeigt.

Abbildung 2.7: Verwenden Sie die Kommandozeile, wenn Sie die Geschwindigkeit und Flexibilität einer Kommandozeilen-Benutzerschnittstelle schätzen.

Es gibt noch eine dritte Methode, Python zu starten. Öffnen Sie eine Kommandozeile, tippen Sie python ein und drücken Sie [Enter]. Sie können diese Methode benutzen, wenn Sie für die Python-Umgebung mehr Flexibilität brauchen, automatisch Dinge laden oder Python mit höheren Benutzerrechten ausführen müssen (wo Ihnen dann noch zusätzliche Berechtigungen zur Verfügung stehen). Python bietet einen beachtlichen Umfang an Kommandozeilenparameter, die Sie sich anschauen können, wenn Sie python /? in die Kommandozeile eingeben und die Eingabetaste drücken. Abbildung 2.8 zeigt, was Sie dann normalerweise sehen. Sie brauchen sich im Moment nicht mit diesen ganzen Kommandozeilenparametern auseinanderzusetzen, denn für dieses Buch brauchen Sie sie nicht. Es ist aber trotzdem gut zu wissen, dass es sie gibt.

Abbildung 2.8: Wenn Sie eine herkömmliche Kommandozeile verwenden, können Sie mithilfe von Parametern die Ausführung von Python beeinflussen.

Wenn Sie Windows verwenden, müssen Sie für die dritte Ausführungsmethode Python zur Umgebungsvariablen PATH hinzufügen. Darum sollten Sie bei der Installation auf einem Windows-System die Option ADD PYTHON.EXE TO PATH aktivieren. Wenn Sie den Pfad nicht während der Installation hinzugefügt haben, können Sie das später nachholen, indem Sie auf Ihrem Desktop auf das DIESER RECHNER-Symbol mit der rechten Maustaste klicken, EIGENSCHAFTEN im Kontextmenü auswählen, auf ERWEITERTE EIGENSCHAFTEN klicken und dann im erscheinenden Fenster SYSTEMEIGENSCHAFTEN auf UMGEBUNGSVARIABLEN klicken. Unter Systemvariablen suchen Sie die Variable PATH, klicken Sie auf die Schaltfläche BEARBEITEN und ändern Sie die Variable, indem Sie den Installationspfad von Python am Ende an die Textzeile anhängen, also zum Beispiel den Standardinstallationspfad: C:\Python34\;C:\Python34\Scripts. Achten Sie darauf, dass Sie hinter den bisherigen letzten Eintrag des Pfades ein Semikolon setzen, denn damit unterscheidet Windows die einzelnen Pfade. Klicken Sie dann in allen geöffneten Dialogfenstern auf OK, um die Änderungen zu speichern. Sie können, statt die PATH-Variable zu ändern, auch die folgenden Variablen neu anlegen:

PYTHONSTARTUP

PYTHONPATH

PYTHONHOME

PYTHONCASEOK

PYTHONIOENCODING

PYTHONFAULTHANDLER

PYTHONHASHSEED

In diesem Buch wird keine dieser Variablen verwendet. Sie können aber mehr über diese Umgebungsvariablen unter http://docs.python.org/3.4/using/cmdline.html#environment-variables nachlesen (in Englisch).

Mit dem Mac

Wenn Sie einen Mac verwenden, ist Python wahrscheinlich schon installiert und Sie brauchen es für dieses Buch nicht zu installieren. Trotzdem müssen Sie aber wissen, wo sie Python auf Ihrem System finden. Die folgenden Abschnitte erklären Ihnen, wie Sie, abhängig von der durchgeführten Installation, auf Python zugreifen können.

Das vorinstallierte Python finden

Die Standard-OS-X-Installation enthält in den meisten Fällen kein Python-spezifisches Verzeichnis. Stattdessen müssen Sie Terminal öffnen, indem Sie PROGRAMME|DIENSTPROGRAMME| TERMINAL auswählen. Nachdem sich Terminal geöffnet hat, können Sie Python eingeben und [Enter] drücken, um auf die Kommandozeilenversion von Python zuzugreifen. Der Bildschirm, den Sie dann sehen, sieht so ähnlich aus wie in Abbildung 2.7. Genauso wie bei Windows (siehe den Abschnitt Mit Windows arbeiten in diesem Kapitel), haben Sie mit Terminal den Vorteil, dass Sie Kommandozeilenparameter verwenden können, um die Ausführung von Python zu steuern.

Die aktualisierte Version von Python finden

Nachdem Sie die Installation auf Ihrem Mac-System beendet haben, öffnen Sie den Ordner PROGRAMME. In diesem Verzeichnis finden Sie einen Python-3.4-Ordner, der das Folgende enthält:

Die IDLE-Anwendung (GUI-Entwicklung)

Python Launcher (interaktive Befehlsentwicklung)

Eine Datei Update Shell Profile.command

Die Lizenz- und ReadMe-Dateien und einen Link zur Python-Dokumentation

Ein Doppelklick auf die IDLE-Anwendung öffnet eine grafische interaktive Umgebung, die so ähnlich aussieht wie die aus Abbildung 2.6. Es gibt leichte kosmetische Unterschiede, aber der Inhalt des Fensters ist derselbe. Der Python Launcher bietet Ihnen die Möglichkeit, sehr komfortabel schon existierende Skripte auszuführen. Wenn Sie doppelt auf das Symbol klicken, bekommen Sie zunächst einen Konfigurationsdialog angezeigt, in dem Sie verschiedene Einstellungen für Python vornehmen können. Schließen Sie den Dialog wieder. Nun können Sie einfach eine existierende Python-Datei auf das Symbol PYTHON LAUNCHER ziehen und die Datei wird mit dem zuvor konfigurierten Python in einem Terminal-Fenster ausgeführt.

Selbst wenn Sie eine neue Version von Python auf Ihrem Mac installieren, müssen Sie sich nicht mit der Standardumgebung zufriedengeben. Sie haben immer noch die Möglichkeit, Terminal zu öffnen und dadurch Zugriff auf die Kommandozeilenparameter für Python zu bekommen. Wenn Sie Python jedoch über die Terminal-Anwendung aufrufen, müssen Sie sicherstellen, dass Sie nicht die Standardinstallation (das vorinstallierte Python) verwenden. Fügen Sie vorher auf jeden Fall /usr/local/bin/Python3.4 zu Ihrem Suchpfad der Kommandozeile hinzu.

Mit Linux

War Python schon auf Ihrem System installiert, finden Sie es im Verzeichnis /usr/ bin. Haben Sie es über das Terminal selbst installiert, wie im Abschnitt Die Standard-Linux-Installation beschrieben, finden Sie es unter /usr/local/bin. Entwickler unter Linux müssen im Terminal-Fenster python3 eingeben statt nur python, um auf die Python-3.4-Installation zuzugreifen.

Ihre Installation ausprobieren

Um sicherzugehen, dass Sie ein funktionierendes Python haben, müssen Sie es ausprobieren. Sie müssen wissen, dass Ihre Installation so funktioniert wie erwartet, wenn Sie sie brauchen. Natürlich bedeutet das auch, dass Sie Ihr erstes Python-Programm schreiben. Zum Loslegen öffnen Sie bitte die IDLE-Anwendung. Wie vorher schon erwähnt, zeigt IDLE Ihnen automatisch die Python-Version und das zugrunde liegende Betriebssystem an, wenn Sie es öffnen (siehe auch Abbildung 2.6).

Um festzustellen, ob Python funktioniert, geben Sie print("Das ist mein erstes Python- Programm.") ein und drücken Sie [Enter]. Python zeigt die Nachricht, die Sie gerade eingegeben haben, an, wie in Abbildung 2.9 zu sehen. Der print()-Befehl zeigt alles, was Sie ihm sagen, auf dem Bildschirm an. print()wird in diesem Buch recht häufig verwendet, um die Ergebnisse einer Aufgabe, die Python für Sie ausführen sollte, auszugeben. Es ist also einer der Befehle, mit dem Sie es sehr oft zu tun haben werden.

Beachten Sie, dass IDLE die verschiedenen Einträge im Fenster farbcodiert, damit sie einfacher zu sehen und zu verstehen sind. Die Farbcodes sind ein Indiz dafür, dass Sie etwas richtig gemacht haben. In Abbildung 2.9 sehen Sie vier Farbcodierungen (leider erkennen Sie diese in der gedruckten Ausgabe des Buches nicht):

Lila: Zeigt an, dass Sie einen Befehl eingegeben haben.

Grün: Signalisiert, dass Sie eine Zeichenkette eingegeben haben.

Abbildung 2.9: Der print()-Befehl gibt jede Information aus, die Sie ihm vorgeben.

Blau: Kennzeichnet die Ausgabe eines Befehls.

Schwarz: Definiert andere Elemente, zum Beispiel Variablennamen oder Zahlen.

Sie wissen jetzt, dass Python funktioniert, da Sie ihm einen Befehl übergeben konnten und Python mit einer Reaktion auf den Befehl geantwortet hat. Es wäre jetzt noch interessant, sich die Ausführung eines weiteren Befehls anzuschauen. Geben Sie 3 + 4 ein und drücken Sie [Enter]. Python antwortet, indem es 7 ausgibt, wie in Abbildung 2.10 gezeigt. Beachten Sie, dass 3 + 4 in schwarzer Schrift erscheint, da es kein Befehl und keine Zeichenkette ist. 7 wird jedoch in blauer Schrift dargestellt, da es eine Ausgabe ist.

Abbildung 2.10: Python unterstützt die direkte Eingabe mathematischer Operationen als Teil der interaktiven Umgebung.

Jetzt wird es Zeit, Ihre IDLE-Sitzung (im Englischen »session« genannt) zu beenden. Geben Sie quit() (Beenden) ein und drücken Sie [Enter]. IDLE zeigt dann eine Nachricht, wie die in Abbildung 2.11, an. Nun, Sie hatten vielleicht nicht die Absicht, etwas oder jemanden um die Ecke zu bringen (»kill« bedeutet so viel wie umbringen oder töten), aber genau das werden Sie nun tun. Klicken Sie auf OK und die Sitzung verabschiedet sich ins Nirwana.

Abbildung 2.11: IDLE dramatisiert etwas, wenn es um das Beenden einer Sitzung geht!

3

Mit Python arbeiten

In diesem Kapitel

Verwenden Sie die Kommandozeile

Verwenden Sie Befehle, um Aufgaben auszuführen

Bekommen Sie Hilfe zu Python

Beenden Sie eine Sitzung in der Kommandozeile

Ausnahmslos jede Anwendung, die Sie schreiben, interagiert mit dem Computer und den Daten, die er enthält. Der Fokus liegt auf den Daten, denn ohne Daten gibt es keinen Grund, eine Anwendung zu benutzen. Jede Anwendung, die Sie verwenden (sogar eine so einfache wie Solitär), manipuliert in irgendeiner Weise Daten. Das Akronym CRUD fasst sehr gut zusammen, was die meisten Anwendungen machen. CRUD steht für:

Create: Daten erzeugen

Read: Daten lesen

Update: Daten aktualisieren

Delete: Daten löschen

Wenn Sie sich CRUD merken, können Sie schnell erklären, was die meisten Anwendungen mit den Daten auf Ihrem Computer machen (und manche Anwendungen sind wirklich sehr »krude«). Bevor Ihre Anwendung jedoch auf den Computer zugreifen kann, müssen Sie eine Programmiersprache verwenden, die eine abzuarbeitende Aufgabenliste in einer Sprache erzeugt, die der Computer verstehen kann. Das ist der Sinn dieses Kapitels. Sie beginnen, Python zu benutzen. Python nimmt die Liste mit Schritten, die Sie mit den Daten des Computers ausführen wollen, entgegen und wandelt diese in Bits um, die der Computer verstehen kann.

Python in der Kommandozeile starten

Python bietet Ihnen verschiedene Wege an, um mit der zugrunde liegenden Sprache zu arbeiten. Zum Beispiel haben Sie in Kapitel 2 schon ein bisschen mit der Integrierten Entwicklungsumgebung IDLE gearbeitet. IDLE macht die Entwicklung von vollfunktionsfähigen Anwendungen einfach. Manchmal möchte Sie jedoch einfach nur etwas herumexperimentieren oder eine bereits existierende Anwendung ausprobieren. In solchen Fällen fahren Sie mit der Kommandozeilenversion von Python oft besser, da sie Ihnen eine bessere Steuerung der Python-Umgebung über die Kommandozeilenparameter bietet, weniger Ressourcen verbraucht und eine minimalistische Oberfläche bietet, sodass Sie sich ganz auf das Ausprobieren des Codes konzentrieren können, anstatt mit einer grafischen Benutzeroberfläche herumzuspielen.

Warum README-Dateien wichtig sind

Viele Anwendungen enthalten eine README-Datei (was so viel wie »Lies mich« heißt). Die README-Datei enthält meist aktualisierte Informationen, die nicht mehr in die Dokumentation aufgenommen werden konnten, bevor die Anwendung veröffentlicht wurde. Leider ignorieren die meisten Leute die README-Datei oder wissen nicht einmal, dass es sie gibt. Deshalb erfahren diese Leute nichts über die wirklich interessanten Dinge Ihrer schönen neuen Anwendung, die sie eigentlich aber wissen sollten. Python hat eine README.txt-Datei im \Python34-Verzeichnis. Wenn Sie diese Datei öffnen, finden Sie jede Menge sehr interessanter Informationen:

Wie man Python auf Linux-Systemen kompiliert und installiert

Wo man sich Informationen über die neuen Features dieser Python-Version besorgen kann

Wo man die neueste Dokumentation zu dieser Version findet

Wie Sie Anwendungen, die Sie mit 2.x-Versionen von Python geschrieben haben, zu einer 3.x-Version umwandeln können

Was Sie machen können, um eigene Änderungen an Python selbst zu testen

Wie man verschiedene Versionen von Python auf demselben System installiert

Wo Sie die Fehler- und Problemberichte (in sogenannten »Bug« oder »Issue Trackern«) finden

Wie und wo Sie Verbesserungsvorschläge für Python machen können

Wie Sie davon erfahren, dass es eine neue Version von Python gibt

Das Öffnen und Lesen der README-Datei bringt Sie einen Schritt näher daran, ein Python-Profi zu werden. Die Leute werden erstaunt sein, dass Sie schon Details über Python wissen, und Ihnen alle möglichen Fragen stellen (auf Ihre Weisheit vertrauend). Natürlich können Sie auch faul sein und bei sich denken, dass es zu viel Aufwand ist, die README-Datei zu lesen.

Python starten

Abhängig von Ihrem System kann es mehrere Wege geben, Python in der Kommandozeile zu starten. Hier die am häufigsten verfügbaren Methoden:

Klicken Sie auf den PYTHON (COMMAND-LINE)-Eintrag im Python 3.4-Verzeichnis. Dieser Eintrag startet eine Kommandozeilensitzung mit den Standardeinstellungen.

Öffnen Sie eine Kommandozeile oder Terminal, tippen Sie python ein und drücken Sie [Enter]. Verwenden Sie diese Methode, wenn Sie Python über die Kommandozeilenparameter flexibel konfigurieren wollen.

Suchen Sie das Python-Verzeichnis, zum Beispiel C:\Python34 unter Windows, und starten Sie die python.exe direkt. Diese Methode startet auch eine Kommandozeilensitzung, die die Standardeinstellungen verwendet. Sie können so aber auch andere Dinge tun, wie die Kommandozeile mit erhöhten Berechtigungen ausführen (bei Anwendungen, die auf Dateien mit speziellen Berechtigungen zugreifen müssen) oder für die Ausführung der exe-Datei noch weitere Eigenschaften festlegen (Kommandozeilenparameter).

Egal, wie Sie die Kommandozeile starten, Sie werden im Endeffekt eine Eingabeaufforderung wie die in Abbildung 3.1 bekommen. (Ihr Fenster wird eventuell etwas anders aussehen als das in Abbildung 3.1, wenn Sie ein anderes Betriebssystem als Windows oder die IDLE-Anwendung statt der Kommandozeile benutzen oder Ihr System anders als meins konfiguriert ist oder Sie eine andere Python-Version haben). Diese Eingabeaufforderung zeigt Ihnen die Python-Version, das Betriebssystem des Rechners und wie Sie an weitere Informationen kommen.

Abbildung 3.1: Die Python-Eingabeaufforderung teilt Ihnen etwas über Ihre Python-Umgebung mit.

Die Kommandozeile nutzbringend einsetzen

Dieser Abschnitt sieht auf den ersten Blick etwas kompliziert aus und normalerweise bräuchten Sie diese Informationen für dieses Buch auch nicht. Trotzdem sind die Informationen in diesem Abschnitt wertvoll und eventuell brauchen Sie sie später. Für den Moment können Sie die Informationen einfach nur überfliegen und später nachschlagen, wenn Sie sie wirklich benötigen.

Um Python in einer Kommandozeile zu öffnen, geben Sie python ein und drücken Sie [Enter]. Das ist aber längst nicht alles, was Sie tun können. Sie können auch noch zusätzliche Informationen mitgeben, um die Art und Weise, wie Python arbeitet, zu ändern.

Optionen: Eine Option oder auch Kommandozeilenparameter beginnt mit einem Bindestrich (oder Minuszeichen) gefolgt von einem oder mehreren Buchstaben. Wenn Sie sich beispielsweise die Hilfe von Python anschauen wollen, geben Sie python –h ein und drücken [Enter]. Sie bekommen nun zusätzliche Informationen angezeigt, wie Sie mit Python in der Kommandozeile arbeiten können. Weitere Optionen werden etwas später in diesem Abschnitt erklärt.

Dateiname: Übergibt man einen Dateinamen als Eingabe, veranlasst man Python damit, diese Datei zu laden und auszuführen. Sie können eine beliebige Beispielanwendung des zum Download zur Verfügung stehenden Codes ausführen, indem Sie den Namen (genauer den Pfad) der Datei, die das Beispiel enthält, als Eingabe angeben. Wenn Sie ein Beispiel haben, das in der Datei C:\Hallo.py enthalten ist, können Sie es ausführen, indem Sie python "C:\Hallo.py" eingeben und [Enter] drücken. Liegt die Datei in dem Ordner, in dem Sie sich gerade mit der Eingabeaufforderung befinden, dann reicht python "Hallo.py".

Parameter: Eine Anwendung kann zusätzliche Informationen als Eingabe annehmen, die steuern, wie die Anwendung ausgeführt wird. Diese zusätzlichen Informationen werden Parameter genannt (im Englischen auch »arguments«). Sie brauchen sich im Moment noch keine Gedanken über diese Parameter zu machen – sie kommen in diesem Buch später noch vor.

Die meisten der Optionen benötigen Sie derzeit noch nicht. Sie stehen hier, damit Sie später darauf zurückgreifen können, wenn Sie sie brauchen (an dieser Stelle im Buch machen sie aber am meisten Sinn). Beim Durchlesen bekommen Sie einen Überblick, was es so gibt, aber Sie können diesen Text auch überspringen, bis Sie ihn wirklich brauchen.

Python unterscheidet bei den Optionen die Groß- und Kleinschreibung. Zum Beispiel ist –s eine ganz andere Option als –S. Für Python gibt es folgende Kommandozeilenparameter, die Python sagen:

-b: Füge Warnungen zur Ausgabe hinzu, wenn meine Anwendung bestimmte Python-Funktionen verwendet, wie str(bytes_instance), str(bytearray_instance), oder wenn ein bytes oder ein bytearray-Objekt mit einer Zeichenkette verglichen wird.

-bb: Ähnlich wie die vorige Option, aber statt Warnungen werden Fehler zur Ausgabe hinzugefügt.

-B: Schreibe während eines Modulimports keine .py- oder .pyco-Dateien.

-c cmd: Führe cmd als Programm aus (cmd könnte zum Beispiel print (´Hallo´) sein. Diese Option sagt Python auch, dass die hinter –c eingegebenen Informationen nicht als Optionen interpretiert werden sollen (sie werden als Teil des Programms behandelt).

-d: Starte den Debugger (damit können Sie Fehler in Ihrem Programm finden).

-E: Ignoriere alle Umgebungsvariablen wie PYTHONPATH, die zur Konfiguration von Python dienen.

-h: Zeige Hilfetext zu den Optionen und grundlegenden Umgebungsvariablen auf dem Bildschirm an. Python beendet sich nach diesem Befehl, ohne sonst irgendetwas getan zu haben, damit Sie sich die Hilfeinformationen in Ruhe anschauen können.

-i: Zeige mir den Code mit interaktiven Funktionen nach Ausführung eines Skripts (in Python nennt man ein Programm auch Skript) an. Zeigt in jedem Fall eine Eingabeaufforderung an, auch wenn stdin (das festgelegte Standardeingabemedium) keine Kommandozeile ist.

-I: Isoliere Python von der Benutzerumgebung, das heißt, es werden keine benutzerspezifischen Informationen in der Programmausführung verwendet.

-m mod: Führe das Bibliotheksmodul mod als Skript aus. Dieser Befehl weist Python auch an, die restlichen Informationen nicht als Optionen zu interpretieren (sondern als Teil des Skripts).

-O: Optimiere den erzeugten Bytecode (das übersetzte, maschinenlesbare Programm) ein wenig (macht das Programm schneller).

-OO: Über die Optimierungen in –O hinaus entferne auch Kommentare (im Englischen auch »doc-strings« genannt).

-q: Gib während eines interaktiven Starts nicht die Versionsnummer und die Copyright-Texte aus.

-s: Füge das aktuelle Benutzerverzeichnis nicht zur sys.path-Variablen hinzu (diese Variable sagt Python, wo es Module findet, die zusätzlich geladen werden sollen).

-S: Führe import site nicht bei der Initialisierung aus. Diese Option weist Python an, sich keine Pfade für Module, die es zur Ausführung eines Programms braucht, selbstständig zu suchen.

-u: Für das Standardausgabemedium (stdout) und die Standardfehlerausgabe (stderr) dürfen ungepufferte Binärdaten als Eingabe angenommen werden.

-v: Erhöht den Detailgrad der Ausgabe von Python. Es zeigt dann die import-Befehle auch an. Jede weitere Anwendung von –v erhöht den Detailgrad.

--version: Gibt die Pythonversion aus und beendet Python.

-W arg: Filtert die ausgegebenen Meldungen, sodass Python mehr oder weniger Meldungen anzeigt. Die Werte, die für den Parameter arg angegeben werden können, sind:

• action

• message

• category

• module

• lineno

Zum Beispiel können Sie mit der Festlegung des Wertes lineno nur Meldungen für eine bestimmte Codezeile ausgeben lassen.

-x: Überspringe die erste Zeile einer Quelldatei, sodass Sie nicht-UNIX-Formen von #!cmd verwenden können.

-X opt: Wende eine implementierungsspezifische Option an. (Die Dokumentation für Ihre Python-Version erklärt diese Optionen, falls es welche gibt.)

Python-Umgebungsvariablen nutzbringend einsetzen

Umgebungsvariablen sind spezielle Einstellungen, die Teil der Kommandozeilen- oder Terminalumgebung Ihres Betriebssystems sind. Sie dienen dazu, Python einheitlich zu konfigurieren. Umgebungsvariablen können viele der Sachen, die die Optionen beim Start von Python bewirken, auch tun, aber Umgebungsvariablen werden dauerhaft belegt, sodass Python immer gleich konfiguriert ist, wenn Sie es starten, ohne dass Sie die Optionen jedes Mal neu eingeben müssen.

Genau wie bei den Optionen gilt hier auch, dass Sie die meisten der Umgebungsvariablen jetzt nicht brauchen. Sie können sie kurz überfliegen, um von der Auswahl einen Eindruck zu bekommen. Manche der Umgebungsvariablen werden später im Buch verwendet. Überspringen Sie ruhig den Rest dieses Abschnitts und schauen Sie ihn sich wieder an, wenn Sie ihn brauchen.

Die meisten Betriebssysteme bieten Ihnen die Möglichkeit, Umgebungsvariablen vorübergehend während einer bestimmten Sitzung oder dauerhaft als Teil der Einstellungen Ihres Betriebssystems zu setzen. Wie genau dieser Prozess aussieht, kommt ganz auf Ihr Betriebssystem an. Wenn Sie beispielsweise mit Windows arbeiten, verwenden Sie den Befehl Set, um temporär eine Variable zu setzen, oder Sie konfigurieren die Umgebungsvariablen in den erweiterten Systemeinstellungen dauerhaft.

Die Verwendung von Umgebungsvariablen macht dann Sinn, wenn Sie Python regelmäßig so konfiguriert ausführen möchten. Die folgende Liste beschreibt die verfügbaren Umgebungsvariablen für Python:

PYTHONCASEOK=x: Zwingt Python, die Groß- und Kleinschreibung bei import-Befehlen zu ignorieren. Diese Variable gibt es nur bei Windows-Betriebssystemen.

PYTHONDEBUG=x: Macht dasselbe wie die Option –d.

PYTHONDONTWRITEBYTECODE=x: Macht dasselbe wie die Option –B.

PYTHONFAULTHANDLER=x: Zwingt Python dazu, die Traceback-Liste (eine Liste von Befehlsaufrufen, die zu einem Fehler geführt haben) bei schwerwiegenden Fehlern auszugeben.

PYTHONHASHSEED=arg: Bestimmt den zugrunde liegenden Wert (den sogenannten »Seed«), der zur Berechnung von Hashwerten aus verschiedenen Daten herangezogen wird. Wenn diese Variable auf random (»zufällig«) gesetzt wird, verwendet Python einen zufälligen Wert für str-, bytes- und DateTime-Objekte (das sind verschiedene Datentypen, die später im Buch noch behandelt werden). Die Variable darf einen ganzzahligen Wert zwischen 0 und 4294967295 annehmen. Wenn Sie reproduzierbare Ergebnisse für die Hashberechnungen bekommen möchten (für bestimmte Tests oder Experimente hilfreich), sollten Sie einen konstanten Wert wählen.

PYTHONHOME=arg: Gibt den Standardsuchpfad an, in dem Python nach zu ladenden Modulen nachschaut.

PYTHONINSPECT=x: Macht dasselbe wie die Option –i.

PYTHONIOENCODING=arg: Gibt die Zeichencodierung (zum Beispiel utf-8) für die Standardeingabe (stdin), die Standardausgabe (stdout) und die Standardfehlerausgabe (stderr) an.

PYTHONNOUSERSITE: Macht dasselbe wie die Option –s.

PYTHONOPTIMIZE=x: Macht dasselbe wie die Option –O.

PYTHONPATH=arg: Enthält eine durch Semikolons getrennte Liste mit Verzeichnispfaden, in denen Python nach zu ladenden Modulen schauen soll. Dieser Wert kann in Python über die Variable sys.path abgerufen werden.

PYTHONSTARTUP=arg: Definiert den Namen einer Datei, die beim Start von Python ausgeführt werden soll. Für diese Umgebungsvariable gibt es keinen Standardwert.

PYTHONUNBUFFERED=x: Macht dasselbe wie die Option –u.

PYTHONVERBOSE=x: Macht dasselbe wie die Option –v.

PYTHONWARNINGS=arg: Macht dasselbe wie die Option –W.

Einen Befehl eingeben

Nachdem Sie die Kommandozeilenversion von Python gestartet haben, können Sie mit der Eingabe von Befehlen beginnen. Die Verwendung von Befehlen ermöglicht es Ihnen, Aufgaben auszuführen, Ideen, die Sie für Ihre Anwendung haben, auszuprobieren und mehr über Python zu erfahren. Die Verwendung der Kommandozeile verschafft Ihnen praktische Erfahrung mit der eigentlichen Funktionsweise von Python – Details, die Ihnen in einer integrierten Entwicklungsumgebung (englisch Integrated Development Environment, IDE) wie IDLE verborgen bleiben könnten. Die folgenden Abschnitte helfen Ihnen beim Einstieg mit der Kommandozeile.

Dem Computer sagen, was er machen soll

Wie jede andere Programmiersprache basiert Python auf Befehlen. Ein Befehl ist einfach ein Schritt in einem Arbeitsablauf. In Kapitel 1 war zum Beispiel »Sie holen das Brot und die Butter aus dem Kühlschrank.« ein Schritt beim Vorgang des Toastmachens. Wenn Sie mit Python arbeiten, ist ein Befehl wie print() genau das Gleiche: ein Schritt in einem Arbeitsablauf.

Um dem Computer mitzuteilen, was er machen soll, geben Sie einen oder mehrere Befehle ein, die Python versteht. Python übersetzt diese Befehle in Anweisungen, die der Computer versteht, und dann wird das Ergebnis angezeigt. Ein Befehl wie print() kann die Ergebnisse auf dem Bildschirm ausgeben, sodass Sie sie unmittelbar sehen können. Python unterstützt vielerlei Befehle, von denen viele gar nichts auf dem Bildschirm anzeigen und dennoch etwas Wichtiges tun.

Im Verlauf des Buches verwenden Sie Befehle, um verschiedene Aufgaben zu erledigen. Jede dieser Aufgaben hilft Ihnen, ein bestimmtes Ziel zu erreichen, genauso wie Schritte in einem Arbeitsablauf dies tun. Sollten Ihnen diese ganzen Python-Befehle mal zu kompliziert vorkommen, dann stellen Sie sie sich wieder als Schritte eines Prozesses vor. Manchmal kommen einem selbst Vorgänge außerhalb des Computers sehr kompliziert vor, aber wenn man diese Schritt für Schritt angeht, bekommen Sie eine Idee, wie sie funktionieren. Mit Python-Befehlen ist es genauso. Lassen Sie sich nicht zu sehr von ihnen beeindrucken; schauen Sie sich stattdessen immer einen nach dem anderen an und konzentrieren Sie sich auf genau diesen einen Schritt in Ihrem Programm.

Dem Computer mitteilen, dass Sie fertig sind

An einem bestimmten Punkt ist Ihr Prozess zu Ende. Wenn Sie einen Toast machen, endet der Vorgang mit dem Bestreichen des Toasts mit Butter. Mit Computerprogrammen ist es ganz genauso. Sie haben einen Start- und einen Endpunkt. Wenn Sie Befehle eingeben, wird der Endpunkt eines bestimmten Schritts durch die Eingabetaste gesetzt. Sie drücken [Enter], um dem Computer zu sagen, dass Sie mit dem Eingeben des Befehls fertig sind. Im Verlaufe des Buches werden Sie feststellen, dass Python zahlreiche Methoden zur Verfügung stellt, um kenntlich zu machen, dass ein Schritt, eine Gruppe aus Schritten oder sogar eine ganze Anwendung fertig ist. Computerprogramme haben immer einen definierten Start- und Endpunkt, egal wie sie eine Aufgabe lösen.

Sich das Ergebnis anschauen

Nun wissen Sie also, dass ein Befehl ein Schritt in einem Programm ist und dass jeder Befehl einen bestimmten Start- und Endpunkt hat. Außerdem haben auch Befehlsgruppen und ganze Anwendungen festgesetzte Start- und Endpunkte. Dann lassen Sie uns mal schauen, wie das funktioniert. Das folgende Vorgehen zeigt Ihnen, wie man sich das Ergebnis eines Befehls anschauen kann.

1. Starten Sie die Kommandozeilenversion von Python.

Es öffnet sich eine Kommandozeile, wie in Abbildung 3.1 dargestellt, in die Sie Befehle eingeben können.

2. Geben Sie print("Dies ist eine Zeile Text.") in die Kommandozeile ein.

Sie werden feststellen, dass nichts passiert ist. Ja, Sie haben einen Befehl eingegeben, aber Sie haben Python nicht mitgeteilt, dass der Befehl zu Ende ist.

3. Drücken Sie [Enter].

Der Befehl ist nun beendet und daher sollten Sie ein Ergebnis wie das in Abbildung 3.2 sehen.

Diese Übung zeigt Ihnen, wie die Dinge in Python funktionieren. Jeder Befehl, den Sie eingeben, führt eine Aufgabe aus, aber nur, nachdem Sie Python mitgeteilt haben, dass der Befehl vollständig ist. Der Befehl print() zeigt Daten auf dem Bildschirm an. In diesem Fall haben Sie Text angegeben, der angezeigt werden soll. Beachten Sie, dass die Ausgabe in Abbildung 3.2 direkt nach dem Befehl kommt, da dies eine interaktive Umgebung ist – eine, in der Sie das Ergebnis jedes eingegebenen Befehls sofort sehen, nachdem Python ihn ausgeführt hat. Wenn Sie später Anwendungen schreiben, werden Sie feststellen, dass Ergebnisse manchmal nicht sofort erscheinen, da die Anwendungsumgebung das hinauszögert. Aber auch da wird der Befehl sofort von Python ausgeführt, nachdem die Anwendung ihm gesagt hat, dass der Befehl vollständig ist.

Abbildung 3.2: Wenn man Befehle eingibt, sagt man Python, was es dem Computer sagen soll, was er zu machen hat.

Die Hilfe verwenden

Pythonist eine Computersprache, keine Menschensprache. Daher werden Sie sie anfänglich nicht sofort fließend sprechen. Und wenn Sie einen Moment darüber nachdenken, ist auch logisch, dass Sie sie nicht fließend sprechen werden (auch bei menschlichen Sprachen würden Sie, selbst wenn Sie die Sprache fließend sprechen, nicht jeden Befehl kennen). Genau wie beim Erlernen einer neuen menschlichen Sprache müssen Sie die Python-Befehle Stück für Stück kennenlernen. Wenn Sie normalerweise Deutsch sprechen und nun versuchen, etwas in Englisch zu sagen, hätten Sie wahrscheinlich gerne ein Wörterbuch, in dem Sie nachschlagen können. Sonst sprechen Sie nachher nur Kauderwelsch und die Leute würden Sie ganz komisch angucken. Auch wenn es Ihnen gelingen würde, etwas Sinnvolles zu sagen, ist es vielleicht nicht das, was Sie eigentlich sagen wollten. Zum Beispiel würden Sie in ein Restaurant gehen und ein paar heiße Radkappen bestellen, obwohl Sie eigentlich ein Steak haben wollten.

Auch beim Erlernen von Python brauchen Sie eine Art Wörterbuch, ein Nachschlagewerk, das Ihnen hilft. Zum Glück ist Python sehr zuvorkommend und stellt Ihnen unmittelbar Hilfe zur Verfügung, damit Sie nicht etwas ausführen, was Sie eigentlich nicht wollen. Die von Python angebotene Hilfe hat zwei verschiedene Funktionsweisen:

Den Hilfemodus, in dem Sie die verfügbaren Befehle anschauen können

Die Soforthilfe, mit der Sie sich über einen bestimmten Befehl schlaumachen können

Es gibt nicht »den« richtigen Weg, die Hilfe zu verwenden – nur die Methode, die für Sie zu einem bestimmten Zeitpunkt am besten funktioniert. Die folgenden Abschnitte beschreiben, wie man sich die Hilfe zunutze macht.

In den Hilfemodus wechseln

Abbildung 3.1 zeigt den Bildschirm, den Sie sehen, wenn Sie Python starten. Wie Sie vielleicht schon gesehen haben, bietet Python Ihnen hier vier Befehle an (im Prinzip schon die erste Hilfestellung):

help
copyright
credits
license

Alle vier Befehle stellen Ihnen auf die eine oder andere Art Hilfe für Python zur Verfügung. Zum Beispiel gibt Ihnen der Befehl copyright() darüber Auskunft, wer dazu berechtigt ist, Python zu vervielfältigen, zu lizenzieren oder zu vertreiben. Der Befehl credits() gibt aus, wer zu Python beigetragen hat. Der license()-Befehl beschreibt die Nutzungsvereinbarung zwischen Ihnen und dem Inhaber des Copyrights. Aber der Befehl, der Sie wahrscheinlich am meisten interessiert, ist help() (Hilfe).

Um in den Hilfemodus zu wechseln, geben Sie help() ein und drücken [Enter]. Beachten Sie, dass die Klammern hinter help mit zum Befehl gehören, auch wenn sie im Hilfetext nicht erwähnt werden. Zu jedem Python-Befehl gehören immer auch Klammern. Nachdem Sie diesen Befehl eingegeben haben, wechselt Python in den Hilfemodus und Sie bekommen ein Fenster ähnlich dem in Abbildung 3.3 angezeigt.

Abbildung 3.3: Im Hilfemodus können Sie Python zu weiteren Befehlen befragen.

Sie wissen immer, dass Sie im Hilfemodus sind, wenn Sie die Eingabeaufforderung help> im Python-Fenster sehen. Solange das help> noch vorne steht, sind Sie im Hilfemodus.

Um Hilfe bitten

Um Hilfe zu bekommen, müssen Sie auch wissen, was für Fragen Sie stellen müssen. Die initiale Hilfenachricht, die Sie im Hilfemodus sehen (siehe Abbildung 3.3), verrät Ihnen ein paar hilfreiche Tipps über die Fragen, die Sie stellen können. Beim Stöbern in Python stehen Ihnen die folgenden Hauptthemenbereiche zur Verfügung:

modules
keywords
topics

Die ersten zwei Themen werden Ihnen jetzt wahrscheinlich noch nicht viel sagen. Sie werden das Thema modules (»Module«) bis Kapitel 10 nicht brauchen. Das Thema keywords (»Schlüsselwörter«) wird für Sie in Kapitel 4 von Nutzen sein. Das Thema topics (»Themen«) ist jetzt schon interessant, da Sie dadurch erfahren, wo Sie Ihr Python-Abenteuer beginnen können. Geben Sie topics ein, drücken Sie [Enter] und Sie sehen eine Themenliste wie die in Abbildung 3.4.

Abbildung 3.4: Beim Hilfeeintrag topics können Sie Ihr Abenteuer mit Python beginnen.

Wenn Sie ein Thema sehen, dass Sie interessiert, zum Beispiel FUNCTIONS, geben Sie das einfach ein und drücken [Enter]. Probieren Sie es einfach mal aus, geben Sie FUNCTIONS ein und drücken Sie [Enter]. (Sie müssen das Wort in Großbuchstaben eingeben – keine Angst, Python denkt nicht, dass Sie schreien.) Ihnen werden Hilfeinformationen wie die in Abbildung 3.5 angezeigt.

Wenn Sie sich durch die Beispiele im Buch arbeiten, werden Sie Befehle verwenden, die interessant aussehen, und vielleicht möchten Sie etwas mehr Informationen darüber haben. In dem Abschnitt Sich das Ergebnis anschauen benutzen Sie zum Beispiel den Befehl print(). Um mehr über den Befehl print() zu erfahren, geben Sie print ein und drücken Sie [Enter] (beachten Sie, dass Sie diesmal die Klammern weglassen müssen, da Sie sich ja den Hilfeeintrag zu print() anschauen wollen und nicht den tatsächlichen Befehl verwenden wollen). Abbildung 3.6 zeigt Ihnen die typischen Hilfeinformationen, die zum Befehl print() ausgegeben werden.

Abbildung 3.5: Sie müssen in Großbuchstaben schreiben, wenn Sie zu einem Thema Hilfe möchten.

Abbildung 3.6: Sie können Informationen über einen Befehl einholen, indem Sie den Befehl genauso eingeben, wie er normalerweise geschrieben wird.

Leider helfen Ihnen die Hilfeinformationen im Moment vielleicht noch nicht so viel, da Sie noch etwas mehr über Python wissen müssen. Sie können aber trotzdem noch mehr Informationen bekommen. Sie fragen sich vielleicht, was sys.stdout im Hilfeeintrag zu print bedeutet – aber der Hilfeeintrag sagt natürlich nichts darüber. Geben Sie einfach sys.stdout ein und drücken Sie [Enter]. Dann bekommen Sie die Hilfeinformationen aus Abbildung 3.7 angezeigt.

Eventuell sind diese Informationen immer noch nicht so hilfreich, wie Sie sie bräuchten, aber zumindest wissen Sie jetzt schon etwas mehr. In diesem Beispiel hat Ihnen die Hilfe mehr mitzuteilen, als in das Fenster passt. Beachten Sie den folgenden Eintrag am Ende der Ausgabe:

-- Fortsetzung –-

Abbildung 3.7: Sie können sich Hilfe für die angezeigte Hilfe besorgen.

Drücken Sie die Leertaste, um sich die zusätzlichen Informationen anzuschauen. Die nächste Seite des Hilfeeintrags wird angezeigt. Solange es weitere Seiten gibt, können Sie [Leertaste] drücken. Die gelesenen Seiten sind aber nicht weg – Sie können jederzeit im Fenster nach oben scrollen, um wieder zu dem vorherigen Text zu kommen.

Den Hilfemodus verlassen

Irgendwann müssen Sie den Hilfemodus wieder verlassen, um sich der eigentlichen Arbeit wieder zuzuwenden. Dazu müssen Sie lediglich [Enter] drücken. Nachdem Sie [Enter] gedrückt haben, erscheint eine Nachricht, dass Sie die Hilfe nun verlassen, und die Eingabeaufforderung wird wieder zur normalen Python-Eingabeaufforderung wie in Abbildung 3.8 zu sehen.

Abbildung 3.8: Verlassen Sie die Hilfe, indem Sie einfach die Eingabetaste drücken.

Sich unmittelbar Hilfe holen

Es nicht unbedingt notwendig, in den Hilfemodus zu wechseln; es sei denn, Sie wollen in der Hilfe etwas herumstöbern oder Sie wissen nicht genau, was Sie suchen. Wenn Sie genau wissen, was Sie suchen, können Sie die Hilfe auch direkt aufrufen (ein nettes Feature in Python). Statt sich also mit dem Hilfemodus herumzuschlagen, geben Sie einfach das Wort help ein, gefolgt von einer öffnenden Klammer und einem einzelnen Anführungszeichen, dem, was Sie finden wollen, einem weiteren einzelnen Anführungszeichen und einer schließenden Klammer. Wenn Sie zum Beispiel mehr über den Befehl print erfahren wollen, geben Sie help(´print´) ein und drücken [Enter]. Abbildung 3.9 zeigt die typische Ausgabe, wenn Sie die Hilfe auf diese Weise verwenden.

Abbildung 3.9: In Python können Sie die Hilfe immer dann aufrufen, wenn Sie sie brauchen, ohne dass Sie Python verlassen müssen.

Sie können in der Python-Eingabeaufforderung aber trotzdem auch durch die Hilfe stöbern. Sie können beispielsweise help(´topics´) eingeben und [Enter] drücken. Sie sehen dann die Themenliste in Abbildung 3.10. Sie können diese mit der Liste aus Abbildung 3.4 vergleichen. Die beiden Listen sind identisch, auch wenn Sie die eine im Hilfemodus und die andere in der Python-Eingabeaufforderung aufgerufen haben.

Abbildung 3.10: Sie können auch in der Python-Eingabeaufforderung in der Hilfe stöbern.

Sie wundern sich vielleicht, warum Python einen Hilfemodus hat, wenn Sie dieselben Informationen auch über die Python-Eingabeaufforderung bekommen können. Die Antwort ist »Komfort«. Im Hilfemodus können Sie einfacher suchen. Auch wenn Sie in der Eingabeaufforderung nicht so viel zusätzliche Schreibarbeit haben, müssen Sie im Hilfemodus noch weniger schreiben. Der Hilfemodus bietet Ihnen zusätzliche Hilfestellungen, wie die Auflistung der Befehle, die Sie eingeben können (siehe Abbildung 3.3). Es gibt also viele gute Gründe, in den Hilfemodus zu wechseln, gerade wenn Sie vorhaben, Python sehr viele Fragen zu stellen.

Egal, auf welche Weise Sie sich Hilfe besorgen, Sie müssen auf die korrekte Groß- und Kleinschreibung achten. Wollen Sie beispielsweise allgemeine Informationen über Funktionen, müssen Sie help(´FUNCTIONS´) und nicht help (´Functions´) oder help(´functions´) eingeben. Sollten Sie die falsche Groß- und Kleinschreibung verwenden, wird Python Ihnen sagen, dass es nicht weiß, was Sie meinen, oder dass es keinen Hilfeeintrag dazu gibt. Es wird Ihnen aber nicht sagen, dass Sie die falsche Groß- und Kleinschreibung benutzt haben. Irgendwann werden Computer wissen, was Sie eingeben wollten, und sich nicht danach richten, was Sie tatsächlich eingegeben haben, aber noch ist es nicht so weit.

Python in der Kommandozeile beenden

Vielleicht möchten Sie Python irgendwann verlassen. Ja, schwer vorstellbar, aber manche Leute haben noch etwas anderes zu tun, als den ganzen Tag mit Python herumzuspielen. Es gibt zwei Standard- und sehr viele andere Methoden, wie Sie Python beenden können. Generell sollten Sie eine der Standardmethoden verwenden, damit sichergestellt ist, dass Python sich wie erwartet verhält. Die anderen Methoden funktionieren aber auch, wenn Sie mit Python nur etwas ausprobieren und nicht ernsthaft damit arbeiten wollen. Die zwei Standardmethoden sind:

quit()

exit()

Jede dieser Methoden beendet die interaktive Python-Sitzung. Die Python-Shell (also das Python-Programm) unterstützt beide Befehle.

Beiden Befehle kann man noch einen optionalen Parameter mitgeben. Sie können zum Beispiel quit(5) oder exit(5) eingeben und [Enter] drücken, um die Shell zu beenden. Der numerische Parameter setzt die Umgebungsvariable ERRORLEVEL der Eingabeaufforderung. Diesen Wert können Sie dann in der Kommandozeile abfangen oder in eine Stapeldatei schreiben. Normalerweise benutzt man aber nur quit() oder exit(), wenn in Ihrer Anwendung nichts schiefgegangen ist.

Sie können diesen Weg folgendermaßen ausprobieren:

1. Öffnen Sie eine Kommandozeile oder Terminal.

Die Kommandozeile wird angezeigt.

2. Geben Sie python ein und drücken Sie [Enter], um Python zu starten.

Die Python-Eingabeaufforderung wird angezeigt.

3. Geben Sie quit(5) ein und drücken Sie [Enter].

Die normale Eingabeaufforderung wird angezeigt.

4. Geben Sie echo %ERRORLEVEL% ein und drücken Sie [Enter].

Ihnen wird der Fehlercode, wie in Abbildung 3.11 dargestellt, angezeigt. Sollten Sie mit anderen Systemen als Windows arbeiten, müssen Sie vielleicht etwas anderes eingeben als echo %ERRORLEVEL%. Wenn Sie beispielsweise mit einem Bash-Skript arbeiten, geben Sie stattdessen echo $ ein.

Abbildung 3.11: Geben Sie einen Fehlercode aus, wenn Sie anderen den Austrittsstatus Ihrer Anwendung mitteilen wollen.

Die gebräuchlichste Methode, die nicht zu den Standardmethoden gehört, ist, einfach die Schließen-Schaltfläche der Kommandozeile oder des Terminals zu drücken. Das bedeutet, dass Ihre Anwendung keine Gelegenheit mehr bekommt, wichtige Aufräumarbeiten durchzuführen, was zu ungewünschtem Verhalten führen kann. Es ist immer besser, Python ordentlich zu beenden, wenn Sie nicht gerade nur durch die Hilfe blättern.

Ihnen stehen auch noch weitere Befehle zum Schließen der Kommandozeile zur Verfügung, wenn nötig. In den meisten Fällen brauchen Sie diese speziellen Befehle aber nicht, sodass Sie den Rest dieses Abschnitts überspringen können, wenn Sie möchten.

Verwenden Sie exit() oder quit(), kümmert sich Python darum, dass alles schön und ordentlich ist, bevor Sie Ihre Sitzung verlassen. Vermuten Sie jedoch, dass eine Sitzung eh nicht ordnungsgemäß beendet wird, können Sie die Kommandozeile auch mit diesen beiden Befehlen beenden:

sys.exit()

os._exit()

Diese beiden Befehle werden nur im Notfall verwendet. Der Erste, sys.exit(), bietet Ihnen spezielle Funktionalität zur Fehlerbehandlung, die Sie in Kapitel 9 kennenlernen werden. Der Zweite, os._exit(), beendet Python, ohne die üblichen Aufräumarbeiten durchzuführen. In beiden Fällen müssen Sie die erforderlichen Module importieren, also entweder sys oder os, bevor Sie die darin enthaltenen Befehle verwenden können. Daher müssen Sie den folgenden Code eingeben, um den Befehl sys.exit() zu benutzen:

import sys
sys.exit()

Bei der Verwendung von os._exit() müssen Sie einen Fehlercode angeben, da dieser Befehl nur verwendet wird, wenn ein gravierender Fehler aufgetreten ist. Der Aufruf dieses Befehls schlägt fehl, wenn Sie keinen Fehlercode angeben. Um den Befehl os._exit() zu verwenden, benutzen Sie diesen Code (der Fehlercode ist im Beispiel 5):

import os
os._exit(5)

Kapitel 10 erklärt das Importieren von Modulen ganz ausführlich. Für den Moment reicht es, wenn Sie wissen, dass diese Befehle nur für ganz spezielle Zwecke eingesetzt werden und Sie sie normalerweise nicht in einer Anwendung benutzen würden.

4

Ihre erste Anwendung schreiben

In diesem Kapitel

Arbeiten Sie mit der Integrierten Entwicklungsumgebung IDLE

Lernen Sie IDLE kennen

Schreiben Sie Ihre erste Anwendung

Sehen Sie, wie Ihre erste Anwendung funktioniert

Formatieren Sie Ihren Programmcode

Setzen Sie Kommentare sinnvoll ein

Arbeiten Sie mit schon existierenden Anwendungen

Beenden Sie Ihre IDLE-Sitzung

Viele Leute denken, dass die Anwendungsentwicklung eine Art Zauberei ist, die von Zauberern praktiziert wird, die sich Computerfreaks nennen und mit ihrer Tastatur hin und her wedeln, um kleine und große Programme zu produzieren. Nun, die Wahrheit ist sehr viel banaler.

Die Anwendungsentwicklung folgt einer Reihe von Prozessen. Es ist zwar mehr als eine strikte Vorgehensweise, aber mit Sicherheit keine Zauberei. Wie Arthur C. Clark einmal anmerkte: »Jede ausreichend fortgeschrittene Technologie lässt sich nicht von Zauberei unterscheiden« (aus dem Englischen übersetzt). Dieses Kapitel streicht die Zauberei völlig aus Ihrer Vorstellung und führt Sie in die Technik ein. Wenn Sie erst einmal mit diesem Kapitel fertig sind, werden Sie selbst in der Lage sein, eine kleine Anwendung zu schreiben (und Sie müssen dazu nicht zaubern können).

Wie bei allen anderen Tätigkeiten auch verwendet man Werkzeuge (oder auch Tools) zur Anwendungsentwicklung. Im Falle von Python müssen Sie kein Werkzeug verwenden, aber ein Werkzeug erleichtert Ihnen die Arbeit so sehr, dass Sie wirklich gerne eins benutzen möchten. In diesem Kapitel werden Sie als Werkzeug die von Python mitgelieferte Integrierte Entwicklungsumgebung IDLE (Integrated DeveLopment Environment) verwenden. Im vorherigen Kapitel haben Sie das Kommandozeilen-Tool benutzt, um Python ein wenig auszuprobieren. IDLE ist umfangreicher als die Python-Shell und erleichtert das Schreiben von Programmen sehr.

Es gibt sehr viele Werkzeuge, die Sie zum Schreiben von Python-Anwendungen benutzen können. In diesem Buch werde ich nicht besonders viel darüber schreiben, da IDLE jede zu erledigende Aufgabe ausführen kann und bei Python dabei ist. Sobald Sie aber erfahrener werden, finden Sie vielleicht Tools wie PyCharm (https://www.jetbrains.com/pycharm) für die Arbeit mit Python komfortabler als IDLE. Eine große Auswahl an Entwicklungsumgebungen finden Sie auch unter https://wiki.python.org/moin/IntegratedDevelopmentEnvironments.

Die Integrierte Entwicklungsumgebung IDLE kennenlernen

Sie können buchstäblich jede gewünschte Python-Anwendung mit einem Texteditor schreiben. Solange der Editor reinen Text und nicht formatierten Text, wie eine Textverarbeitungssoftware, ausgibt, können Sie ihn zum Schreiben von Python-Code verwenden. Das Verwenden eines Texteditors ist aber nicht besonders effizient oder einfach. Um den Entwicklungsprozess zu vereinfachen, haben Programmierer Integrierte Entwicklungsumgebungen (IDEs) geschrieben. Die IDE, die bei Python dabei ist, heißt IDLE. Aber es ist gibt auch viele andere IDEs, mit denen man mit Python arbeiten kann.

Der Funktionsumfang der IDEs ist verschieden. Daher gibt es auch so viele davon auf dem Markt. IDLE bietet einen Basisfunktionsumfang, den die meisten anderen IDEs auch haben. Folgende Funktionalität stellt es zur Verfügung:

Python-Code schreiben

Schlüsselwörter und bestimmte Arten von Spezialtext erkennen und hervorheben

Sowohl einfaches Bearbeiten (wie Ausschneiden, Kopieren und Einfügen) als auch codespezifische Bearbeitung (zum Beispiel die Klammern hervorheben, die einen Ausdruck umschließen)

Python-Dateien speichern und öffnen

Den Python-Pfad durchsuchen, um Dateien schnell zu finden

Python-Klassen durchsuchen und finden

Einfache Debugging-Aufgaben ausführen (Fehler im Code finden und beheben)

IDLE unterscheidet sich von der Kommandozeilenversion dadurch, dass es eine vollwertige grafische Benutzeroberfläche bietet und dass Sie viele Aufgaben sehr viel einfacher als in der Kommandozeile erledigen können. Außerdem stellt die Kommandozeile nicht dieselben Funktionen wie IDLE zur Verfügung. Klar können Sie Ihr Programm auch in der Kommandozeile debuggen, aber das ist ein schwieriger und fehleranfälliger Prozess. IDLE zu verwenden, ist um einiges leichter.

IDLE starten

Sie finden IDLE in dem Verzeichnis Python 3.4.2 auf Ihrem System unter IDLE (PYTHON GUI). Klicken oder doppelklicken Sie auf diesen Eintrag (abhängig von Ihrem Betriebssystem), wird der IDLE-Editor wie in Abbildung 4.1 zu sehen, angezeigt. Die zwei Zeilen Text enthalten Informationen über das ausführende System und Vorschläge zu Befehlen, die Sie ausprobieren können. Der genaue Wortlaut hängt von Ihrem System ab. Sie sehen je nach Python-Version, Betriebssystem und wie Sie IDLE und Ihr System konfiguriert haben, Unterschiede zu den Screenshots in diesem Kapitel.

Abbildung 4.1: IDLE bietet Ihnen eine grafische Benutzeroberfläche zum Programmieren Ihrer Anwendungen.

Die Standardbefehle verwenden

IDLE bietet genau dieselben Befehle wie die Kommandozeilenversion von Python an. Es listet diese nicht auf, weil es davon ausgeht, dass Sie die Funktionen der grafischen Benutzeroberfläche von IDLE verwenden. Sie können jedoch trotzdem help() eingeben und [Enter] drücken, um in den Hilfemodus zu wechseln, auch wenn dieser Befehl nicht, wie in der Kommandozeilenversion, mit den initial angezeigten Befehlen für IDLE aufgelistet wird. Abbildung 4.2 zeigt Ihnen die Ausgabe.

Abbildung 4.2: Sie haben in IDLE auf dieselben Befehle Zugriff wie in der Kommandozeilenversion.

Die Farbcodierung verstehen

In diesem Buch können Sie die Farbcodierung oder auch Syntax-Highlighting, die Sie sehen, wenn Sie help() eingeben, nicht erkennen, aber im Editor können Sie sie sehen. Die Farbcodierung hilft Ihnen, Befehle schneller zu erkennen und sie von anderem Text zu unterscheiden. Drücken Sie [Enter], um den Hilfemodus zu beenden. Wie in der Kommandozeilenversion sehen Sie auch hier einen beschreibenden Text, wenn Sie eine Aktion ausführen.

Geben Sie nun print(´Hier steht ein Text.´) ein und drücken Sie [Enter]. Sie sehen die erwartete Ausgabe, wie Sie sie sonst auch sehen (siehe Abbildung 4.3). Beachten Sie jedoch die Farbcodierung. Der Befehl print() wird als lila Text angezeigt, um zu kennzeichnen, dass es sich um einen Befehl handelt. Der Text innerhalb des Befehls print() ist grün, um anzuzeigen, dass es sich um eine Zeichenkette handelt. Die Ausgabe wird blau dargestellt. Die Farbcodierungen macht vieles einfacher – einer der vielen Gründe, warum die Arbeit mit IDLE komfortabler ist als mit der Kommandozeile.

Abbildung 4.3: Durch die Farbcodierung erkennen Sie leicht, welchen Zweck ein Text im Anwendungscode erfüllt.

Die Hilfe in der GUI aufrufen

IDLE macht das Beschaffen von Hilfeinformationen sehr einfach. Wenn Sie sich das Hilfemenü anschauen, sehen Sie drei Einträge, über die Sie an Hilfeinformationen kommen:

About IDLE: Zeigt Ihnen aktuelle Informationen zu IDLE an.

IDLE Help: Zeigt eine Textdatei mit Informationen über die Arbeit mit der IDLE-IDE an. Hier finden Sie zum Beispiel eine Liste mit IDLE-Befehlen.

Python Docs: Enthält Informationen zur Arbeit mit Befehlen und anderen Elementen von Python.

Wählen Sie HELP|ABOUT IDLE aus, um sich das Dialogfenster ABOUT IDLE anzeigen zu lassen, wie in Abbildung 4.4 zu sehen. Ungefähr in der Mitte des Fensters finden Sie URLs, die auf weitere Hilfeseiten verweisen. Jede der Schaltflächen öffnet eine Textdatei, die nützliche Informationen enthält, insbesondere die README- und die NEWS-Dateien. Klicken Sie auf CLOSE, um das Dialogfenster zu schließen.

Abbildung 4.4: Das Dialogfenster ABOUT IDLE enthält nützliche Informationen, die Sie woanders wahrscheinlich nicht finden.

Was genau Sie sehen, wenn Sie HELP|PYTHON DOCS auswählen, hängt ganz von Ihrem System ab. Abbildung 4.5 zeigt die Windows-Version des Dialogfensters. Die Datei PYTHON DOCS enthält Informationen darüber, wie man mit Python arbeitet und damit Anwendungen erstellt. Es gibt sogar einen Abschnitt mit Tutorials, wo Sie nach dem Durcharbeiten dieses Buches zusätzlich hilfreiche Tipps finden.

Abbildung 4.5: Benutzen Sie die Python-Dokumentation, um noch mehr über das Erstellen von Anwendungen mit Python zu erfahren.

IDLE konfigurieren

Denkt man mal genauer darüber nach, ist IDLE im Grunde eigentlich nur ein schicker Texteditor. Daher ist es auch nicht verwunderlich, dass Sie es so konfigurieren können, dass Sie Text noch besser bearbeiten können. Wählen Sie OPTIONS|CONFIGURE IDLE…, um sich das Dialogfenster IDLE PREFERENCES anzeigen zu lassen, das in Abbildung 4.6 dargestellt ist. Hier können Sie zum Beispiel auswählen, welchen Font IDLE benutzen soll, um Text anzuzeigen. In der Abbildung sehen Sie die Registerkarte FONTS/TABS, auf dem Sie die Größe und den Typ des Fonts für den Text ebenso wie die Anzahl der Leerzeichen bei einer Einrückung (siehe auch den Abschnitt Den Nutzen von Einrückungen verstehen) einstellen können.

Wie schon erwähnt, verwendet IDLE Farbcodierungen, um das Lesen und Verstehen des Codes zu vereinfachen. Auf der Registerkarte HIGHLIGHTING können Sie die Farben für die Hervorhebungen auswählen, wie in Abbildung 4.7 zu sehen. Beachten Sie, dass Ihre Einstellungen als Theme (Profil) gespeichert werden. Sie können verschiedene Themes für verschiedene Zwecke anlegen. Sie können sich ein Theme für Ihren Laptop oder ein anderes Gerät, mit dem Sie unter sehr hellen Bedingungen arbeiten, und ein weiteres für dunklere Lichtverhältnisse anlegen.

Auch wenn in diesem Buch Tastenkürzel aufgrund von Systemunterschieden nicht sehr oft verwendet werden, werden sie trotzdem von IDLE unterstützt. Die Tastenkürzel auf der Registerkarte KEYS in Abbildung 4.8 sehen vielleicht anders als die auf Ihrem System aus. In IDLE gibt es Tastenkürzel für Windows, Mac OS X und UNIX-Systeme. Sie können eins dieser Profile auswählen, indem Sie auf die kleine Schaltfläche neben dem Eintrag IDLE CLASSIC WINDOWS klicken (siehe Abbildung 4.8). Sie können auch Ihr eigenes benutzerdefiniertes Profil definieren, das von einer anderen Anwendung, die Sie sonst verwenden, abgeleitet ist.

Abbildung 4.6: Konfigurieren Sie sich IDLE ganz für Ihre persönlichen Anforderungen.

Abbildung 4.7: Ändern Sie die Hervorhebungen so, dass Sie den Text besser lesen können.

Abbildung 4.8: Verwenden Sie die Tastenkürzel, die für Sie als Entwickler am meisten Sinn machen.

Die Registerkarte GENERAL (Allgemein) in Abbildung 4.9 steuert die Art und Weise, wie IDLE funktioniert. Zum Beispiel können Sie mit STARTUP PREFERENCES IDLE sagen, dass es eine Python-Shell (zum Experimentieren) oder ein Editierfenster (zum Schreiben eines Programms) öffnen soll. Standardmäßig wird eine Python-Shell geöffnet, sodass Sie mit Python herumexperimentieren und neue Techniken ausprobieren können. Sie können mit AUTOSAVE PREFERENCES auch festlegen, ob IDLE Sie auffordern soll, Ihre Dateien zu speichern, bevor eine Anwendung ausgeführt wird (immer eine gute Idee, wenn die Anwendung dazu neigt, das System zum Abstürzen zu bringen), oder mit INITIAL WINDOW SIZE die initiale Größe eines Fensters, das Sie erstellen, bestimmen. PARAGRAPH REFORMAT WIDTH legt die Breite des Textes in Ihrem Fenster fest, damit dieser schön übersichtlich bleibt. Die Standardeinstellungen passen meist schon sehr gut, sodass es nicht wirklich einen Grund gibt, sie zu ändern.

Mit der Funktion ADDITIONAL HELP SOURCES können Sie weitere Quellen für Hilfeinformationen in IDLE einbinden. Zum Beispiel können Sie dort einen Link zu einer Website, wie die Onlinedokumentation von Python unter https://docs.python.org/release/3.4.2, angeben. Um eine neue Quelle hinzuzufügen, klicken Sie auf ADD. Sie sehen nun das Dialogfenster NEW HELP SOURCE aus Abbildung 4.10, wo Sie den Text, der im Hilfemenü für diese Quelle angezeigt werden soll, und den Speicherort (Festplatte oder online) auswählen können. Wenn Sie alles eingegeben haben, klicken Sie auf OK und die Quelle wird zum IDLE-Menü HELP hinzugefügt. Auf der Registerkarte GENERAL gibt es auch Schaltflächen zum Bearbeiten und Entfernen von Quellen.

Abbildung 4.9: Die Registerkarte GENERAL passt die Funktionsweise von IDLE an.

Abbildung 4.10: Sie können sich neue Hilfequellen anlegen, um Ihnen die Anwendungsentwicklung zu erleichtern.

Eine Anwendung erstellen

Nun wird es Zeit für Ihre erste Python-Anwendung. Ihr initiales Python-Konsolenfenster taugt zum Erstellen einer Anwendung nicht, also müssen Sie zunächst ein neues Editierfenster für die Anwendung öffnen. Sie werden dort die erforderlichen Befehle eingeben und dann die Datei auf Ihrer Festplatte speichern.

Ein neues Fenster öffnen

Das initiale Fenster der Python-Shell ist zum Experimentieren okay, aber zum Schreiben Ihrer Anwendung brauchen Sie ein schönes, neues Editierfenster. Das Python-Shell-Fenster ist interaktiv, das heißt, dass Sie sofort eine Rückmeldung auf die von Ihnen eingegebenen Befehle bekommen. Das Editierfenster stellt eine statische Umgebung zur Verfügung, wo Sie Befehle eingeben, speichern und schließlich ausführen können, wenn Sie genug Befehle für Ihre Anwendung eingegeben haben. Die beiden Fenster verfolgen zwei ganz unterschiedliche Zwecke.

Wählen Sie FILE|NEW FILE aus, um ein neues Fenster zu öffnen. Es öffnet sich ein Fenster wie das in Abbildung 4.11. Beachten Sie, dass in der Titelzeile UNTITLED (Unbenannt) statt PYTHON 3.4.2 SHELL steht. Ein Python-Shell-Fenster wird immer das Wort SHELL in der Titelzeile enthalten. Die beiden Fenstertypen haben auch teilweise unterschiedliche Einträge in den Werkzeugleisten. Zum Beispiel beinhaltet das Editierfenster den Befehl RUN (Ausführen), den Sie später zum Testen Ihrer Anwendung brauchen.

Abbildung 4.11: Verwenden Sie das Editierfenster, um Anwendungen zu erstellen.

Die Arbeit mit dem Editierfenster funktioniert genauso wie mit jedem anderen Texteditor. Sie haben Zugriff auf grundlegende Bearbeitungsfunktionen, wie Kopieren, Ausschneiden und Einfügen. Wenn Sie [Enter] drücken, erzeugt das einen Zeilenumbruch und führt nicht, wie in dem Python-Shell-Fenster, einen Befehl aus. Der Grund ist, dass das Editierfenster eine statische Umgebung ist – eine, in die Sie Befehle eingeben und für den späteren Gebrauch speichern.

Das Editierfenster bietet auch Spezialbefehle zur Formatierung des Textes an. Die Abschnitte Den Nutzen von Einrückungen verstehen und Kommentare einfügen dieses Kapitels beschreiben, wie diese Formatierungsfunktionen verwendet werden können. Für den Moment ist nur wichtig, dass diese Formatierungsbefehle sich anders verhalten als die in einem herkömmlichen Texteditor, da sie das Aussehen des Codes und nicht das von herkömmlichem Text verändern. Viele der Formatierungsfeatures funktionieren automatisch, sodass Sie sich darüber im Moment keine Gedanken machen müssen.

Schließlich stellt Ihnen das Editierfenster den Zugriff auf Befehle zur Verfügung, die Python die Schritte Ihres programmierten Arbeitsablaufs einen nach dem anderen abarbeiten lassen. Dieser Vorgang nennt sich auch das Ausführen der Anwendung. Der Abschnitt Die Anwendung ausführen dieses Kapitels beschreibt diesen Prozess detaillierter.

Den Befehl eingeben

Wie im Python-Shell-Fenster auch, können Sie in das Editierfenster einfach einen Befehl eingeben. Damit Sie sehen, wie das funktioniert, geben Sie print() ein. Beachten Sie, dass das Editierfenster nützliche Informationen über den print()-Befehl zur Verfügung stellt, wie in Abbildung 4.12 zu sehen. Die Information ist sehr knapp gehalten, sodass Sie sie jetzt vielleicht noch nicht verstehen. Im Verlauf des Buches werden Sie noch mehr über den Befehl print() erfahren und dann werden die Hilfeinformationen des Editierfensters auch mehr Sinn für Sie ergeben. Für den Augenblick sollten Sie sich auf das Wort value konzentrieren. Der print()-Befehl braucht einen Wert, den er ausgeben kann, bevor er etwas ausgeben kann, und Sie werden noch eine Menge verschiedener Werte im Verlauf des Buches kennenlernen.

Abbildung 4.12: Das Editierfenster stellt Ihnen hilfreiche Informationen über die von Ihnen eingegebenen Befehle zur Verfügung.

Schließen Sie den Befehl ab, indem Sie "Dies ist ein einfaches Python-Programm.") eingeben und [Enter] drücken. Ihre Anwendung sollte nun so aussehen wie die in Abbildung 4.13. Dies ist eine der einfachsten Anwendungen, die Sie mit Python erstellen können.

Abbildung 4.13: Eine vollständige Anwendung muss nicht lang sein.

Die Datei speichern

Sie könnten die Anwendung nun ausführen, wenn Sie wollten. Es ist aber immer eine gute Idee, Ihre Anwendung vor der Ausführung zu speichern. Auf diese Weise ist Ihr Code gesichert, auch wenn Sie einen Fehler gemacht haben, der Python oder Ihr System nicht mehr reagieren lässt. Das Speichern der Anwendung ermöglicht es Ihnen, sich später noch mal anzuschauen, was schiefgelaufen ist, Korrekturen vorzunehmen und die Anwendung noch mal auszuführen.

Wählen Sie FILE|SAVE, um das Dialogfenster SPEICHERN UNTER anzuzeigen, wie in Abbildung 4.14 zu sehen. Das Editierfenster schlägt von sich aus das Verzeichnis PYTHON34 zum Speichern der Anwendung vor. Dort liegt aber Python selbst und es ist keine gute Idee, Ihren Anwendungscode im selben Verzeichnis zu speichern.

Abbildung 4.14: Das Dialogfenster SPEICHERN UNTER bietet Ihnen die Möglichkeit, Ihre Anwendung zu speichern.

Der Beispielcode zu diesem Buch ist in einem Verzeichnis namens MPPLFD (Mit Python programmieren lernen für Dummies) enthalten. Der Code für dieses Kapitel findet sich im Unterverzeichnis \MPPLFD\KAPITEL04 der zum Download bereitgestellten Dateien. Sie können eine Verzeichnisstruktur mit ähnlichen Namen erstellen, während Sie sich durch das Buch arbeiten. Sie können sich auch den Quellcode zum Buch einfach herunterladen und sich die Arbeit sparen, den Beispielcode einzugeben.

Geben Sie ErsteApp.py in das Feld DATEINAME des SPEICHERN UNTER-Dialogs ein und klicken Sie auf SPEICHERN. Ihr Anwendungscode ist nun auf der Festplatte gespeichert und Sie können jederzeit darauf zugreifen. Wenn Sie nun zum Editierfenster zurückkehren, ändert sich der Inhalt der Titelleiste, wie in Abbildung 4.15 zu sehen. Beachten Sie, dass die Titelzeile den vollständigen Pfad zur Anwendung enthält.

Abbildung 4.15: Eine gespeicherte Anwendung wird mit ihrem Namen und Dateipfad in der Titelleiste angezeigt.

Die Anwendung ausführen

Anwendungen sind zu nichts nutze, wenn man sie nicht ausführen kann. Python stellt eine große Auswahl an Methoden zum Ausführen jeglicher Anwendung bereit. Dieser Abschnitt beschreibt die einfachste Methode, eine Anwendung auszuführen, nachdem Sie sie erstellt haben. Weitere Methoden werden in dem Abschnitt Laden und Ausführen existierender Anwendungen dieses Kapitels erklärt. Eine wichtige Sache, die Sie daran erkennen, dass Python eine extrem flexible Umgebung zur Verfügung stellt. Auch wenn eine Methode zur Ausführung einer Aufgabe nicht so richtig für Sie funktioniert, werden Sie mit einer anderen Methode mit Sicherheit Erfolg haben.

Um Ihre erste Anwendung auszuführen, wählen Sie RUN|RUN MODULE aus. Es öffnet sich eine neue Instanz des Python-Shell-Fensters und die Ausgabe Ihrer Anwendung erscheint, wie Abbildung 4.16 zeigt.

Abbildung 4.16: Die Ausgabe der Beispielanwendung erscheint in einem Python-Konsolenfenster.

Die zwei obersten Zeilen der Ausgabe in Abbildung 4.16 sollten Ihnen nun bekannt vorkommen – es sind die Informationen, die immer beim Öffnen der Shell angezeigt werden. Als Nächstes kommt die Nachricht

================================ RESTART ================================

Diese Nachricht wird immer dann ausgegeben, wenn Sie die Anwendung ausführen. Probieren Sie es selbst aus, selektieren Sie das Editierfenster und wählen Sie RUN|RUN MODULE aus. Das ursprüngliche Shell-Fenster kommt in den Vordergrund, eine weitere Nachricht erscheint und Sie sehen wieder die Ausgabe Ihrer Anwendung, wie in Abbildung 4.17 zu erkennen.

Abbildung 4.17: Die Python-Shell zeigt bei der Ausführung der Anwendung jedes Mal eine Restart-Nachricht an.

Den Nutzen von Einrückungen verstehen

Beim Durcharbeiten der Beispiele in diesem Buch werden Sie feststellen, dass manche Zeilen eingerückt sind. Tatsächlich enthalten die Beispiele einen ziemlich großen Anteil an Leerräumen (zum Beispiel die zusätzlichen Zeilen zwischen den Codezeilen). Python ignoriert jegliche Einrückungen in Ihrer Anwendung. Der Hauptgrund, Einrückungen zu verwenden, ist die bessere Lesbarkeit des Codes. So, wie Einrückungen für Gliederungen in Büchern benutzt werden, zeigen Einrückungen im Code die Beziehungen zwischen verschiedenen Codeelementen an.

Sie werden mit den verschiedenen Einsatzgebieten von Einrückungen vertrauter, je weiter Sie sich durch die Beispiele im Buch vorarbeiten. Trotzdem ist es jetzt schon wichtig zu wissen, warum Einrückungen verwendet werden und wie man sie platziert. Also wird es Zeit für ein weiteres Beispiel. Die folgenden Schritte leiten Sie bei der Erstellung eines neuen Beispiels an. In diesem Beispiel verwenden Sie Einrückungen, um die Beziehungen zwischen Anwendungselementen sichtbarer und für später verständlicher zu machen.

1. Wählen Sie FILE|NEW FILE aus.

IDLE öffnet ein neues Editierfenster für Sie.

2. Geben Sie print("Dies ist eine wirklich lange Zeile mit Text, die "+ ein.

Sie sehen, dass der Text auf dem Bildschirm, wie erwartet, ganz normal angezeigt wird. Das Pluszeichen teilt Python mit, dass weiterer Text angezeigt werden soll. Verknüpft man Text aus mehreren Zeilen zu einem langen Stück Text, wird das Konkatenation oder Verkettung genannt. Sie werden über diese Funktion später im Buch noch etwas erfahren, also machen Sie sich jetzt keine Gedanken darüber.

3. Drücken Sie [Enter].

Der Einfügemarke erscheint nun nicht, wie Sie vielleicht erwarten, am Anfang der Zeile. Stattdessen taucht sie direkt unter dem ersten Anführungszeichen auf, wie Abbildung 4.18 zeigt. Dieses Feature wird automatische Einrückung genannt und unterscheidet einen Codeeditor von einem herkömmlichen Texteditor.

4. Geben Sie "in mehreren Zeilen Text in der Quellcodedatei erscheint.") ein und drücken Sie [Enter].

Beachten Sie, dass die Einfügemarke wieder zum Anfang der Zeile zurückspringt. Sobald IDLE merkt, dass Sie am Ende eines Codeabschnitts angekommen sind, rückt er den Text automatisch wieder an die ursprüngliche Position aus.

5. Wählen Sie FILE|SAVE aus.

Das Dialogfenster SPEICHERN UNTER öffnet sich.

6. Geben Sie LANGEZEILE.PY in das Feld DATEINAME ein und klicken Sie auf SPEICHERN, um die Datei zu speichern.

7. Wählen Sie RUN|RUN MODULE aus.

Ein neues Python-Shell-Fenster öffnet sich, das den Text anzeigt. Auch wenn der Text in mehreren Zeilen in der Quelldatei angezeigt wird, erscheint er in der Ausgabe trotzdem in einer Zeile, wie Sie in Abbildung 4.19 sehen können.

Abbildung 4.18: Das Editierfenster rückt bestimmte Arten von Text automatisch ein.

Abbildung 4.19: Verwenden Sie Verkettung von Text, damit mehrere Zeilen Text in einer Zeile in der Ausgabe erscheinen.

Kommentare einfügen

Wir machen uns ständig Notizen für uns selbst. Wenn Sie einkaufen gehen müssen, schauen Sie zuerst in Ihre Schränke, überlegen, was Sie brauchen, und schreiben eine Einkaufsliste. Im Laden angekommen, schauen Sie sich Ihre Liste an, um sich daran zu erinnern, was Sie brauchen. Die Verwendung von Notizen ist in vielen Bereichen praktisch, zum Beispiel zum Nachhalten einer Konversation zwischen Geschäftspartnern oder um sich die wichtigsten Punkte in einer Vorlesung zu merken. Menschen brauchen Notizen, um ihre Erinnerungen wachzurütteln. Kommentare im Quelltext sind nur eine weitere Form von Notizen. Sie schreiben sie in den Quelltext, um sich später daran zu erinnern, welche Aufgabe der Code an dieser Stelle erfüllt. Die folgenden Abschnitte beschreiben Kommentare etwas genauer.

Kommentare verstehen

Computer brauchen eine bestimmte Methode, um festzustellen, dass der von Ihnen geschriebene Text ein Kommentar ist und kein auszuführender Code. Python stellt Ihnen hier zwei verschiedene Methoden zur Verfügung, um Text als Kommentar und nicht als Code auszuzeichnen. Die erste Methode ist der einzeilige Kommentar. Er verwendet das Doppelkreuzzeichen (#) wie folgt:

# Dies ist ein Kommentar.

print("Python sagt Hallo!") # Dies ist auch ein Kommentar.

Ein einzeiliger Kommentar kann in einer Zeile allein oder hinter ausführbarem Code stehen. Er erscheint in nur einer Zeile. Der einzeilige Kommentar wird üblicherweise für kurzen beschreibenden Text verwendet, wie die Erklärung eines bestimmten Codestücks.

Sollten Sie einen längeren Kommentar schreiben müssen, verwenden Sie besser einen mehrzeiligen Kommentar. Ein mehrzeiliger Kommentar beginnt und endet mit drei Anführungszeichen (»»»), ungefähr so:

"""

Anwendung: Kommentare.py

Verfasser: John

Zweck: Zeigen, wie man Kommentare benutzt

"""

Alles zwischen den beiden dreifachen Anführungsstrichen wird als Kommentar angesehen. Mehrzeilige Kommentare werden typischerweise für längere Beschreibungen zum Beispiel über den Verfasser, den Zweck einer Anwendung und die Aufgaben, die sie erfüllt, genutzt. Es gibt keine wirklichen Regeln, wofür Sie Kommentare einsetzen können. Das Hauptziel ist hier, dem Computer mitzuteilen, was ein Kommentar ist und was nicht, sodass er nicht durcheinandergebracht wird.

Auch wenn einzeilige und mehrzeilige Kommentare jeweils Kommentare sind, kann man mit IDLE doch den Unterschied recht einfach erkennen. Mit dem Standardfarbschema erscheinen einzeilige Kommentare in roter Schrift, während mehrzeilige Kommentare in grüner Schrift dargestellt werden. Python ist die Farbgebung egal; sie soll für Sie als Entwickler nur eine Hilfestellung sein.

Kommentare als Erinnerungsstützen verwenden

Viele Leute verstehen den Sinn von Kommentaren nicht wirklich – sie wissen gar nichts mit den Notizen im Code anzufangen. Stellen Sie sich vor, dass Sie heute ein Stück Code schreiben und es sich dann Jahre lang nicht mehr anschauen. Sie brauchen Kommentare, um auch später noch zu wissen, welchen Zweck der Code erfüllt und warum Sie ihn geschrieben haben. Im Folgenden finden Sie ein paar gute Gründe, warum Sie Ihren Code kommentieren sollten:

Sich selbst daran erinnern, was der Code macht und warum Sie ihn geschrieben haben

Anderen erklären, wie Ihr Code zu warten ist

Ihren Code für andere Entwickler verständlich machen

Ideen für spätere Aktualisierungen festhalten

Eine Liste mit Quellen aufschreiben, die Sie für das Schreiben des Codes verwendet haben

Eine Liste mit Verbesserungen, die Sie gemacht haben, nachhalten

Sie können Kommentare auch für viele andere Dinge benutzen, aber das sind die gebräuchlichsten. Schauen Sie sich an, wie Kommentare in den Beispielen dieses Buches verwendet werden, speziell dort, wo der Code etwas komplexer wird. Je komplexer Ihr Code wird, desto mehr Kommentare brauchen Sie und desto besser müssen die Kommentare wiedergeben, was Sie sich merken müssen.

Mit Kommentaren den Code von der Ausführung abhalten

Entwickler verwenden Kommentare auch manchmal, um bestimmte Codezeilen nicht ausführen zu lassen (aus als Auskommentieren bezeichnet). Sie müssen das vielleicht machen, um herauszufinden, ob eine bestimmte Zeile Ihre Anwendung abstürzen lässt. Tatsächlich ist das eine so übliche und nützliche Art, mit Code zu arbeiten, dass IDLE eine Funktion für diesen Kommentartyp direkt integriert hat. Hier ein Beispiel, wie das funktioniert. Sagen wir, Sie haben eine Anwendung, wie die in Abbildung 4.20 (Sie finden sie in der Datei Kommentare.py in den herunterladbaren Beispielen).

Sie möchten vielleicht die Zeile print("Dieser Code ist auskommentiert.") auskommentieren. Damit Sie das hinbekommen, setzen Sie die Einfügemarke an den Anfang der Zeile oder markieren Sie einfach die gesamte Zeile und wählen Sie FORMAT|COMMENT OUT REGION aus. IDLE fügt dann einen einzeiligen Kommentar in den Code ein, wie in Abbildung 4.21 gezeigt. Beachten Sie, dass dieser Kommentar zwei Doppelkreuzzeichen (##) verwendet, um ihn von den manuell eingefügten einzeiligen Kommentaren zu unterscheiden.

Abbildung 4.20: Manchmal müssen Entwickler Codezeilen auskommentieren.

Abbildung 4.21: Kommentieren Sie Code aus, den Sie nicht von Python ausführen lassen wollen.

Natürlich wissen Sie jetzt noch nicht, ob das Auskommentieren geklappt hat. Speichern Sie die Datei und wählen Sie dann RUN|RUN MODULE aus. Es öffnet sich eine neue Python-Shell mit nur einer Zeile in der Ausgabe, wie in Abbildung 4.22 zu sehen. Der erste nicht auskommentierte print()-Befehl wird also ganz normal ausgeführt, der zweite aber nicht.

Abbildung 4.22: Auskommentierte Codezeilen werden nicht ausgeführt.

Um den Code wieder zur Anwendung hinzuzufügen, setzen Sie die Einfügemarke wieder an den Anfang der Zeile und wählen Sie FORMAT|UNCOMMENT REGION aus. IDLE entfernt den Kommentar, den es zuvor eingefügt hat, wieder. Speichern Sie die Datei und wählen Sie dann RUN|RUN MODULE aus, um sich das Ergebnis anzuschauen. Diesmal sollten beide print()Befehle ausgeführt werden, wie in Abbildung 4.23 zu sehen.

Abbildung 4.23: Beide print()-Befehle werden ausgeführt, wenn keiner auskommentiert ist.

Sie können mehrere Zeilen Code auf einmal auskommentieren, indem Sie diese Zeilen alle markieren und FORMAT|COMMENT OUT REGION auswählen. Genauso können Sie auch mehrere Zeilen Code wieder einkommentieren, indem Sie sie markieren und FORMAT|UNCOMMENT REGION auswählen. Es ist nicht notwendig, Zeile für Zeile auszukommentieren beziehungsweise einzukommentieren, es sei denn, Sie müssen nur eine Zeile kommentieren.

Laden und Ausführen existierender Anwendungen

Das Ausführen Ihrer Anwendung direkt, nachdem Sie sie geschrieben haben, ist ganz lustig und spannend, aber irgendwann werden Sie IDLE schließen und nur noch Ihre Datei auf der Festplatte haben. Die Datei enthält Ihre Anwendung, aber Sie müssen wissen, wie Sie diese Datei benutzen, um die Anwendung auszuführen. Python verfügt über einige Methoden, wie Sie das bewerkstelligen können. Die folgenden Abschnitte beschreiben nur drei dieser Wege.

Die Kommandozeile oder das Terminalfenster verwenden

Die Kommandozeile oder das Terminalfenster bieten Ihnen die Möglichkeit, Befehle auszuführen, indem Sie sie eingeben. Sie können auch eine Stapeldatei (auch Batchdatei genannt) schreiben, um mehrere Befehle als Teil eines Stapelprozesses auszuführen. In diesem Fall arbeiten Sie mit der nativen Befehlsumgebung, die Ihr System Ihnen bietet, und nicht mit der speziellen Python-Kommandozeile. In dieser Umgebung geben Sie Befehle ein, um Python zu starten und bestimmte Aufgaben auszuführen. Wenn Sie zum Beispiel ErsteApp.py (beschrieben im Abschnitt Eine Anwendung erstellen dieses Kapitels) ausführen wollen, geben Sie python ErsteApp.py ein und drücken Sie [Enter]. Abbildung 4.24 zeigt die typische Ausgabe. Sie können so jede andere Anwendung auch ausführen.

Abbildung 4.24: Sie können eine Anwendung direkt aus der Kommandozeile ausführen.

Das Editierfenster benutzen

Immer wenn Sie IDLE geöffnet haben, können Sie eine Anwendung in einem Editierfenster öffnen und ausführen, genauso, wie Sie es in den vorangegangenen Abschnitten dieses Kapitels getan haben. Um das zu bewerkstelligen, öffnen Sie mit FILE|OPEN die Datei, die Sie vorher gespeichert haben. Das Dialogfenster ÖFFNEN erscheint. Es sieht dem SPEICHERN UNTER-Dialog aus Abbildung 4.14 sehr ähnlich. Wählen Sie das Verzeichnis, das die Anwendung enthält, in dem Feld SUCHEN IN aus und markieren Sie die gewünschte Datei. Klicken Sie auf ÖFFNEN, um die Datei zu öffnen. Nun können Sie RUN|RUN MODULE auswählen, um die Anwendung auszuführen, so wie Sie es normalerweise auch machen würden.

Das Python-Shell-Fenster oder die Python-Kommandozeile verwenden

Im IDLE-Shell-Fenster oder der Python-Kommandozeile steht Ihnen eine Umgebung zur Verfügung, in der Sie Befehle eingeben und direkt ausführen können. Sie müssen jedoch die richtigen Befehle kennen, um bestimmte Aufgaben ausführen zu können. In diesem Fall ist der Befehl etwas komplizierter als der bisher verwendete print()-Befehl. Um die Anwendung ErsteApp.py ausführen zu können, brauchen Sie einen der zwei folgenden, sehr langweilig aussehenden Befehle:

exec (open("C:\\MPplfD\\Kapitel04\\ErsteApp.py").read())

exec (open("C:/MPplfD/Kapitel04/ErsteApp.py").read())

Die zwei vorhergehenden Befehle sind tatsächlich gleich, verwenden aber zwei verschiedene Schrägstrichtypen. Die Befehle funktionieren aber mit Schrägstrich und Gegenschrägstrich (Backslash) gleich gut. Dieser Befehl sagt Python:

1. Öffne die Datei ErsteApp.py, die im Verzeichnis MPplfD\Kapitel04 auf dem Laufwerk mit dem Buchstaben C liegt (Befehl open()).

2. Lade den Inhalt dieser Datei in die Python-Umgebung (Befehl read()).

3. Führe die Anweisungen aus der Datei aus, nachdem diese geladen wurden (Befehl exec()).

Für einen solchen Befehl ist es eigentlich noch etwas früh, aber Sie werden weiter hinten in diesem Buch lernen, wie Sie solche kombinierten Befehle selbst erstellen können. Für den Moment können Sie den Befehl einfach nur ausprobieren, um zu sehen, dass er funktioniert. Abbildung 4.25 zeigt die allbekannte Ausgabe.

Abbildung 4.25: Verwenden Sie zur Angabe des Speicherorts Ihrer Anwendung Schrägstriche oder Gegenschrägstriche.

IDLE schließen

Wahrscheinlich möchten Sie IDLE gerne schließen, wenn Ihre Sitzung beendet ist. Die Befehle zum Schließen von IDLE können Sie im Menü FILE finden und es gibt dort zwei davon (was ein bisschen verwirrend scheint):

Close: Schließt nur das Fenster, das aktuell den Fokus hat. Sind Sie zum Beispiel nach der Ausführung einer Anwendung gerade in einem Python-Shell-Fenster, dann schließt sich nur dieses Shell-Fenster und nicht das dazugehörige Editierfenster.

Exit: Schließt das aktuelle Fenster und alle dazugehörigen Fenster. Befinden Sie sich wieder in einer Python-Shell nach Ausführung einer Anwendung, schließen sich sowohl das Shell-Fenster als auch das zugehörige Editierfenster.

Wenn Sie ein Fenster schließen, prüft IDLE, ob Sie alle Änderungen gespeichert haben. Wenn Sie die Änderungen nicht gespeichert haben, öffnet sich ein Dialogfenster, das Sie fragt, ob Sie speichern möchten.

Die Befehle FILE|CLOSE und FILE|EXIT betreffen nur die aktuelle Sitzung. Haben Sie beispielsweise zwei verschiedene Python-Dateien geöffnet, müssen Sie jede Datei separat schließen, da jede Datei in einer separaten Sitzung geöffnet wird.

Teil II

Mit der Programmierung loslegen

In diesem Teil . . .

Erfahren Sie, wie man Variablen zur Speicherung von Daten verwendet.

Schreiben Sie Funktionen, um Ihren Code lesbarer zu machen.

Soll Ihre Python-Anwendung eine Entscheidung treffen.

Wiederholen Sie Aufgaben.

Bringen Sie Ihrer Anwendung bei, mit Fehlern umzugehen.

5

Informationen speichern und ändern

In diesem Kapitel

Erfahren Sie etwas über das Speichern von Daten

Lernen Sie verschiedene Arten der Datenspeicherung kennen

Verwenden Sie Datum und Uhrzeit in Ihren Programmen

In Kapitel 3 haben Sie ja schon CRUD kennengelernt, Create, Read, Update und Delete – genau, das war das Kapitel, wo keine kruden Sachen drinstanden. Dieses Akronym ist eine einfache Methode, um sich genau zu merken, was Computerprogramme alles mit den Informationen, die Sie gerne verwalten möchten, machen können. Computererfahrene verwenden noch einen speziellen Ausdruck für Informationen – Daten –, es gibt da einen feinen Unterschied, aber für die Zwecke dieses Buches ist es okay, die Begriffe Daten und Informationen synonym zu verwenden.

Damit Daten einen wirklichen Nutzen haben, müssen Sie sie permanent speichern können. Ansonsten würden alle Ihre Daten verloren gehen, sobald Sie den Computer ausschalten, und der Computer wäre für Sie nur von geringem Nutzen. Außerdem muss Python Regeln vorgeben, wie Daten geändert werden. Tut es das nicht, würden Ihre Programme Amok laufen und unkontrolliert irgendwo Daten ändern. Dieses Kapitel beschäftigt sich damit, Ihre Daten unter Kontrolle zu bringen – damit, wie Daten permanent gespeichert und durch von Ihnen geschriebene Anwendungen verändert werden können.

Informationen speichern

Eine Anwendung braucht schnellen Zugriff auf Daten, ansonsten würde sie für Erledigung ihrer Aufgaben sehr lange brauchen. Darum speichern Programme Daten im Speicher Ihres Computers. Aber dieser speichert die Daten nur temporär. Sobald Sie Ihren Rechner ausschalten, müssen die Informationen permanent gespeichert werden, zum Beispiel auf einer Festplatte, einem Universal-Serial-Bus(USB)-Flashlaufwerk oder einer Secure-Digital(SD)-Karte. Außerdem müssen Sie auch die Art der Informationen berücksichtigen, zum Beispiel, ob es eine Zahl oder ein Text ist. Die folgenden Abschnitte betrachten das Problem der Informationsspeicherung als Teil einer Anwendung genauer.

Variablen als Aufbewahrungsboxen betrachten

Wenn Sie mit Anwendungen arbeiten, speichern Sie Daten in Variablen. Eine Variable ist eine Art Behälter. Immer, wenn Sie mit Daten arbeiten wollen, greifen Sie darauf über Variablen zu. Haben Sie neue Informationen, die Sie speichern wollen, legen Sie sie in einer Variablen ab. Die Daten zu ändern, bedeutet, zunächst auf die Variable zuzugreifen und dann den neuen Wert in der Variablen zu speichern. Genauso, wie Sie Dinge in Kisten lagern, lagern Sie Daten in Variablen (also eine Art Behälter), wenn Sie Programme schreiben.

Computer sind eigentlich ziemlich ordentlich. Jede Variable speichert nur ein einziges Stück Information. Mit dieser Technik findet man ein bestimmtes Stück Information sehr einfach – anders als in Ihrer Abstellkammer, wo sich noch Sachen aus dem alten Ägypten verbergen könnten. Auch wenn die Beispiele, die Sie in den vorherigen Kapiteln bearbeitet haben, keine Variablen verwenden, benutzen die meisten Programme Variablen doch sehr intensiv, um die Arbeit mit Daten zu vereinfachen.

Den richtigen Behälter zur Datenspeicherung verwenden

Man tendiert dazu, Dinge in den falschen Behältern unterzubringen. Sie könnten zum Beispiel ein Paar Schuhe in einem Kleidersack finden und eine Ladung Stifte in einem Schuhkarton. Python mag es allerdings gerne sauber und ordentlich. Daher werden Zahlen in einer Sorte von Variablen gespeichert und Text in einer ganz anderen Art von Variablen. Ja, Sie verwenden in beiden Fällen Variablen, aber die Variablen sind dazu gedacht, eine bestimmte Art von Information zu speichern. Mit spezialisierten Variablen kann man mit den Informationen auch auf verschiedene Weisen arbeiten. Sie müssen sich über die Details jetzt noch keine Gedanken machen, sich aber merken, dass jede Informationsart in einer speziellen Variablen gespeichert wird.

Python verwendet unterschiedliche Variablen, um verschiedene Informationsarten zu speichern, um den Programmierern das Leben zu erleichtern und die Informationen zu schützen. Computer kennen jedoch eigentlich keine Datentypen. Das Einzige, was Computer kennen, sind 0en und 1en, was Abwesenheit oder Anwesenheit von Strom bedeutet. Auf höherer Ebene arbeiten Computer nicht mit Zahlen, aber auch das sind nur Auswirkungen davon, was Computer intern machen. Zahlen, Buchstaben, Datum und Uhrzeit und jegliche andere Art der Information, die Sie sich vorstellen können, werden im Computer irgendwann zu 0en und 1en. Der Buchstabe A wird zum Beispiel als 01000001 oder die Zahl 65 gespeichert. Der Computer hat keine Ahnung von dem Buchstaben A oder von einem Datum wie dem 31.08.2015.

Pythons grundlegende Datentypen

Jede Programmiersprache definiert Variablen, die bestimmte Informationen enthalten, und da ist Python keine Ausnahme. Die Art einer Variablen wird Datentyp genannt. Es ist wichtig, den Datentyp einer Variablen zu kennen, da er verrät, welche Informationen Sie darin finden werden. Wenn Sie außerdem Daten in einer Variablen speichern wollen, müssen Sie dafür eine Variable mit dem richtigen Datentyp haben. Python erlaubt es nicht, dass Text in einer Variablen gespeichert wird, in die eigentlich numerische Werte gehören. Das würde dazu führen, dass der Text zerstört wird und Sie Probleme mit der Anwendung bekommen. In Python können Sie als Datentypen generell Zahlen, Zeichenketten (von Programmierern auch String genannt) und boolesche Werte (also wahr oder falsch, 0 oder 1) unterscheiden, obwohl es sicher noch viel mehr Möglichkeiten gibt, wie man Variablen kategorisieren kann. Die folgenden Abschnitte beschreiben jeden der Standarddatentypen in dieser Klassifikation.

Daten in Variablen ablegen

Um einen Wert in irgendeine Variable zu speichern, machen Sie eine Zuweisung mit dem Zuweisungsoperator (=). Kapitel 6 erklärt Ihnen die ganze Bandbreite der grundlegenden Python-Operatoren genauer, aber diesen einen Operator müssen Sie nun schon jetzt kennenlernen. Damit Sie zum Beispiel die Zahl 5 in einer Variablen meineVar ablegen können, müssen Sie in der Python-Eingabeaufforderung meineVar = 5 eingeben und [Enter] drücken. Auch wenn Python Ihnen dazu erst einmal keine weiteren Informationen liefert, können Sie jederzeit den Variablennamen eingeben und [Enter] drücken, um den Wert der Variablen zu sehen, wie in Abbildung 5.1 gezeigt.

Abbildung 5.1: Verwenden Sie den Zuweisungsoperator, um Informationen in Variablen abzulegen.

Numerische Datentypen verstehen

Menschen neigen dazu, Zahlen zu verallgemeinern. Wir denken, dass 1 und 1.0 dieselbe Zahl sind – die eine hat nur einen Dezimalpunkt. Für uns sind die beiden Zahlen gleich und wir können sie ganz einfach beide benutzen. Python betrachtet sie als zwei verschiedene Arten von Zahlen, da ihre Form eine andere Verarbeitung erfordert. Die folgenden Abschnitte beschreiben die von Python unterstützten Datentypen Integer (Ganzzahlen), Fließkommazahlen und komplexe Zahlen.

Integer

Jedeganze Zahl ist ein Integer. Der Wert 1 ist eine ganze Zahl, also ist sie auch ein Integer. 1.0 hingegen ist keine ganze Zahl; sie hat einen Dezimalteil, ist also kein Integer. Für Integer-Werte benutzt man den Datentyp int.

Variablen haben, genauso wie Aufbewahrungsboxen, eine begrenzte Kapazität. Wenn man versucht, einen zu großen Wert in eine der Aufbewahrungsboxen zu stopfen, wird es zu einem Fehler kommen. In den meisten Betriebssystemen können Sie Zahlen zwischen -9 223 372 036 854 775 808 und -9 223 372 036 854 775 807 in einer int-Variable speichern (das ist der maximale Wert, der in eine 64-Bit-Variable passt). Auch wenn das schon eine sehr große Zahl ist, ist das nicht der Wert unendlich.

Bei der Arbeit mit dem int-Datentyp stehen Ihnen jede Menge interessanter Funktionen zur Verfügung. Viele von ihnen kommen erst später in diesem Buch vor, aber ein Feature stelle ich Ihnen jetzt schon vor. Sie können nämlich bei Integer-Zahlen verschiedene numerische Zahlensysteme verwenden:

Binärsystem: Verwendet nur 0 und 1 als Zahlen.

Oktalsystem: Verwendet die Zahlen 0 bis 7.

Dezimalsystem: Benutzt das normale numerische System.

Hexadezimalsystem: Verwendet die Zahlen 0 bis 9 und die Buchstaben A bis F, insgesamt 16 Zeichen, mit denen man Zahlenwerte zusammensetzen kann.

Sie können Python mitteilen, dass es ein anderes System als das Dezimalsystem benutzen soll, indem Sie eine 0 und einen speziellen Buchstaben zur Zahl hinzufügen. Zum Beispiel ist 0b100 der Wert eins-null-null im Binärsystem (im Dezimalsystem wäre das 4). Für die oben genannten Systeme stehen Ihnen in Python die folgenden Buchstaben zur Verfügung:

b: Binärsystem
o: Oktalsystem
x: Hexadezimalsystem

Sie können numerische Werte auch in andere Systeme mit den Befehlen bin(), oct() und hex() umrechnen lassen. In Abbildung 5.2 ist dargestellt, wie Sie zwischen den Systemen mit diesen Befehlen umrechnen können. Probieren Sie die Befehle aus Abbildung 5.2 ruhig selbst aus, damit Sie verstehen, wie die verschiedenen Systeme funktionieren. In vielen Situationen erleichtert Ihnen das Verwenden eines anderen Systems manches und ein paar dieser Situationen werden Ihnen noch weiter hinten im Buch begegnen. Für den Moment müssen Sie nur wissen, dass der Integer-Datentyp verschiedene Zahlensysteme unterstützt.

Fließkommazahlen

Jede Zahl, die einen Dezimalanteil enthält, ist eine Fließkommazahl. Zum Beispiel hat 1.0 einen Dezimalteil, also ist es eine Fließkommazahl. Viele Leute kommen bei ganzen Zahlen und Fließkommazahlen durcheinander, aber den Unterschied kann man sich ganz einfach merken. Wenn Sie einen Dezimalpunkt sehen, dann ist es eine Fließkommazahl. Python speichert Fließkommazahlen in Variablen des Datentyps float (das kommt aus dem Englischen, wo Fließkommazahl »floating-point number« heißt).

Abbildung 5.2: Integer haben viele interessante Fähigkeiten, unter anderem die Möglichkeit, verschiedene Zahlensysteme zu benutzen.

Fließkommazahlen haben einen Vorteil gegenüber Integer-Werten. Sie können in ihnen immens große oder unglaublich kleine Werte speichern. Wie Integer-Werte auch haben float-Variablen eine bestimmte Kapazität. In ihrem Fall ist in den meisten Systemen der maximale Wert, den eine Variable enthalten kann, ±1,7976931348623157 × 10^308 und der minimale Wert ±2,2250738585072014 × 10^308.

Sie können einer Variablen auf zahlreiche Arten Informationen zuweisen, wenn Sie mit Fließkommazahlen arbeiten. Die zwei gebräuchlichsten Methoden sind, die Zahl direkt, so wie sie ist, anzugeben oder die wissenschaftliche Notation zu verwenden. Wenn Sie die wissenschaftliche Notation verwenden, trennt ein e die Zahl von ihrem Exponenten. Abbildung 5.3 zeigt beide Zuweisungsmethoden. Beachten Sie, dass die Verwendung eines negativen Exponenten einen Teilwert ergibt.

Abbildung 5.3: Fließkommazahlen bieten verschiedene Zuweisungsmethoden an.

Komplexe Zahlen

Wahrscheinlich erinnern Sie sich nicht mehr an komplexe Zahlen aus Ihrer Schulzeit. Eine komplexe Zahl besteht aus einem Real- und einem Imaginärteil, die miteinander verheiratet werden. Wenn Sie komplexe Zahlen total verdrängt haben, können Sie unter http://www.mathematik.de/ger/fragenantworten/erstehilfe/komplexezahlen/komplexezahlen.html Ihr Wissen auffrischen. Die Anwendungsgebiete komplexer Zahlen sind unter anderem die folgenden:

Elektrotechnik

Strömungsdynamik

Quantenmechanik

Computergrafik

Dynamische Systeme

Komplexe Zahlen werden auch woanders eingesetzt, aber diese Liste verschafft Ihnen einen Eindruck. Sollten Sie in keiner dieser Disziplinen arbeiten, werden Ihnen komplexe Zahlen wahrscheinlich nie begegnen. Python ist eine der wenigen Sprachen, die einen integrierten Datentyp für komplexe Zahlen anbietet. Im Verlauf des Buches werden Sie feststellen, dass Python sich sehr gut für die Natur- und Ingenieurswissenschaften eignet.

Der Imaginärteil einer Zahl erscheint jeweils immer mit einem j dahinter. Wenn Sie also eine komplexe Zahl mit einer 3 als Realteil und einer 4 als Imaginärteil erzeugen wollen, machen Sie folgende Zuweisung:

meineKomplex = 3 + 4j

Um sich nun den Realteil der Zahl anzuschauen, geben Sie einfach meineKomplex.real in die Python-Shell ein und drücken [Enter]. Auf die gleiche Weise können Sie sich den Imaginärteil anzeigen lassen, indem Sie meineKomplex.imag in die Python-Eingabeaufforderung eingeben und [Enter] drücken.

Boolesche Werte verstehen

Es scheint verblüffend, aber Computer geben Ihnen immer eine klare Antwort! Ein Computer wird Ihnen nie ein »vielleicht« als Ausgabe zurückgeben. Jede Antwort, die Sie bekommen, ist entweder wahr (True) oder falsch (False). Tatsächlich gibt es einen ganzen Zweig der Mathematik, der sich boolesche Algebra nennt, ursprünglich von George Boole (ein Mega-Mathefreak seiner Zeit) erfunden wurde und auf den sich Computer beziehen, wenn sie Entscheidungen treffen. Die boolesche Algebra gibt es, entgegen anderer Behauptungen, seit 1854 – lange bevor es Computer gab.

In Python verwenden Sie den Datentyp bool, wenn Sie mit booleschen Werten arbeiten. Eine Variable dieses Typs kann zwei Werte enthalten: True oder False. Sie können die Schlüsselwörter True oder False verwenden, um einen Wert zuzuweisen, oder Sie definieren einen Ausdruck, der am Ende wahr oder falsch ergibt. Sie könnten zum Beispiel mein Bool = 1 > 2 eingeben, was False ergeben würde, da 1 auf jeden Fall größer als 2 ist. Der Datentyp bool wird in diesem Buch intensiv genutzt, machen Sie sich jetzt also keine Gedanken, wenn Sie das Konzept noch nicht ganz verstanden haben.

Warum braucht man verschiedene Zahlenarten?

Viele Programmieranfänger (aber auch einige alte Hasen) tun sich schwer zu verstehen, warum man mehr als einen numerischen Datentyp braucht. Letzen Endes können Menschen nur eine Zahlenart verwenden. Damit Sie den Sinn mehrerer Datentypen für Zahlen verstehen, müssen Sie ein bisschen mehr darüber wissen, wie Computer mit Zahlen arbeiten.

Ein Integer wird im Computer als Reihe von Bits gespeichert, die der Computer sofort liest. Der Wert 0100 im Binärsystem ist gleich dem Wert 4 im Dezimalsystem. Zahlen, die einen Dezimalpunkt haben, werden dagegen auf ganz andere Weise gespeichert. Denken Sie an all die Schulstunden über Exponenten zurück, die Sie verschlafen haben – manchmal sind sie jedoch ganz nützlich. Eine Fließkommazahl wird mit einem Vorzeichen (Plus oder Minus), einer Mantisse (dem Teilwert der Zahl), der Basis (im folgenden Beispiel 2) und einem Exponenten gespeichert. Den Fließkommawert bekommen Sie mit der Gleichung:

Wert = Mantisse * 2^Exponent

Es gab mal eine Zeit, da verwendeten alle Computer verschiedene Darstellungen für Fließkommazahlen, aber heutzutage benutzen sie alle den IEEE-754-Standard unter http://grouper.ieee.org/groups/754. Eine vollständige Erklärung, wie Fließkommazahlen genau funktionieren, geht über den Inhalt dieses Buches hinaus, aber Sie finden hier eine gut verständliche Erklärung dazu: http://www.ulthryvasse.de/gleitkommazahlen.html. Aber nichts hilft Ihnen besser, ein Konzept zu verstehen, als das Herumspielen mit den Werten selbst. Sie finden einen sehr interessanten Konverter für Fließkommazahlen unter www.h-schmidt.net/FloatConverter/IEEE754.html, wo Sie auf einzelne Bits klicken können (um sie ein- und auszuschalten), und sehen dann die Fließkommazahl, die herauskommt.

Wie Sie sich vielleicht vorstellen können, verbrauchen Fließkommazahlen aufgrund ihrer Komplexität mehr Platz im Speicher. Außerdem verwenden sie einen ganz anderen Teil des Prozessors – dieser arbeitet langsamer als der Teil für die Rechnungen mit Integer-Werten. Schließlich sind Integer-Werte im Gegensatz zu Fließkommazahlen, die eine Zahl nicht ganz präzise darstellen können und stattdessen nur eine Annäherung geben, genau. Aber Fließkommazahlen können viel größere Werte speichern. Das Fazit ist, dass Dezimalwerte in der realen Welt unvermeidbar sind und Sie Fließkommazahlen brauchen, aber die Verwendung von Integer-Werten, wo möglich, den benötigten Speicherplatz Ihrer Anwendung reduziert und schneller macht. Bei Computern muss man viele Kompromisse eingehen und dieser ist unvermeidbar.

Den Typ einer Variablen bestimmen

Manchmal möchten Sie gerne wissen, welchen Typ eine Variable hat. Vielleicht kann man den Datentyp nicht direkt aus dem Code heraus erkennen oder Sie haben die Informationen aus einer Quelle, deren Quellcode nicht verfügbar ist. Immer wenn Sie den Typ einer Variablen bestimmen wollen, verwenden Sie die Methode type(). Zum Beispiel können Sie den Wert 5 in einer Variablen meinInt speichern, indem Sie meinInt = 5 einge-ben und [Enter] drücken. Sie ermitteln den Typ von meinInt durch die Eingabe von type(meinInt) und das Drücken der Taste [Enter]. Als Ausgabe bekommen Sie <class ´int´>, was bedeutet, dass meinInt einen Wert vom Typ int enthält.

Den Datentyp String verstehen

Unter allen Datentypen werden Strings (was Zeichenkette bedeutet) von Menschen am einfachsten und von Computer gar nicht verstanden. Wenn Sie die vorherigen Kapitel in diesem Buch gelesen haben, dann haben Sie schon einige Strings gesehen. Zum Beispiel verwendet der Beispielcode in Kapitel 4 Strings. Ein String ist einfach eine Gruppierung aus Zeichen, die Sie zwischen zwei Anführungszeichen schreiben. Beispielsweise weist meinStr = "Python ist eine tolle Sprache." der Variablen meinStr einen String zu.

Der Computer erkennt Buchstaben überhaupt nicht. Jeder Buchstabe, den Sie verwenden, ist im Hauptspeicher eine Zahl. Der Buchstabe A ist zum Beispiel die Zahl 65. Probieren Sie es selbst aus und geben Sie ord(A) in die Python-Shell ein und drücken Sie [Enter]. Sie sehen als Ausgabe 65. Sie können jeden beliebigen Buchstaben mit dem Befehl ord() in sein numerisches Äquivalent umwandeln.

Da der Computer Zeichenketten nicht wirklich versteht, Strings aber beim Schreiben von Anwendungen sehr praktisch sind, müssen Sie manchmal eine Zeichenkette in eine Zahl umwandeln. Sie können die Befehle int() oder float() verwenden, um diese Umwandlung durchzuführen. Wenn Sie beispielsweise meinInt = int("123") eingeben und [Enter] drücken, erzeugen Sie eine Integervariable meinInt, die den Wert 123 enthält. Abbildung 5.4 zeigt, wie Sie diese Aufgabe ausführen und den Inhalt und Typ von meinInt prüfen können.

Abbildung 5.4: Einen String in eine Zahl zu konvertieren, ist mit den Befehlen int() und float() ganz einfach.

Mit dem Befehl str() können Sie aber auch Zahlen in Zeichenketten umwandeln. Geben Sie beispielsweise meinStr = str(1234.56) ein und drücken [Enter], erzeugen Sie die Zeichenkette "1234.56" und weisen sie meinStr zu. In Abbildung 5.5 sehen Sie diese Konvertierung und wie Sie den Datentyp prüfen können. Der springende Punkt ist, dass Sie sehr einfach zwischen Zahlen und Zeichenketten hin- und herwechseln können. Spätere Kapitel zeigen, wie diese Umwandlungen viele unmöglich erscheinende Aufgaben lösbar machen.

Abbildung 5.5: Es ist auch möglich, Zahlen in Strings umzuwandeln.

Mit Datum und Zeit arbeiten

Datum und Zeit sind Dinge, mit denen die meisten Leute schon viel arbeiten. In unserer Gesellschaft basiert fast alles auf dem Datum und der Uhrzeit, beispielsweise wann eine Aufgabe fertig sein muss oder fertiggestellt wurde. Wir vereinbaren Termine und planen Ereignisse an einem bestimmten Tag und zu einer bestimmten Uhrzeit. Der Großteil unseres Tages ist durchgeplant. Aufgrund des zeitorientierten Wesens der Menschen sollte man sich anzuschauen, wie Python mit Datum und Uhrzeit umgeht (im Speziellen, wie diese Werte zur späteren Verwendung gespeichert werden). Wie immer verstehen Computer aber nur Zahlen – Datum und Uhrzeit existieren für sie nicht wirklich.

Um mit Datum und Uhrzeit zu arbeiten, müssen Sie in Python etwas Bestimmtes machen. Beim Schreiben von Computerbüchern kommt irgendwann immer eine Henne-Ei-Situation auf und dies ist gerade eine. Um Datum und Uhrzeit zu verwenden, müssen Sie den Befehl import datetime eingeben. Eigentlich nennt man diesen Vorgang das Importieren eines Moduls, worüber Sie in Kapitel 10 mehr erfahren werden. Sie müssen sich über diesen Befehl aber jetzt noch keine Gedanken machen – verwenden Sie ihn einfach, wenn Sie mit Datum und Uhrzeit arbeiten müssen.

Computer haben in ihrem Inneren eine Uhr, aber die Uhren sind für die Menschen, die den Computer benutzen. Ja, manche Software ist auch abhängig von dieser Uhr, aber auch hier geht es eher um die Anforderungen des Menschen als darum, dass der Computer dies wirk-lich bräuchte. Um die aktuelle Uhrzeit zu bekommen, geben Sie einfach datetime. datetime.now() ein und drücken Sie [Enter]. Sie sehen dann das vollständige Datum und die Uhrzeit, wie Sie sie auch auf Ihrer Computeruhr sehen (siehe Abbildung 5.6).

Abbildung 5.6: Lassen Sie sich das aktuelle Datum und die Uhrzeit mit dem Befehl now() ausgeben.

Ihnen ist vielleicht aufgefallen, dass man das Datum und die Uhrzeit in dieser Form schlecht lesen kann. Nehmen wir mal an, dass Sie nur das aktuelle Datum in einem lesbaren Format brauchen. Nun wird es Zeit, dass Sie ein paar Dinge, die Sie in den letzten Abschnitten gelernt haben, kombinieren, um die Aufgabe zu lösen. Geben Sie str(datetime.datetime. now().date()) ein und drücken Sie [Enter]. In Abbildung 5.7 sehen Sie, dass Sie nun etwas Brauchbareres zurückbekommen.

Abbildung 5.7: Bringen Sie Datum und Uhrzeit mit dem Befehl str() in eine lesbare Form.

Interessant zu wissen ist auch, dass Python auch einen Befehl time() hat, mit dem Sie die Zeit eines Datumswerts bestimmen können. Für jede Komponente des Datums und der Uhrzeit gibt es eigene Befehle: day(), month(), year(), hour(), minute(), second() und microsecond(). Spätere Kapitel erklären Ihnen, wie Sie diese verschiedenen Funktionen für Datum und Uhrzeit verwenden können, um Benutzer über das aktuelle Datum und die Zeit auf Ihrem System auf dem Laufenden zu halten.

6

Informationen verwalten

In diesem Kapitel

Erfahren Sie, wie Python Daten sieht

Verwenden Sie Operatoren, um Daten zuzuweisen, zu ändern und
zu vergleichen

Strukturieren Sie Ihren Code mit Funktionen

Interagieren Sie mit dem Benutzer

Ob Sie nun den Begriff Informationen oder Daten verwenden, um auf die Dinge, die Anwendungen verwalten, zu verweisen, ist egal. Tatsache ist aber, dass Sie irgendeine Methode zur Verfügung stellen müssen, um damit zu arbeiten, denn ansonsten hat Ihre Anwendung keinen Nutzen. In diesem Buch meinen die Begriffe Informationen und Daten das Gleiche, da sie es ja auch sind, und in Alltagssituationen kommen beide auch vor, also sollten Sie sich auch an beide gewöhnen. Egal, welchen Begriff Sie verwenden, brauchen Sie Hilfsmittel, um Daten Variablen zuzuweisen, den Inhalt dieser Variablen zu ändern, um bestimmte Aufgaben zu erfüllen und zurückgegebene Ergebnisse mit den gewünschten Ergebnissen zu vergleichen. Dieses Kapitel beschäftigt sich mit allen drei genannten Anforderungen, damit Sie die Daten in Ihrer Anwendung im Griff haben.

Es ist auch sehr wichtig, jetzt Methoden kennenzulernen, die Ihren Code verständlich halten. Natürlich könnten Sie Ihren Code in Form eines langen Programms ohne Struktur schreiben. Aber so ein Programm ist sehr schwer zu verstehen und Sie werden vielleicht manche Dinge mehrmals schreiben müssen, da sie auch mehrmals ausgeführt werden müssen. Funktionen sind eine Methode, mit der Sie Code zusammenfassen können, sodass dieser einfacher zu verstehen ist und bei Bedarf wiederverwendet werden kann.

Anwendungen müssen auch mit dem Benutzer interagieren können. Natürlich gibt es auch Programme, die nichts mit dem Benutzer am Hut haben, aber diese sind sehr selten und tun größtenteils nicht viel. Damit sie für den Anwender nützlich sind, interagieren die meisten Anwendungen mit ihm, um herauszufinden, wie er seine Daten verwalten möchte. In diesem Kapitel erfahren Sie mehr über diesen Prozess. Natürlich wird Ihnen das Thema der Benutzerinteraktion in diesem Buch noch häufiger über den Weg laufen, da es ein wichtiges Thema ist.

Pythons Sicht auf die Daten steuern

Wie in Kapitel 5 schon erwähnt, werden alle Daten auf Ihrem Computer als 0en und 1en gespeichert. Der Computer versteht das Konzept von Buchstaben, booleschen Werten, Datum und Uhrzeit oder irgendwelcher anderen Informationen außer Zahlen nicht. Außerdem sind die Möglichkeiten des Computers, mit Zahlen zu arbeiten, sowohl unflexibel als auch simpel. Sie müssen sich darauf verlassen, dass Python Ihnen das Konzept einer Zeichenkette in eine Form übersetzt, die der Computer verstehen kann, wenn Sie mit Zeichenketten in Python arbeiten. Die Behälter, die Ihr Computer in Form von Variablen erstellt und verwendet, sagen Python, wie es mit den 0en und 1en umgehen muss, die der Computer gespeichert hat. Also ist es wichtig zu wissen, dass Pythons Sicht auf die Daten eine andere ist als Ihre Sicht auf die Daten und die Sicht Ihres Computers auf die Daten – Python spielt aber den Vermittler, um Ihre Anwendungen funktionstüchtig zu machen.

Um Daten in einer Anwendung zu verwalten, muss die Anwendung Pythons Sicht auf die Daten steuern. Die Verwendung von Operatoren, Strukturierungsmethoden wie Funktionen und das Einführen von Benutzereingaben helfen der Anwendung, die Daten zu steuern. Alle diese Techniken basieren zum Teil auf Vergleichen. Um bestimmen zu können, was als Nächstes passieren soll, muss man verstehen, in welchem Zustand die Daten im Moment im Vergleich zu einem anderen Zustand sind. Enthält die Variable gerade Peter, aber Sie wollen gerne, dass sie Maria enthält, dann müssen Sie zuerst wissen, dass sie tatsächlich Peter enthält. Nur dann können Sie die Entscheidung treffen, den Variablenwert in Maria zu ändern.

Vergleiche machen

Pythons Hauptmethode, um Vergleiche zu machen, ist die Verwendung von Operatoren. In der Tat spielen Operatoren auch eine große Rolle bei der Manipulation der Daten. Der noch kommende Abschnitt Mit Operatoren arbeiten erklärt, wie Operatoren funktionieren und wie Sie sie in Anwendungen benutzen können, um Daten auf verschiedene Weise zu verwalten. Spätere Kapitel verwenden intensiv Operatoren für Methoden, um Entscheidungen zu treffen, Aufgaben wiederholt durchzuführen oder mit dem Benutzer auf vielfältige Arten zu interagieren. Die grundlegende Idee von Operatoren ist jedoch, Anwendungen zu ermöglichen, verschiedene Arten von Vergleichen durchzuführen.

In manchen Fällen benutzen Sie extravagante Methoden, um in einer Anwendung Vergleiche durchzuführen. Zum Beispiel können Sie die Ausgaben von zwei Funktionen miteinander vergleichen (wie in dem Abschnitt Funktionsausgaben vergleichen beschrieben). Sie können mit Python auf zahlreichen Ebenen Vergleiche durchführen und somit Daten ohne Probleme in Ihrer Anwendung verwalten. Die Verwendung dieser Techniken versteckt bestimmte Details, sodass Sie sich auf den eigentlichen Vergleich konzentrieren und definieren können, wie auf das Ergebnis des Vergleichs reagiert werden soll, anstatt sich in den Details zu verlieren.

Ihre Auswahl zur Durchführung des Vergleichs beeinflusst die Art und Weise, wie Python die Daten betrachtet, und bestimmt die Dinge, die Sie tun können, um die Daten nach dem Beenden des Vergleichs verwalten zu können. All diese Funktionen erscheinen im Moment vielleicht absurd komplex, Sie sollten sich für den Moment aber nur merken, dass Anwendungen Vergleiche benötigen, um mit Daten korrekt umzugehen.

Wie Computer Vergleiche machen

Computer verstehen nichts von Strukturen, wie zum Beispiel Funktionen oder irgendwelche anderen Strukturen, die Sie mit Python erstellen können. Diese Strukturierungsmöglichkeiten sind nur zu Ihrem Vorteil, nicht zu dem des Computers. Computer unterstützen jedoch das Konzept von Operatoren direkt. Die meisten Python-Operatoren haben einen direkten Bezug zu einem Befehl, den der Computer sofort versteht. Fragen Sie zum Beispiel, ob eine Zahl größer als eine andere ist, kann der Computer diese Berechnung unmittelbar mit einem Operator ausführen. (Der folgende Abschnitt behandelt Operatoren im Detail.)

Manche Vergleiche können nicht direkt ausgeführt werden. Computer arbeiten nur mit Zahlen. Wenn Sie Python bitten, zwei Zeichenketten miteinander zu vergleichen, vergleicht Python eigentlich die Zahlenwerte jedes Zeichens des Strings miteinander. Der Buchstabe A ist eigentlich die Zahl 65 für den Computer. Der Kleinbuchstabe a hat einen anderen Zahlenwert – 97. Daraus folgt, dass Sie vielleicht meinen, dass ABC und abc das Gleiche wären, aber der Computer ist da anderer Meinung – er betrachtet sie als verschieden, da die Zahlenwerte der einzelnen Buchstaben anders sind.

Mit Operatoren arbeiten

Operatoren sind die Grundlage sowohl für die Steuerung als auch die Verwaltung von Daten in einer Anwendung. Sie verwenden Operatoren zum Vergleich eines Informationsstücks mit einem anderen und um Informationen in einer einzelnen Variablen zu ändern. Operatoren sind wesentlich, um jegliche Aufgaben, die etwas mit Mathematik zu tun haben, auszuführen, und insbesondere, um Daten Variablen zuzuweisen.

Damit Sie einen Operator verwenden können, müssen Sie entweder eine Variable oder einen Ausdruck angeben. Sie wissen schon, dass eine Variable eine Art Behälter ist, um Daten aufzunehmen. Ein Ausdruck ist eine Gleichung oder Formel, die eine Beschreibung eines mathematischen Konzepts darstellt. In den meisten Fällen ist das Auswertungsergebnis eines Ausdrucks ein boolescher Wert (wahr oder falsch). Die folgenden Abschnitte beschreiben Operatoren im Detail, da Sie sie überall im Rest dieses Buches verwenden.

Operatoren definieren

Ein Operator akzeptiert ein oder mehrere Eingaben in Form von Variablen oder Ausdrücken, führt eine Aufgabe aus (wie einen Vergleich oder eine Addition) und gibt dann einen Wert entsprechend der Aufgabe aus. Operatoren werden teils anhand ihres Effekts und teils anhand der Anzahl der Elemente, die sie benötigen, klassifiziert. Zum Beispiel arbeitet ein unärer Operator mit einer einzigen Variablen oder einem Ausdruck; ein binärer Operator benötigt zwei.

Die Elemente, die dem Operator als Eingabe übergeben werden, nennt man Operanden. Der Operand auf der linken Seite des Operators wird linker Operand und der Operand auf der rechten Seite wird rechter Operand genannt. Die folgende Liste gibt die Operatoren an, die in Python verwendet werden können:

Unäre Operatoren

Arithmetische Operatoren

Vergleichsoperatoren

Logische Operatoren

Bitweise Operatoren

Zuweisungsoperatoren

Membership-Operatoren

Identitätsoperatoren

Jede dieser Kategorien hat eine bestimmte Aufgabe. Die arithmetischen Operatoren führen zum Beispiel mathematische Aufgaben durch, während Vergleichsoperatoren Vergleiche ausführen. Die folgenden Abschnitte beschreiben die Operatoren basierend auf der Kategorie, in der sie vorkommen.

Unäre Operatoren

Unäre Operatoren benötigen eine einzelne Variable oder einen Ausdruck als Eingabe. Sie verwenden diese Operatoren oft als Teil eines Entscheidungsprozesses. Zum Beispiel können Sie etwas suchen, das nicht wie etwas anderes ist. Tabelle 6.1 listet die unären Operatoren auf.

Operator | Beschreibung | Beispiel
~ | Invertiert die Bits einer Zahl, sodass alle 0-Bits ein 1-Bit werden und umgekehrt. | ~4 ergibt den Wert -5.
- | Negiert den Ursprungswert, sodass ein positiver Wert negativ wird und umgekehrt. | -(-4) ergibt 4 und -4 ergibt -4.

+

Wird nur der Vollständigkeit halber zur Verfügung gestellt. Dieser Operator gibt den gleichen Wert zurück, den Sie dem Operator übergeben haben.

+4 ergibt den Wert 4.

Tabelle 6.1: Unäre Operatoren in Python

Arithmetische Operatoren

Computer sind dafür bekannt, dass sie komplexe mathematische Berechnungen ausführen können. Diese von Computern ausgeführten komplexen Aufgaben basieren meist auf viel einfacheren mathematischen Aufgaben wie die Addition. Python bietet Ihnen Zugriff auf Bibliotheken, die Ihnen bei komplexen mathematischen Aufgaben helfen, aber Sie können immer auch Ihre eigenen Bibliotheken mathematischer Funktionen mit den einfachen Operatoren aus Tabelle 6.2 erstellen.

Pythons einziger ternärer Operator

Ein ternärer Operator benötigt drei Elemente. Python unterstützt nur einen solchen Operator und Sie verwenden ihn, um den Wahrheitswert eines Ausdrucks zu bestimmen. Dieser Operator hat die folgende Form:

TrueValue if Ausdruck else FalseValue

Wenn Ausdruck wahr ist, gibt der Operator den Wert TrueValue aus. Wenn der Ausdruck falsch ist, gibt der Operator den Wert FalseValue aus. Wenn Sie zum Beispiel eingeben

"Hallo" if True else "Auf Wiedersehen"

gibt der Operator »Hallo« als Antwort zurück,

Wenn Sie aber eingeben

"Hallo" if False else "Auf Wiedersehen"

gibt der Operator als Antwort »Auf Wiedersehen« aus. Das ist ein praktischer Operator für Zeiten, in denen Sie eine schnelle Entscheidung treffen müssen, aber nicht viel Code schreiben wollen, um das zu tun.

Ein Vorteil von Python ist, dass es meistens mehr als einen Weg gibt, etwas zu tun. Python hat noch eine alternative Methode für diesen ternären Operator – eine noch kürzere Methode. Sie hat die folgende Form:

(FalseValue, TrueValue)

[Ausdruck]

Wie zuvor gibt der Operator den Wert TrueValue aus, wenn Ausdruck wahr ist, andernfalls gibt er FalseValue aus. Beachten Sie, dass die Reihenfolge von TrueValue und FalseValue vertauscht ist. Ein Beispiel für diese Version ist:

("Hallo", "Auf Wiedersehen") [True]

In diesem Fall ist die Ausgabe des Operators »Auf Wiedersehen«, weil das der Wert an der Stelle des von TrueValue ist. Die erste der beiden Methoden ist etwas verständlicher, während die zweite Methode kürzer ist.

Operator | Beschreibung | Beispiel
+ | Addiert zwei Werte. | 5 + 2 = 7
- | Subtrahiert den rechten Operanden von dem linken Operanden. | 5 – 2 = 3
* | Multipliziert den rechten Operanden mit dem linken Operanden. | 5 * 2 = 10
/ | Dividiert den linken Operanden durch den rechten Operanden. | 5 / 2 = 2.5
% | Dividiert den linken Operanden durch den rechten Operanden und gibt den Rest zurück (Modulo). | 5 % 2 = 1
** | Berechnet den Exponentialwert des linken Operanden durch Potenzierung des Wertes mit dem rechten Operanden. | 5 ** 2 = 25

//

Führt eine Ganzzahldivision durch, in der der linke Operand durch den rechten Operanden dividiert wird, und nur die ganze Zahl wird zurückgegeben.

5 // 2 = 2

Tabelle 6.2: Arithmetische Operatoren in Python

Vergleichsoperatoren

Vergleichsoperatoren vergleichen einen Wert mit einem anderen und ermitteln, ob die von Ihnen angegebene Relation (Beziehung) wahr ist. Zum Beispiel ist 1 kleiner als 2, aber 1 ist niemals größer als 2. Der Wahrheitswert von Relationen wird oft zur Entscheidungsfindung in Ihren Anwendungen verwendet, um sicherzustellen, dass die Bedingung zur Ausführung einer bestimmten Aufgabe erfüllt ist. Tabelle 6.3 beschreibt die Vergleichsoperatoren.

Operator | Beschreibung | Beispiel

==

Bestimmt, ob zwei Werte gleich sind. Beachten Sie, dass der Vergleichsoperator zwei Gleichheitszeichen verwendet. Ein häufiger Fehler, den viele Entwickler machen, ist es, nur ein Gleichheitszeichen zu verwenden, was dazu führt, dass ein Wert einem anderen zugewiesen wird.

1 == 2 ergibt False

!=

Bestimmt, ob zwei Werte ungleich sind. Ältere Versionen von Python haben anstelle des Operators != den Operator <> akzeptiert, aber in heutigen Python-Versionen führt das zu einem Fehler.

1 != 2 ergibt True

> | Prüft, ob der Wert des linken Operanden größer als der Wert des rechten Operanden ist. | 1 > 2 ergibt False
< | Prüft, ob der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist. | 1 < 2 ergibt True
>= | Prüft, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist. | 1 >= 2 ergibt False
<= | Prüft, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist. | 1 <= 2 ergibt True

Tabelle 6.3: Vergleichsoperatoren in Python

Logische Operatoren

Logische Operatoren verknüpfen True- oder False-Werte von Variablen oder Ausdrücken, sodass Sie den Wahrheitswert des Ergebnisses bestimmen können. Sie verwenden logische Operatoren, um boolesche Ausdrücke zu erstellen, mit denen Sie beispielsweise ermitteln können, ob eine bestimmte Aufgabe ausgeführt werden soll. Tabelle 6.4 beschreibt die logischen Operatoren.

Operator | Beschreibung | Beispiel
and | Bestimmt, ob beide Operanden den Wert True haben. | True and True ergibt True True and False ergibt False False and True ergibt False False and False ergibt False
or | Bestimmt, ob einer der beiden Operanden den Wert True hat. | True or True ergibt True True or False ergibt True False or True ergibt True False or False ergibt False
not | Negiert den Wahrheitswert eines einzelnen Operanden. Aus True wird False und aus False wird True. | not True ergibt False not False ergibt True

Tabelle 6.4: Logische Operatoren in Python

Bitweise Operatoren

Die bitweisen Operatoren arbeiten mit den einzelnen Bits in einer Zahl. Zum Beispiel ist die Zahl 6 eigentlich 0b0110 im Binärsystem.

Wenn Ihre Kenntnisse über das Binärsystem etwas eingerostet sind, können Sie den praktischen Zahlensystemkonverter unter http://www.arndt-bruenner.de/mathe/scripts/Zahlensysteme.htm benutzen.

Ein bitweiser Operator geht mit jedem Bit innerhalb einer Zahl ganz besonders um. Arbeiten Sie mit einem logischen bitweisen Operator, wird der Wert 0 als False behandelt und der Wert 1 als True. Tabelle 6.5 erklärt die bitweisen Operatoren.

Operator | Beschreibung | Beispiel

& (And)

Bestimmt, ob die beiden Bits an derselben Position der zwei Operanden den Wert True haben, und setzt in diesem Fall das entsprechende Ergebnisbit auf den Wert True.

0b1100 & 0b0110 = 0b0100

| (Or)

Bestimmt, ob in mindestens einem der Operanden an derselben Position ein Bit den Wert True hat, und setzt in diesem Fall das entsprechende Ergebnisbit auf den Wert True.

0b1100 | 0b0110 = 0b1110

^ (XOR)

Bestimmt, ob die beiden Bits an derselben Position in den zwei Operanden verschieden sind, und setzt in diesem Fall das Ergebnisbit auf den Wert True. Sind beide Bits True oder beide Bits False, dann ist das Ergebnis False.

0b1100 ^ 0b0110 = 0b1010

~ (Einerkomplement) | Berechnet das Einerkomplement einer Zahl. | ~0b1100 = -0b1101 ~0b0110 = -0b0111

<< (Linksverschiebung)

Verschiebt die Bits im linken Operanden um den Wert des rechten Operanden nach links. Alle neuen Bits werden auf 0 gesetzt und alle Bits, die am Ende herausgeschoben werden, gehen verloren.

0b00110011 < < 2 = 0b11001100

>> (Rechtsverschiebung)

Verschiebt die Bits im linken Operanden um den Wert des rechten Operanden nach rechts. Alle neuen Bits werden auf 0 gesetzt und alle Bits, die am Ende herausgeschoben werden, gehen verloren.

0b00110011 > > 2 = 0b00001100

Tabelle 6.5: Bitweise Operatoren in Python

Zuweisungsoperatoren

Die Zuweisungsoperatoren legen Daten in einer Variablen ab. Der einfache Zuweisungsoperator kam schon in vorherigen Kapiteln dieses Buches vor, aber Python bietet noch mehr interessante Zuweisungsoperatoren an. Diese Zuweisungsoperatoren können während der Zuweisung mathematische Operationen ausführen, sodass Sie sich dadurch viel Schreibarbeit sparen. Tabelle 6.6 beschreibt die Zuweisungsoperatoren. Für diese Tabelle nehmen wir an, dass die Variable meineVar den Wert 5 hat.

Operator | Beschreibung | Beispiel
= | Weist den Wert des rechten Operanden dem linken Operanden zu. | meineVar = 2 führt dazu, dass meineVar den Wert 2 enthält.

+=

Addiert den Wert des rechten Operanden zu dem Wert des linken Operanden und schreibt das Ergebnis in den linken Operanden.

meineVar += 2 führt dazu, dass meineVar den Wert 7 hat.

-=

Subtrahiert den Wert des rechten Operanden von dem Wert des linken Operanden und schreibt das Ergebnis in den linken Operanden.

meineVar -= 2 führt dazu, dass meineVar den Wert 3 hat.

*=

Multipliziert den Wert des rechten Operanden mit dem Wert des linken Operanden und schreibt das Ergebnis in den linken Operanden.

meineVar *= 2 führt dazu, dass meineVar den Wert 10 hat.

/=

Dividiert den Wert des rechten Operanden durch den Wert des linken Operanden und schreibt das Ergebnis in den linken Operanden.

meineVar /= 2 führt dazu, dass meineVar den Wert 2.5 hat

%=

Dividiert den Wert des rechten Operanden durch den Wert des linken Operanden und schreibt den Rest der Division in den linken Operanden.

meineVar %= 2 führt dazu, dass meineVar den Wert 1 hat

**=

Bestimmt den exponentiellen Wert des linken Operanden durch Potenzierung mit dem rechten Operanden und schreibt das Ergebnis in den linken Operanden.

meineVar **= 2 führt dazu, dass meineVar den Wert 25 hat

//=

Dividiert den Wert des rechten Operanden durch den Wert des linken Operanden und schreibt die resultierende Ganzzahl der Division in den linken Operanden.

meineVar //= 2 führt dazu, dass meineVar den Wert 2 hat

Tabelle 6.6: Zuweisungsoperatoren in Python

Membership-Operatoren

Die Membership-Operatoren suchen einen Wert in einer Liste oder Reihe und geben dann das Suchergebnis als Wahrheitswert aus. Man kann die Membership-Operatoren mit einem Suchbefehl auf einer Datenbank vergleichen. Sie geben einen Wert ein, von dem Sie denken, dass er in der Datenbank vorkommt, und der Suchbefehl sagt Ihnen dann, dass er ihn gefunden hat oder er nicht in der Datenbank existiert. Tabelle 6.7 beschreibt die Membership-Operatoren.

Operator | Beschreibung | Beispiel
in | Ermittelt, ob der Wert des linken Operanden in der Reihe oder Liste, die im rechten Operanden gespeichert ist, vorkommt. | »Hallo« in »Hallo Du« ergibt True

not in

Ermittelt, ob der Wert des linken Operanden in der Reihe oder Liste, die im rechten Operanden gespeichert ist, nicht vorkommt.

»Hallo« not in »Hallo Du« ergibt False

Tabelle 6.7: Membership-Operatoren in Python

Identitätsoperatoren

Die Identitätsoperatoren bestimmen, ob ein Wert oder Ausdruck einer bestimmten Klasse oder einem bestimmten Typ angehört. Sie verwenden Identitätsoperatoren, um festzustellen, ob Sie wirklich mit dem Typ Information arbeiten, mit dem Sie eigentlich arbeiten wollten. Die Verwendung der Identitätsoperatoren hilft Ihnen, Fehler in Ihrer Anwendung zu vermeiden oder die Methode zu bestimmen, wie ein Wert verarbeitet werden muss. Tabelle 6.8 beschreibt die Identitätsoperatoren.

Operator | Beschreibung | Beispiel
is | Ergibt True, wenn der Typ des Wertes oder Ausdrucks im rechten Operanden der gleiche ist wie der im linken Operanden. | type(2) is int ergibt True

is not

Ergibt True, wenn der Typ des Wertes oder Ausdrucks im rechten Operanden nicht der gleiche ist wie der im linken Operanden.

type(2) is not int ergibt False

Tabelle 6.8: Identitätsoperatoren in Python

Vorrangsregeln für Operatoren

Bei der Erstellung sehr einfacher Ausdrücke, die nur einen Operator enthalten, ist die Reihenfolge der Auswertung der Operatoren für das Ergebnis schnell ermittelt. Arbeiten Sie jedoch mit mehreren Operatoren, ist es wichtig zu wissen, welcher Operator als Erstes ausgewertet wird. Es ist zum Beispiel nicht ganz uninteressant, ob der Ausdruck 1 + 2 * 3 den Wert 7 ergibt (die Multiplikation wird zuerst ausgeführt) oder 9 (die Addition wird als Erstes ausgewertet). Die Reihenfolge in den Vorrangsregeln sagt Ihnen, dass die Antwort 7 ist, es sei denn, Sie ändern dies mit Klammern. In diesem Fall, (1 + 2) * 3, ergäbe die Auswertung 9, da die Klammer Vorrang vor der Multiplikation hat. Tabelle 6.9 listet die Reihenfolge der Operatoren in Python auf.

Operator | Beschreibung

()

Sie verwenden Klammern, um Ausdrücke zu gruppieren und die Standardreihenfolge der Operatoren zu überschreiben, sodass eine Operation mit geringerem Stellenwert in der Rangfolge (wie die Addition) Vorrang vor einer Operation mit höherem Stellenwert hätte (wie die Multiplikation).

** | Die Potenzierung potenziert den Wert des linken Operanden mit dem des rechten Operanden.
~ + - | Unäre Operatoren benötigen nur eine einzelne Variable oder einen Ausdruck.
* / % // | Multiplizieren, Dividieren, Modulo und Ganzzahldivision
+ - | Addition und Subtraktion
>> << | Bitweiser Rechts- und Linksshift
& | Bitweises AND
^ | | Bitweises XOR und das normale OR
<= < > >= | Vergleichsoperatoren
== != | Gleichheitsoperatoren
= %= /= //= -= += *= **= | Zuweisungsoperatoren
is is not | Identitätsoperatoren
in not in | Membership-Operatoren
not or and | Logische Operatoren

Tabelle 6.9: Auswertungsreihenfolge der Operatoren in Python

Erstellen und Verwenden von Funktionen

Damit Sie Informationen ordentlich verwalten können, müssen Sie die Mittel, mit denen Sie die erforderlichen Aufgaben lösen wollen, strukturieren. Jede Zeile Code, die Sie schreiben, erfüllt eine bestimmte Aufgabe und Sie kombinieren diese Codezeilen, um das gewünschtes Ergebnis zu bekommen. Manchmal müssen Sie die Anweisungen mit anderen Daten wiederholen und manchmal wird Ihr Code so lang, dass Sie den Überblick darüber verlieren, welcher Abschnitt was macht. Funktionen dienen als Strukturierungshilfsmittel, um Ihren Code sauber und ordentlich zu halten. Außerdem ermöglichen Ihnen Funktionen, Anweisungen für andere Daten wiederzuverwenden, wenn nötig. Dieser Abschnitt erklärt Ihnen alles über Funktionen. Aber viel wichtiger ist, dass Sie in diesem Abschnitt Ihre erste ernsthafte Anwendung so erstellen, wie es auch professionelle Entwickler tun.

Funktionen als Codepäckchen

Sie gehen zu Ihrem Schrank, öffnen die Tür und alles fällt Ihnen entgegen. Eine richtige Lawine rollt Ihnen entgegen und Sie können froh sein, überlebt zu haben. Die Bowlingkugel auf dem obersten Regal hätte Sie schon ein wenig lädieren können! Aber Sie haben sich mit Kisten bewaffnet und schon bald ist alles ordentlich in den Kisten im Schrank verstaut. Die Schuhe verschwinden in der einen Kiste, Spiele in einer anderen und alte Karten und Briefe in einer weiteren Kiste. Nachdem Sie fertig sind, finden Sie in Ihrem Schrank alles, was Sie brauchen, ohne dass Sie sich verletzen. Funktionen sind genau das – Sie schnappen sich chaotischen Code und packen ihn in Kisten, in die Sie leicht hineinschauen können. So sehen Sie auf einen Blick, was Sie so haben, und verstehen schnell, wie es funktioniert.

Es gibt viele Erläuterungen dazu, was Funktionen sind und wofür Sie sie brauchen, aber wenn Sie diese ganzen Texte zusammenfassen, kommt man doch auf denselben Grundgedanken: Funktionen sind ein Mittel, um Code zusammenzufassen, sodass Sie schnell etwas wiederfinden und darauf zugreifen können. Wenn Sie Funktionen als Strukturierungshilfe betrachten, fällt es Ihnen viel leichter, damit zu arbeiten. Vermeiden Sie beispielsweise den Fehler, den viele Entwickler machen – sie fassen nämlich die falschen Dinge in einer Funktion zusammen. Jede Ihrer Funktionen soll einen einzigen Zweck haben, so wie die Kisten in Ihrem Schrank.

Die Wiederverwendbarkeit von Code ist wichtig

Sie gehen mal wieder an Ihren Schrank, holen eine Hose und ein Hemd heraus, entfernen die Etiketten und ziehen sie an. Am Ende des Tages ziehen Sie alles wieder aus und werfen es in den Müll. Hmmm … das machen die meisten Leute nicht. Die meisten Leute ziehen ihre Kleidung aus, waschen sie und legen sie bis zum nächsten Gebrauch wieder in den Schrank. Funktionen sind auch wiederverwendbar. Niemand möchte immer wieder dieselbe Aufgabe wiederholen; das wird monoton und langweilig. Sie erstellen eine Funktion und definieren damit eine Menge von Code, die Sie wieder und wieder benutzen können, um dieselbe Aufgabe auszuführen. Sie müssen lediglich dem Computer mitteilen, welche Funktion er ausführen soll, um eine bestimmte Aufgabe zu erfüllen. Der Computer führt jede Anweisung in der Funktion jedes Mal pflichtergeben aus, wenn Sie ihn darum bitten.

Den Code, der die Dienste einer anderen Funktion in Anspruch nimmt, nennt man auch aufrufend (also zum Beispiel eine aufrufende Funktion) oder Aufrufer (caller), da er an die Funktion quasi einen Aufruf startet, dass sie eine bestimmte Aufgabe erledigen soll. Viele der Informationen, die Sie sehen, beziehen sich auf den Aufrufer. Der aufrufende Code muss der Funktion Informationen zur Verfügung stellen und die Funktion gibt wiederum Informationen an den Aufrufer zurück.

Es gab Zeiten, da gab es für Computerprogramme das Konzept der Wiederverwendbarkeit nicht. So kam es, dass Entwickler denselben Code wieder und wieder neu schreiben mussten. Daher dauerte es auch nicht lange, bis jemand die Idee mit den Funktionen hatte und das Konzept wurde über die Jahre immer weiter verbessert, bis Funktionen ziemlich flexibel waren. Funktionen können alles machen, was Sie wollen. Die Wiederverwendbarkeit von Code ist ein wichtiger Teil von Anwendungen, damit
sich die Entwicklungszeit verringert.

es weniger Programmierfehler gibt.

sich die Anwendungsstabilität erhöht.

ganze Gruppen von der Arbeit eines Programmierers profitieren können.

der Code besser zu verstehen ist.

sich die Effizienz der Anwendung verbessert.

Funktionen bieten Anwendungen also in punkto Wiederverwendbarkeit eine ganze Palette an Vorteilen. Beim Durcharbeiten der Beispiele dieses Buches werden Sie merken, dass Wiederverwendbarkeit Ihr Leben als Programmierer sehr viel leichter macht. Gäbe es die Wiederverwendbarkeit nicht, müssten Sie zum Programmieren den Computer immer noch per Hand mit 0en und 1en füttern.

Eine Funktion definieren

Das Erstellen einer Funktion erfordert nicht viel Arbeit. Python regelt die Dinge nett und einfach für Sie. Die folgenden Schritte erklären Ihnen, wie Sie eine Funktion erstellen, auf die Sie später zugreifen können.

1. Öffnen Sie ein Python-Shell-Fenster.

Es erscheint die bekannte Python-Eingabeaufforderung.

2. Geben Sie def Hallo(): ein und drücken Sie [Enter].

Dieser Schritt sagt Python, dass es eine Funktion namens Hallo definieren soll. Die Klammern sind wichtig, da sie alle Anforderungen zur Verwendung der Funktion angeben. (In diesem Fall hat die Funktion keine Anforderungen.) Der Doppelpunkt am Ende teilt Python mit, dass Sie mit der Definition, wie Leute auf Ihre Funktion zugreifen sollen, fertig sind. Beachten Sie, dass die Einfügemarke jetzt eingerückt ist, wie in Abbildung 6.1 zu sehen. Diese Einrückung erinnert Sie daran, dass Sie der Funktion nun eine Aufgabe geben müssen, die sie ausführen kann.

Abbildung 6.1: Geben Sie Ihrer Funktion einen Namen.

3. Geben Sie print("Das ist meine erste Python-Funktion!") ein und drücken Sie [Enter].

Ihnen sollten zwei Dingen auffallen, die Sie auch in Abbildung 6.2 sehen. Erstens ist die Einfügemarke immer noch eingerückt, weil IDLE darauf wartet, dass Sie den nächsten Schritt in der Funktion eingeben. Zweitens hat Python den print()-Befehl noch nicht ausgeführt, da er Teil einer Funktion ist und nicht im Hauptteil des Fensters steht.

Abbildung 6.2: IDLE wartet auf Ihre nächste Anweisung.

4. Drücken Sie [Enter].

Die Funktion ist nun vollständig. Das können Sie daran erkennen, dass die Einfügemarke jetzt auf der linken Seite steht, wie in Abbildung 6.3 zu sehen. Außerdem ist die Python-Eingabeaufforderung ( > > >) wieder da.

Abbildung 6.3: Die Funktion ist vollständig und IDLE wartet darauf, dass Sie noch eine Anweisung eingeben.

Auch wenn das eine sehr einfache Funktion ist, zeigt es doch das Schema, das Sie zur Erstellung aller Funktionen anwenden müssen. Sie legen einen Namen fest, geben alle Anforderungen zur Verwendung der Funktion an (in diesem Fall keine), und definieren eine Reihe von Schritten, die die Funktion ausführen soll. Eine Funktion ist beendet, wenn eine zusätzliche Zeile eingefügt wird (oder Sie zweimal [Enter] drücken).

Das Arbeiten mit Funktionen funktioniert im Editierfenster genauso wie in der Python-Shell, außer, dass Sie den Inhalt des Editierfensters auch auf Festplatte speichern können. Dieses Beispiel finden Sie auch in den herunterladbaren Beispielen in der Datei ErsteFunktion.py. Probieren Sie mal, die Datei in einem Editierfenster mit der Technik, die Sie im Abschnitt Das Editierfenster benutzen in Kapitel 4 kennengelernt haben, zu öffnen.

Auf Funktionen zugreifen

Nachdem Sie eine Funktion definiert haben, möchten Sie sie wahrscheinlich dazu nutzen, sinnvolle Aufgaben für Sie auszuführen. Das heißt natürlich, dass Sie wissen müssen, wie man die Funktion aufruft. Im letzten Abschnitt haben Sie eine neue Funktion namens Hallo() geschrieben. Um diese Funktion auszuführen, geben Sie einfach Hallo() ein und drücken [Enter]. Abbildung 6.4 zeigt, wie die Ausgabe aussieht, wenn Sie die Funktion ausführen.

Abbildung 6.4: Immer, wenn Sie den Funktionsnamen in die Shell eingeben, bekommen Sie die Ausgabe der Funktion angezeigt.

Auf jede von Ihnen geschriebene Funktion können Sie auf dieselbe Weise zugreifen. Sie geben den Funktionsnamen und eine öffnende Klammer ein, Informationen, die die Funktion benötigt, und eine schließende Klammer und schließlich drücken Sie [Enter]. In diesem Fall braucht die Funktion keine Informationen, daher müssen Sie nur Hallo() eingeben. Im Laufe des Kapitels werden Sie noch Beispiele kennenlernen, wo Informationen an die Funktion übergeben werden müssen.

Informationen an Funktionen übergeben

Das Beispiel ErsteFunktion.py ist schön, da Sie nun nicht jedes Mal diesen langen Text eingeben müssen, wenn Sie Hallo() sagen wollen. Die Funktion hat aber nur einen begrenzten Nutzen, da Sie sie nur die eine Sache sagen lassen können. Funktionen sollten flexibel sein und mehr als eine Sache tun können. Sonst haben Sie nachher ganz viele Funktionen, die sich nur durch die Daten unterscheiden, die sie verarbeiten und nicht durch ihre Funktionalität. Die Verwendung von Parametern hilft Ihnen dabei, Funktionen zu erstellen, die flexibel sind und sehr viele Daten verwenden können.

Parameter kennenlernen

Der Begriff Parameter hat nichts mit Messungen zu tun; er bedeutet, dass Sie der Funktion Informationen für die Bearbeitung einer Aufgabe zur Verfügung stellen. Der Ausdruck passt aber trotzdem sehr gut, da sie die Funktion, genauer das Verhalten der Funktion, mit diesen Informationen parametrieren, also einstellen können. Auch wenn man am Namen nicht gleich erkennt, was Parameter machen, ist es doch einfach nachvollziehen, was sie tun. Mit einem Parameter können Sie Daten an eine Funktion übergeben, die diese Funktion verwenden kann, wenn sie eine Aufgabe ausführt. Die Verwendung von Parametern macht Ihre Funktion flexibler.

Die Funktion Hallo() ist momentan sehr unflexibel, da sie nur einen String ausgeben kann. Definiert man einen Parameter für die Funktion, kann man sie sehr viel flexibler gestalten, da die Funktion dann jeden String, den man ihr übergibt, ausgeben lassen kann. Erstellen Sie eine neue Funktion in dem Python-Shell-Fenster (oder öffnen Sie die Datei Parameter01.py aus den herunterladbaren Beispielen). Diese Version von Hallo(), nämlich Hallo2(), benötigt einen Parameter:

def Hallo2(Begruessung):

print(Begruessung)

Beachten Sie, dass die Klammern nun nicht mehr leer sind. Sie enthalten das Wort Begruessung, den Parameter für die Funktion Hallo2(). Der Parameter Begruessung ist eigentlich eine Variable, die Sie an print() übergeben können, um ihren Inhalt auf dem Bildschirm ausgeben lassen zu können.

Die benötigten Parameter übergeben

Sie haben nun eine neue Funktion Hallo2(). Diese Funktion erfordert, dass Sie ihr einen Parameter übergeben, damit Sie sie verwenden können. Zumindest ist das das, was Sie bisher gesagt bekommen haben. Geben Sie Hallo2() in die Python-Shell ein und drücken Sie [Enter]. Es wird eine Fehlermeldung angezeigt, wie in Abbildung 6.5 zu sehen, die Ihnen mitteilt, dass Hallo2() einen Parameter benötigt.

Python sagt Ihnen nicht nur, dass ein Parameter fehlt, sondern auch, wie dieser heißt. So, wie Sie die Funktion definiert haben, müssen Sie einen Parameter übergeben. Geben Sie Hallo2("Das ist eine interessante Funktion!") ein und drücken Sie [Enter]. Dieses Mal sehen Sie die erwartete Ausgabe. Trotzdem wissen Sie immer noch nicht, ob Hallo2() flexibel genug ist, um verschiedene Nachrichten auszugeben. Geben Sie Hallo2("Eine weitere Nachricht…") ein und drücken Sie [Enter]. Sie sehen wieder den erwarteten Text, wie in Abbildung 6.6 zu sehen. Also ist Hallo2() tatsächlich eine Verbesserung gegenüber der ersten Version Hallo().

Abbildung 6.5: Sie müssen einen Parameter übergeben, sonst bekommen Sie eine Fehlermeldung angezeigt.

Abbildung 6.6: Mit Hallo2() können Sie jede beliebige Nachricht ausgeben lassen.

Durch die von Ihnen bisher durchgeführten Tests könnten Sie schnell annehmen, dass Begruessung nur einen String entgegennimmt. Geben Sie Hallo2(1234) ein und drücken Sie [Enter] und Python wird 1234 ausgeben. Genauso können Sie auch Hallo2(5+5) eingeben und [Enter] drücken. Dieses Mal sehen Sie das Ergebnis des Ausdrucks, also 10.

Parameter per Schlüsselwort übergeben

Wenn Ihre Funktionen und die Methoden zur Verwendung der Funktionen komplizierter werden, möchten Sie vielleicht etwas mehr Kontrolle darüber haben, wie die Funktion aufgerufen werden soll und wie ihr die Parameter übergeben werden sollen. Bisher haben Sie Positionsparameter verwendet, das heißt, Sie haben die Parameter in der Reihenfolge übergeben, in der sie in der Parameterliste in der Definition stehen. Es gibt in Python aber auch eine andere Methode, mit der Sie die Parameter per Schlüsselwort übergeben können. Bei dieser Methode geben Sie den Namen des Parameters ein, gefolgt von einem Gleichheitszeichen (=) und dem Wert des Parameters. Probieren Sie es mal aus, öffnen Sie eine Python-Shell und geben Sie die folgende Funktion ein (diese finden Sie auch in der Datei Parameter02.py):

def Addieren (Wert1, Wert2):      print(Wert1, " + ", Wert2, " = ", (Wert1 + Wert2))

Beachten Sie, dass der Parameter des Befehls print() eine Elementliste enthält und dass diese Elemente durch Kommas getrennt sind. Außerdem haben die Parameter verschiedene Datentypen. Python erleichtert Ihnen die Kombination von Parametern auf diese Weise.

Nun ist es Zeit, die Funktion Addieren() zu testen. Natürlich möchten Sie die Funktion gerne zuerst mit Positionsparametern ausprobieren. Geben Sie also Addieren(2,3) ein und drücken Sie [Enter]. Sie sehen die erwartete Ausgabe 2 + 3 = 5. Geben Sie nun Addieren (Wert2=3, Wert1=2) ein und drücken Sie [Enter]. Und wieder bekommen Sie die Ausgabe 2 + 3 = 5, obwohl Sie die Parameter in umgekehrter Reihenfolge eingegeben haben.

Funktionsparametern einen Standardwert geben

Bisher haben die Funktionen immer erfordert, dass Sie ihnen einen Parameter übergeben, ob Sie nun Positionsparameter oder Schlüsselwortparameter verwendet haben. Man kann aber für Funktionen auch Standardwerte für die Parameter angeben, wenn es einen üblichen Wert gibt. Standardwerte erleichtern die Benutzung der Funktion und vermeiden Fehler, wenn ein Entwickler keine Daten übergibt. Um einen Standardwert zu definieren, geben Sie nach dem Parameternamen einfach ein Gleichheitszeichen ein und dann den Standardwert. Damit Sie sehen, wie das funktioniert, öffnen Sie ein Python-Shell-Fenster und geben die folgende Funktion ein (die Sie auch in der Datei Parameter03.py finden):

def Hallo3(Begruessung = "Kein Wert angegeben"):

print(Begruessung)

Dies ist eine weitere Version der ursprünglichen Funktion Hallo() und aktualisierten Funktion Hallo2(), aber Hallo3() springt ein, wenn jemand mal keinen Wert eingegeben hat. Versucht nun jemand, Hallo3() aufzurufen, ohne einen Parameter zu übergeben, führt das nicht zu einem Fehler. Geben Sie Hallo3() ein und überzeugen Sie sich selbst. Geben Sie Hallo3("Das ist ein String") ein und die normale Ausgabe wird angezeigt. Sollten Sie denken, die Funktion akzeptiert nun keine anderen Datentypen mehr als Eingabe, geben Sie Hallo3(5) ein und drücken Sie [Enter]; dann Hallo3(2+7) und drücken [Enter]. Abbildung 6.7 zeigt die Ausgaben dieser Tests.

Funktionen mit einer variablen Parameteranzahl definieren

In den meisten Fällen wissen Sie genau, wie viele Parameter Ihre Funktion braucht. Dieses Ziel sollte nach Möglichkeit immer angestrebt werden, da die Fehlersuche und Fehlerbehebung bei Funktionen mit einer festen Anzahl Parameter später einfacher ist. Manchmal können Sie aber am Anfang einfach noch nicht sagen, wie viele Parameter die Funktion übergeben bekommt. Programmieren Sie beispielsweise eine Python-Anwendung für die Kommandozeile, kann der Benutzer entweder keinen Parameter, die maximale Anzahl an Parametern (angenommen, es gibt eine) oder irgendeine Anzahl an Parametern dazwischen angeben.

Abbildung 6.7: Geben Sie Standardwerte an, wo immer es möglich ist, um die Verwendung Ihrer Funktion zu erleichtern.

Glücklicherweise bietet Python eine Methode an, sodass man einer Funktion eine variable Parameteranzahl übergeben kann. Sie können einfach einen Parameter definieren, dem ein Sternchen vorangestellt ist, wie zum Beispiel *VarPar. Die übliche Methode ist dann, einen zweiten Parameter anzugeben, der die Anzahl der übergebenen Parameter enthält. Hier ist ein Beispiel (auch in der Datei VarPar.py zu finden) für eine Funktion, die eine variable Anzahl von Elementen ausgeben kann. (Machen Sie sich keine Sorgen, wenn Sie sie jetzt noch nicht vollständig verstehen – Sie haben diese Technik ja zuvor noch nicht gesehen.)

def Hallo4(ArgCount, *VarPar):

print("Sie haben ", ArgCount, " Parameter übergeben.")

for Par in VarPar:

print(Par)

Dieses Beispiel verwendet etwas, das sich for-Schleife nennt. Sie werden dieses Konstrukt in Kapitel 8 kennenlernen. Alles, was Sie für den Moment wissen müssen, ist, dass es sich jeden Parameter einzeln aus VarPar herausholt, den jeweiligen Parameter in Par speichert und dann Par mit dem Befehl print() ausgibt. Sie sollten sich aber am meisten dafür interessieren, wie man eine variable Anzahl an Parametern benutzt.

Nachdem Sie die Funktion in ein neues Python-Shell-Fenster eingegeben haben, geben Sie Hallo4(1, "Ein Testtext.") ein und drücken [Enter]. Sie sollten nun die Anzahl der Parameter und den Text als Ausgabe sehen – also nichts besonders Aufregendes. Geben Sie nun Hallo4(3, "Eins", "Zwei", "Drei") ein und drücken [Enter]. Wie in Abbildung 6.8 zu sehen, kann die Funktion ohne Probleme mit einer variablen Anzahl von Parametern umgehen.

Abbildung 6.8: Mit einer variablen Parameteranzahl gewinnt Ihre Funktion an Flexibilität.

Informationen von Funktionen zurückgeben lassen

Funktionen können Daten direkt anzeigen oder sie können Daten an den Aufrufer zurückgeben, sodass der Aufrufer noch etwas anderes damit tun kann. In manchen Fällen zeigt eine Funktion die Daten an und gibt Daten an den Aufrufer zurück, aber es ist bei Funktionen eher üblich, dass die Daten entweder direkt angezeigt werden oder an den Aufrufer zurückgegeben werden.

Wie eine Funktion funktioniert, hängt von der Art der Aufgabe ab, die sie erfüllen soll. Zum Beispiel wird eine Funktion, die eine mathematische Berechnung durchführen soll, eher die Daten an den Aufrufer zurückgeben als andere Funktionen.

Um Daten an einen Aufrufer zurückzugeben, muss die Definition einer Funktion das Schlüsselwort return enthalten, gefolgt von den Daten, die zurückgegeben werden sollen. Es sind Ihnen keine Grenzen gesetzt, was Sie an den Aufrufer zurückgeben können. Im Folgenden sind ein paar Arten von Daten aufgelistet, die üblicherweise von einer Funktion an einen Aufrufer zurückgegeben werden.

Werte: Jeder Wert ist okay. Sie können Zahlen wie 1 oder 2.5 zurückgeben; Strings wie "Hallo Du!"; oder boolesche Werte wie True oder False.

Variablen: Der Inhalt einer Variablen funktioniert genauso gut wie die direkte Rückgabe eines Wertes. Der Aufrufer bekommt das, was in der Variable drinsteht.

Ausdrücke: Viele Entwickler verwenden Ausdrücke als Abkürzung. Sie können zum Beispiel einfach A + B zurückgeben, statt die Berechnung auszuführen, das Ergebnis in eine Variable zu schreiben und die Variable dann an den Aufrufer zurückzugeben. Die Verwendung von Ausdrücken ist schneller und macht dasselbe.

Ergebnisse anderer Funktionen: Sie können auch Daten von anderen Funktionen als Teil der Rückgabe Ihrer Funktion verwenden.

Nun wird es Zeit, dass Sie selbst ausprobieren, wie Rückgabewerte funktionieren. Öffnen Sie ein Python-Shell-Fenster und geben Sie den folgenden Code ein (oder öffnen Sie stattdessen die Datei Rückgabewert.py):

def Addieren2(Wert1,Wert2):

return Wert1 + Wert2

Diese Funktion nimmt zwei Werte als Eingabe entgegen und gibt die Summe dieser Werte zurück. Natürlich könnten Sie diese Aufgabe auch ohne eine Funktion hinkriegen, aber so geht es in vielen Funktionen los. Um diese Funktion zu testen, geben Sie print("Die Summe von 3 + 4 ist ", Addieren2(3,4)) ein und drücken Sie [Enter]. Sie sehen das gewünschte Ergebnis in Abbildung 6.9.

Abbildung 6.9: Rückgabewerte vergrößern den Nutzen Ihrer Funktionen noch mehr.

Rückgabewerte vergleichen

Man verwendet Funktionen mit Rückgabewerten auf vielfältige Art und Weise. Im letzten Abschnitt haben Sie zum Beispiel gesehen, wie Sie Funktionen als Eingabe für andere Funktionen benutzen können. Man verwendet Funktionen für alle möglichen Arten von Aufgaben, zum Beispiel zu Vergleichszwecken. Sie können sogar Ausdrücke mit ihnen bilden, die eine logische Ausgabe definieren.

Damit Sie sehen, wie das funktioniert, verwenden Sie die Funktion Addieren2() aus dem vorhergehenden Abschnitt. Geben Sie print("3 + 4 gleich 2 + 5 ergibt ", Addieren2 (3,4) == Addieren2(2,5))) ein und drücken Sie [Enter]. Sie sehen den Wahrheitswert des Ausdrucks, dass 3 +4 gleich 2 + 5 ist, in Abbildung 6.10. Der Punkt ist, dass Funktionen nicht nur einen einzigen Zweck erfüllen oder Sie sie nur auf eine Art betrachten müssen. Funktionen können Ihren Code sehr vielfältig einsetzbar und flexibel machen.

Abbildung 6.10: Verwenden Sie Ihre Funktionen, um viele unterschiedliche Aufgaben zu erfüllen.

Benutzereingaben

Es gibt nur sehr wenige Anwendungen, die in ihrer eigenen kleinen Welt existieren – also weit weg von einem Benutzer. Eigentlich interagieren die meisten Programme sogar sehr intensiv mit Benutzern, da Computer dafür da sind, Benutzeranforderungen zu erfüllen. Um mit dem Benutzer interagieren zu können, muss die Anwendung eine Möglichkeit vorsehen, Benutzereingaben zu erfragen. Glücklicherweise ist die gebräuchlichste Methode, um Benutzereingaben zu erhalten, auch einfach zu implementieren. Sie verwenden dazu einfach die Funktion input().

Die Funktion input() gibt immer einen String aus. Auch wenn der Benutzer eine Zahl eingibt, ist die Ausgabe der Funktion input() ein String. Das bedeutet, dass Sie die Eingabe konvertieren müssen, wenn Sie eine Zahl erwarten. Die Funktion input() ermöglicht es Ihnen auch, den Text für die Eingabeaufforderung anzugeben. Diese Eingabeaufforderung wird angezeigt, damit der Benutzer weiß, welche Informationen er eingeben soll.

Die Datei Eingabe01.py enthält ein Beispiel, wie man die input()-Funktion auf einfache Weise verwendet. Hier kommt der Code zum Beispiel:

Name = input("Geben Sie bitte Ihren Namen ein: ")

print("Hallo ", Name)

In diesem Fall fragt die input()-Funktion den Benutzer nach seinem Namen. Nachdem der Benutzer einen Namen eingegeben hat und [Enter] gedrückt hat, gibt das Beispiel eine angepasste Grußformel aus. Probieren Sie das Beispiel in der Kommandozeile oder im Python-Shell-Fenster aus. Abbildung 6.11 zeigt eine typische Ausgabe, wenn Sie John als Benutzernamen eingeben.

Abbildung 6.11: Geben Sie einen Benutzernamen ein und schauen Sie sich die Grußformel in der Ausgabe an.

Sie können input() für alle Arten von Daten verwenden; alles, was Sie brauchen, ist die richtige Konvertierungsfunktion. Der Beispielcode in der Datei Eingabe02.py enthält eine Methode, um eine solche Konvertierung durchzuführen, wie hier:

EineZahl = float(input("Geben Sie eine Zahl ein: "))

print("Sie haben eingegeben: ", EineZahl)

Wenn Sie dieses Beispiel ausführen, fragt Sie die Anwendung nach einem numerischen Wert. Der Aufruf von float() konvertiert die Eingabe in eine Zahl. Nach der Umwandlung gibt print() das Ergebnis aus. Führen Sie das Beispiel mit einem Wert wie 5.5 aus, bekommen Sie das gewünschte Ergebnis.

Es ist wichtig zu wissen, dass eine Datenkonvertierung auch Risiken birgt. Sollten Sie etwas anderes als eine Zahl eingeben, bekommen Sie eine Fehlermeldung, wie in Abbildung 6.12 zu sehen. Kapitel 9 erklärt Ihnen, wie Sie Fehler finden und beheben, bevor sie einen Systemabsturz verursachen.

Abbildung 6.12: Die Datenumwandlung ändert den Typ der Eingabe in den gewünschten Typ, aber kann auch Fehler verursachen.

7

Entscheidungen treffen

In diesem Kapitel

Verwenden Sie die if-Anweisung, um einfache Entscheidungen zu treffen

Treffen Sie mit der if...then...else-Anweisung kompliziertere Entscheidungen

Erstellen Sie durch die Verschachtelung von Anweisungen mehrere Entscheidungsebenen

Die Möglichkeit, eine Entscheidung zu treffen – den einen oder den anderen Pfad in einem Programm zu wählen –, ist eine wichtige Komponente, um sinnvolle Aufgaben programmieren zu können. Die Mathematik ermöglicht es dem Computer, sich nützliche Informationen zu besorgen. Entscheidungen wiederum erlauben es, etwas Sinnvolles mit diesen Informationen anzufangen. Ohne diese Funktionalität wäre ein Computer nutzlos. Jede Sprache, die Sie benutzen werden, enthält diese Funktionalität auf die eine oder andere Weise. Dieses Kapitel erläutert die Techniken, die Python für Entscheidungen anbietet.

Spielen Sie mal den Prozess durch, den Sie verwenden, wenn Sie eine Entscheidung treffen. Sie besorgen sich den Wert von etwas, vergleichen ihn mit einem gewünschten Wert und verhalten sich dann dementsprechend, um den Wert zu erreichen. Wenn Sie zum Beispiel eine rote Ampel sehen, vergleichen Sie die rote Ampel mit einer grünen Ampel, sehen, dass die Ampel nicht grün ist, und halten an. Die meisten Leute nehmen sich nicht die Zeit, über ihren Entscheidungsfindungsprozess nachzudenken, weil sie ihn täglich so oft ausführen. Entscheidungen zu treffen, ist für Menschen etwas ganz Selbstverständliches, aber Computer müssen jedes Mal die folgenden Aufgaben ausführen:

1. Den eigentlichen oder aktuellen Wert von etwas besorgen.

2. Den eigentlichen oder aktuellen Wert mit einem gewünschten Wert vergleichen.

3. Eine Aktion ausführen, die der gewünschten Ausgabe des Vergleichs entspricht.

Einfache Entscheidungen mit der »if«-Anweisung ausführen

Die if-Anweisung ist die einfachste Methode in Python, um eine Entscheidung zu implementieren. Sie besagt einfach, dass, wenn etwas wahr ist, Python die danach folgenden Schritte ausführen soll. Die folgenden Abschnitte erklären Ihnen, wie Sie die if-Anweisung für verschiedene Arten von Entscheidungen in Python verwenden können. Sie werden erstaunt sein, was diese einfache Anweisung alles leisten kann.

Die »if«-Anweisung

Sie verwenden if-Anweisungen regelmäßig in Ihrem Alltag. Zum Beispiel könnten Sie sich selbst sagen: »Heute ist Dienstag, also werde ich Schnitzel zu Mittag essen.« Die if-Anweisung in Python ist etwas wortkärger, aber verfolgt genau dasselbe Schema. Nehmen wir mal an, Sie definieren eine Variable VergleicheMich und weisen ihr den Wert 6 folgendermaßen zu:

VergleicheMich = 6

Dann können Sie den Computer bitten, die Variable VergleicheMich auf den Wert 6 folgendermaßen zu prüfen:

if VergleicheMich == 6:

print("VergleicheMich ist gleich 6!")

Jede if-Anweisung beginnt in Python, wie langweilig, immer mit dem Wort if. Sobald Python ein if sieht, weiß es, dass Sie eine Entscheidung treffen wollen. Nach dem Wort if kommt eine Bedingung. Eine Bedingung gibt lediglich an, welche Art von Entscheidung Python treffen soll. Im letzten Beispiel sollte Python bestimmen, ob VergleicheMich den Wert 6 enthält.

Beachten Sie, dass die Bedingung den Vergleichsoperator == verwendet und nicht den Zuweisungsoperator =. Ein ganz häufiger Fehler, den Entwickler machen, ist, den Zuweisungsoperator statt den Vergleichsoperator zu verwenden. In Kapitel 6 finden Sie eine Liste mit Vergleichsoperatoren.

Die Bedingung wird immer mit einem Doppelpunkt (:) beendet. Geben Sie keinen Doppelpunkt an, weiß Python nicht, dass die Bedingung beendet ist, und sucht nach weiteren Bedingungen zum Treffen der Entscheidung. Nach dem Doppelpunkt kommen alle Aufgaben, die Python für Sie erledigen soll. In diesem Fall gibt Python einen Text aus, der besagt, dass VergleicheMich gleich 6 ist.

Die »if«-Anweisung in einer Anwendung verwenden

Man kann die if-Anweisung in Python auf vielfältige Weise einsetzen. Sie sollten allerdings gleich jetzt die drei gebräuchlichsten Verwendungsmethoden kennenlernen:

Verwendung einer einzigen Bedingung, um eine Anweisung auszuführen, wenn die Bedingung wahr ist.

Verwendung einer einzigen Bedingung, um mehrere Anweisungen auszuführen, wenn die Bedingung wahr ist.

Mehrere Bedingungen zu einer Entscheidung miteinander kombinieren und eine oder mehrere Anweisungen ausführen, wenn die zusammengesetzte Bedingung wahr ist.

Die folgenden Abschnitte beschreiben diese drei Möglichkeiten und zeigen Ihnen Beispiele für ihre Verwendung. Im Laufe des Buches werden Sie noch weitere Beispiele kennenlernen, wie man die if-Anweisung einsetzen kann, da es eine grundlegende Methode zum Treffen von Entscheidungen ist.

Mit Vergleichsoperatoren arbeiten

Ein Vergleichsoperator bestimmt, wie ein Wert auf der linken Seite eines Ausdrucks im Vergleich zu einem Wert auf der rechten Seite des Ausdrucks dasteht. Nachdem er dies bestimmt hat, gibt er entweder True oder False, also den Wahrheitswert des Ausdrucks, aus. Zum Beispiel ergibt 6 == 6 True und 5 == 6 False. Tabelle 6.3 enthält eine Auflistung der Vergleichsoperatoren. Die folgenden Schritte zeigen, wie man eine if-Anweisung verwendet. Dieses Beispiel finden Sie auch unter den herunterladbaren Beispielen in der Datei SimplesIf.py.

1. Öffnen Sie ein Python-Shell-Fenster.

Sie sehen die schon bekannte Python-Eingabeaufforderung.

2. Geben Sie VergleicheMich = 6 ein und drücken Sie [Enter].

Dieser Schritt weist VergleicheMich den Wert 6 zu. Beachten Sie, dass hier der Zuweisungsoperator und nicht der Vergleichsoperator verwendet wird.

3. Geben Sie if VergleicheMich == 6: ein und drücken Sie [Enter].

Dieser Schritt erstellt eine if-Anweisung, die den Wert von VergleicheMich mit dem Vergleichsoperator prüft. Hier sollten Ihnen zwei Features der Python-Shell auffallen:

• Das Wort if ist in einer anderen Farbe markiert als der Rest der Anweisung.

• Die nächste Zeile wird automatisch eingerückt.

4. Geben Sie print("VergleicheMich ist gleich 6!") ein und drücken Sie [Enter].

Python führt die if-Anweisung nicht sofort aus. Es rückt die nächste Zeile ein. Das Wort print erscheint in einer speziellen Farbe, da es ein Funktionsname ist. Zusätzlich wird der Text in einer anderen Farbe dargestellt, um anzuzeigen, dass es ein String ist. Die Farbcodierung verdeutlicht sehr gut, wie Python funktioniert.

5. Drücken Sie [Enter].

Die Python-Shell rückt die nächste Zeile aus und führt die if-Anweisung aus, wie in Abbildung 7.1 dargestellt. Beachten Sie, dass die Ausgabe wiederum eine andere Farbe hat. Da die Variable VergleicheMich den Wert 6 enthält, wird die if-Anweisung wie erwartet ausgeführt.

Abbildung 7.1: Einfache if-Anweisungen sagen Ihrer Anwendung, was sie in bestimmten Situationen tun soll.

Mehrere Aufgaben ausführen

Manchmal möchten Sie nach einer Entscheidung mehr als eine Aufgabe ausführen. Python bestimmt mit der Einrückung, wann es Aufgaben nicht mehr als Teil der if-Anweisung interpretieren soll. Solange die nächste Zeile eingerückt ist, gehört sie zur if-Anweisung. Ist die nächste Zeile ausgerückt, wird sie zur ersten Zeile außerhalb des if-Blocks. Ein Codeblock besteht aus einer Anweisung und den damit verbundenen Aufgaben. Egal, welche Anweisung Sie verwenden, es wird immer dieser Begriff benutzt. In diesem Fall arbeiten Sie mit einer if-Anweisung, die Teil dieses Codeblocks ist. Dieses Beispiel finden Sie auch in den herunterladbaren Beispielen in der Datei SimplesIf2.py.

1. Öffnen Sie ein Python-Shell-Fenster.

Die übliche Python-Eingabeaufforderung wird angezeigt.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie nach jeder Zeile auf [Enter]:

VergleicheMich = 6

if VergleicheMich == 6:

print("VergleicheMich ist gleich 6!")

print("Fertig!")

Beachten Sie, dass die Shell solange Zeilen einrückt, wie Sie Code eingeben. Jede Zeile ist Teil des aktuellen Codeblocks der if-Anweisung.

In der Shell erzeugen Sie einen Codeblock, indem Sie eine Zeile Code nach der anderen eingeben. Drücken Sie zweimal nacheinander [Enter], ohne dazwischen Text einzugeben, ist der Codeblock beendet und Python führt den gesamten Codeblock in einem Rutsch aus.

3. Drücken Sie [Enter].

Python führt den gesamten Codeblock aus. Sie bekommen die Ausgabe, die Sie in Abbildung 7.2 sehen.

Abbildung 7.2: Ein Codeblock kann mehrere Zeilen Code enthalten – eine für jede Aufgabe.

Mehrere Vergleiche mit logischen Operatoren verknüpfen

Bisher kamen in den Beispielen nur einzelne Vergleiche vor. Im richtigen Leben ist es oft erforderlich, dass Sie mehrere Vergleiche machen, um mehreren Anforderungen gerecht zu werden. Zum Beispiel müssen Sie beim Plätzchenbacken die Plätzchen aus dem Ofen holen, wenn die Eieruhr abgelaufen ist und die Ecken anfangen, braun zu werden.

Um mehrere Vergleiche auszuführen, schreiben Sie mehrere Bedingungen mit Vergleichsoperatoren auf und verknüpfen diese mit logischen Operatoren (siehe Tabelle 6.4). Ein logischer Operator beschreibt, wie man Bedingungen verknüpft. Sie können beispielsweise x == 6 and y == 7 als Bedingung für die Ausführung einer oder mehrerer Aufgaben festlegen. Das Schlüsselwort and ist ein logischer Operator, der besagt, dass beide Bedingungen wahr sein müssen.

Eines der häufigsten Einsatzgebiete für mehrere Vergleiche ist die Bestimmung, ob ein Wert in einem bestimmten Bereich liegt. Eigentlich ist die Bereichsprüfung, also die Bestimmung, ob ein Wert zwischen zwei anderen Werten liegt, ein Mittel, um Ihre Anwendung sicher und benutzerfreundlich zu gestalten. Die folgenden Schritte zeigen Ihnen, wie man diese Aufgabe ausführt. In diesem Fall erzeugen Sie eine Datei, sodass Sie die Anwendung mehrmals ausführen können. Dieses Beispiel finden Sie in der Beispieldatei SimplesIf3.py.

1. Öffnen Sie ein Python-Editierfenster.

Es wird ein Editor angezeigt, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie nach jeder Zeile [Enter]:

Wert = int(input("Geben Sie eine Zahl zwischen 1 und 10 ein: "))

if (Wert > 0) and (Wert <= 10):

print("Sie haben eingegeben: ", Wert)

Das Beispiel beginnt mit der Frage an den Benutzer nach einem Wert. Sie wissen nicht, was der Benutzer eingegeben hat, sondern wissen nur, dass es irgendein Wert ist. Die Verwendung der Funktion int() bedeutet, dass der Benutzer eine Ganzzahl eingeben muss (also eine ohne Dezimalteil). Andernfalls wird die Anwendung eine Ausnahme erzeugen (einen Fehlerhinweis; Kapitel 9 erklärt Ausnahmen). Diese erste Prüfung stellt sicher, dass der Wert zumindest den richtigen Typ hat.

Die if-Anweisung hat zwei Bedingungen. Die erste gibt an, dass Wert größer als 0 sein muss. Sie könnten diese Bedingung auch mit Wert >= 1 ausdrücken. Die zweite Bedingung verlangt, dass Wert kleiner oder gleich 10 sein muss. Nur wenn Wert beide Bedingungen erfüllt, hat die Bedingung den Wahrheitswert True und der vom Benutzer eingegebene Wert wird ausgegeben.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Ein Python-Shell-Fenster öffnet sich mit der Aufforderung, eine Zahl zwischen 1 und 10 einzugeben.

4. Geben Sie 5 ein und drücken Sie [Enter].

Die Anwendung stellt fest, dass die Zahl im gewünschten Bereich liegt, und gibt die Nachricht aus Abbildung 7.3 aus.

Abbildung 7.3: Die Anwendung stellt fest, dass der Wert im richtigen Bereich liegt, und gibt eine Nachricht aus.

5. Wiederholen Sie Schritt 3 und 4, aber geben Sie 22 statt 5 ein.

Die Anwendung gibt nichts aus, da der Wert nicht im gewünschten Bereich liegt. Immer wenn Sie einen Wert eingeben, der außerhalb des definierten Bereichs liegt, werden die Anweisungen innerhalb des if-Blocks nicht ausgeführt.

6. Wiederholen Sie die Schritte 3 und 4, aber geben Sie 5.5 statt 5 ein.

Python zeigt die Fehlermeldung aus Abbildung 7.4 an. Auch wenn Sie denken, dass 5.5 und 5 doch beides Zahlen sind, betrachtet Python die erste Zahl als Fließkommazahl und die zweite als Integer.

Abbildung 7.4: Die Eingabe des falschen Datentyps führt zu einem Fehler.

Mit der »if...else«-Anweisung Optionen auswählen

Für viele Entscheidungen in einer Anwendung muss eine Option aus zwei Möglichkeiten anhand von Bedingungen ausgewählt werden. Wenn Sie sich beispielsweise eine Fußgängerampel anschauen, wählen Sie eine von zwei Optionen aus: Sie bleiben entweder stehen, oder Sie überqueren die Straße. Eine grüne Ampel sagt Ihnen, dass Sie über die Straße gehen dürfen, eine rote Ampel sagt Ihnen, dass Sie stehen bleiben müssen. Die folgenden Abschnitte erklären, wie Sie mit Python zwischen zwei Möglichkeiten wählen können.

Die »if…else«-Anweisung

Mit Python können Sie mit der else-Klausel der if-Anweisung eine von zwei Optionen auswählen. Eine Klausel ist eine Ergänzung im Codeblock, die die Art und Weise beeinflusst, wie dieser funktioniert. Die meisten Codeblöcke unterstützen mehrere Klauseln. Bei der if-Anweisung ermöglicht Ihnen die else-Klausel, eine alternative Aufgabe auszuführen, was die if-Anweisung noch nützlicher macht. Die meisten Entwickler nennen die if-Anweisungen, die eine else-Klausel enthalten, if...else-Anweisung mit der Auslassung, dass etwas zwischen if und else passiert.

Entwickler vergessen manchmal bei der if...else-Anweisung, dass der else-Zweig immer dann ausgeführt wird, wenn die Bedingungen für die if-Anweisung nicht erfüllt sind. Es wichtig, sich Gedanken darüber zu machen, was passiert, wenn eine Menge von Anweisungen immer dann ausgeführt werden, wenn die Bedingungen False ergeben. Es könnte sein, dass sich daraus ungewünschte Effekte ergeben.

Die »if…else«-Anweisung in einer Anwendung verwenden

Das Beispiel aus SimpelIf3.py ist weniger nützlich, als es eigentlich sein könnte, falls der Benutzer einen Wert eingibt, der außerhalb des gewünschten Bereichs liegt. Sogar die Eingabe eines falschen Datentyps erzeugt wenigstens eine Fehlermeldung, während die Eingabe eines Werts außerhalb des Bereichs dem Benutzer gar nichts meldet. In dem nächsten Beispiel erfahren Sie, wie Sie dieses Problem mit der else-Klausel beheben. Die folgenden Schritte zeigen Ihnen, warum man eine alternative Aktion angeben sollte, wenn die Bedingung einer if-Anweisung False ergibt. Dieses Beispiel finden Sie auch in den herunterladbaren Beispielen in der Datei IfElse.py.

1. Öffnen Sie ein Python-Editierfenster.

Es öffnet sich ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie nach jeder Zeile [Enter]:

Wert = int(input("Geben Sie eine Zahl zwischen 1 und 10 ein: "))

if (Wert > 0) and (Wert <= 10):

print("Sie haben eingegeben: ", Wert)

else:

print("Der von Ihnen eingegebene Wert ist nicht korrekt!")

Wie zuvor fordert das Beispiel den Benutzer auf, eine Zahl einzugeben, und bestimmt dann, ob diese Zahl im gewünschten Bereich liegt. In diesem Fall gibt der else-Zweig jedoch eine alternative Ausgabe an, wenn der Benutzer einen Wert außerhalb des gewünschten Bereichs eingibt.

Beachten Sie, dass die else-Klausel mit einem Doppelpunkt abgeschlossen wird, genauso wie es auch bei der if-Anweisung der Fall ist. Die meisten Klauseln in Python werden mit einem Doppelpunkt beendet, damit Python weiß, wann die Klausel abgeschlossen ist. Sollten Sie in Ihrer Anwendung eine Fehlermeldung bekommen, prüfen Sie noch mal, ob der Doppelpunkt wie gefordert vorhanden ist.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Ein Python-Shell-Fenster mit der Aufforderung, eine Zahl zwischen 1 und 10 einzugeben, öffnet sich.

4. Geben Sie 5 ein und drücken Sie [Enter].

Die Anwendung stellt fest, dass die Zahl im richtigen Bereich liegt, und gibt die Nachricht aus, die Sie schon vorher in Abbildung 7.3 gesehen haben.

5. Wiederholen Sie Schritt 3 und 4, aber geben Sie 22 statt 5 ein.

Dieses Mal gibt die Anwendung die Fehlermeldung aus Abbildung 7.5 aus. Der Benutzer weiß nun, dass die Eingabe außerhalb des gewünschten Bereichs liegt, und könnte es noch mal versuchen.

Abbildung 7.5: Es ist immer gut, eine Rückmeldung für eine falsche Eingabe zu geben.

Die »if…elif«-Anweisung in einer Anwendung verwenden

Sie gehen in ein Restaurant und schauen Sie die Speisekarte an. Das Restaurant bietet zum Frühstück Rührei, belegte Brötchen, Croissants und Müsli an. Nachdem Sie sich eins davon ausgesucht haben, bringt es der Kellner Ihnen. Um eine Menüauswahl zu programmieren, braucht man so etwas wie eine if...else-Anweisung, aber mit etwas mehr Pep. Für dieses Beispiel verwenden Sie die elif-Klausel, um eine weitere Bedingungen zu implementieren. Die elif-Klausel ist eine Kombination aus einer else-Klausel und einer weiteren if-Anweisung. Die folgenden Schritte zeigen Ihnen, wie Sie ein Auswahlmenü mit der elif-Anweisung erstellen. Dieses Beispiel finden Sie bei den herunterladbaren Beispielen in der Datei IfElIf.py.

1. Öffnen Sie ein Python-Editierfenster.

Es öffnet sich ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie nach jeder Zeile [Enter]:

print("1. Rot")

print("2. Orange")

print("3. Gelb")

print("4. Grün")

print("5. Blau")

print("6. Violett")

Auswahl = int(input("Wählen Sie Ihre Lieblingsfarbe aus: "))

if (Auswahl == 1):

print("Sie haben Rot gewählt!")

elif (Auswahl == 2):

print("Sie haben Orange gewählt!")

elif (Auswahl == 3):

print("Sie haben Gelb gewählt!")

elif (Auswahl == 4):

print("Sie haben Grün gewählt!")

elif (Auswahl == 5):

print("Sie haben Blau gewählt!")

elif (Auswahl == 6):

print("Sie haben Violett gewählt!")

else:

print("Ihre Auswahl ist ungültig!")

Das Beispiel beginnt mit der Anzeige eines Auswahlmenüs. Der Benutzer sieht eine Auswahlliste für die Anwendung. Der Benutzer wird dann gebeten, eine Auswahl zu treffen, die in Auswahl gespeichert wird. Die Verwendung der Funktion int() stellt sicher, dass der Benutzer nichts außer einer ganzen Zahl eingeben kann.

Nachdem der Benutzer seine Auswahl getroffen hat, schaut die Anwendung diese in der Liste der möglichen Werte nach. Auswahl wird mit jedem Wert verglichen, der in den Bedingungen der if- und elif-Anweisungen vorkommt, um die Aktion zu bestimmen, die als Nächstes ausgeführt werden soll. Gibt der Benutzer 1 ein, gibt die Anwendung die Nachricht "Sie haben Rot gewählt!" aus. Kommt der Wert in keiner der if- und elif-Klauseln vor, wird standardmäßig die else-Klausel ausgeführt, um dem Benutzer mitzuteilen, dass seine Auswahl ungültig ist.

3. Wählen Sie RUN|RUN MODULE aus.

Es wird eine Python-Shell mit dem Auswahlmenü angezeigt. Die Anwendung bittet Sie, Ihre Lieblingsfarbe auszuwählen.

4. Geben Sie 1 ein und drücken Sie [Enter].

Die Anwendung zeigt die entsprechende Nachricht an, wie in Abbildung 7.6 zu sehen.

Abbildung 7.6: Mit Auswahlmenüs können Sie eine Option aus einer Liste auswählen.

5. Wiederholen Sie Schritt 3 und 4, aber geben Sie 5 statt 1 ein.

Die Anwendung zeigt eine andere Nachricht an – die, die zur ausgewählten Farbe gehört.

6. Wiederholen Sie Schritt 3 und 4, aber geben Sie 8 statt 1 ein.

Die Anwendung teilt Ihnen mit, dass Sie eine ungültige Auswahl getroffen haben.

7. Wiederholen Sie Schritt 3 und 4, aber geben Sie Rot statt 1 ein.

Die Anwendung zeigt die zu erwartende Fehlermeldung an, wie in Abbildung 7.7 zu sehen. Jede von Ihnen geschriebene Anwendung sollte in der Lage sein, Fehler und ungültige Eingaben zu erkennen. Kapitel 9 zeigt Ihnen, wie Sie mit Fehlern benutzerfreundlich umgehen können.

Abbildung 7.7: Jede Ihrer Anwendungen sollte in der Lage sein, fehlerhafte Eingaben zu erkennen.

Keine »switch«-Anweisung?

Sollten Sie schon mal mit anderen Sprachen programmiert haben, fällt Ihnen sicher auf, dass Python keine switch-Anweisung hat (falls nicht, brauchen Sie sich bei Python darüber keine Gedanken zu machen). Entwickler verwenden die switch-Anweisung normalerweise in anderen Sprachen, um Menü-basierte Anwendungen zu erstellen. Die if...elif-Anweisung wird in Python generell für denselben Zweck eingesetzt.

Trotzdem bietet die if...elif-Anweisung nicht ganz dieselbe Funktionalität wie die switch-Anweisung, da in der if...elif-Anweisung nicht zwingend dieselbe Variable in jedem Vergleich benutzt werden muss. Daher verwenden manche Entwickler in Python ein Dictionary, um die switch-Anweisung nachzubauen. Kapitel 13 beschreibt, wie man mit Dictionaries arbeitet.

Verschachtelte Entscheidungsanweisungen verwenden

Der Entscheidungsprozess findet häufig in Stufen statt. Gehen Sie beispielsweise in ein Restaurant und bestellen sich Rührei zum Frühstück, haben Sie eine einstufige Entscheidung getroffen. Nun fragt Sie der Kellner, was Sie gerne für ein Brot zu Ihrem Rührei hätten. Der Kellner würde Sie das nicht fragen, wenn Sie ein Müsli bestellt hätten, also wird aus der Auswahl eine zweistufige Entscheidung. Als das Frühstück zum Tisch gebracht wird, überlegen Sie, ob Sie Marmelade auf Ihrem Brot haben möchten. Nun ist es schon eine dreistufige Entscheidung. Hätten Sie ein Brot ausgewählt, zu dem keine Marmelade passt, hätten Sie die Entscheidung vielleicht gar nicht treffen müssen. Der Vorgang, Entscheidungen stufenweise zu fällen, während eine Stufe auf der Entscheidung der vorherigen Stufe basiert, nennt sich Verschachtelung oder Schachtelung. Programmierer verwenden die Verschachtelungstechnik oft, um Anwendungen zu erstellen, die komplexe Entscheidungen basierend auf verschiedenen Eingaben ausführen. Die folgenden Abschnitte beschreiben, wie Sie mit verschiedenen Arten der Schachtelung komplexe Entscheidungen ausführen können.

Mehrere »if«- oder »if…else«-Anweisungen verwenden

Die gebräuchlichste Methode für eine Mehrfachauswahl ist eine Kombination aus if- und if...else-Anweisungen. Diese Form der Auswahl wird auch Selektionsbaum genannt, da sie ein bisschen an Äste in einem Baum erinnert. Hier folgen Sie einem bestimmten Pfad, um ein gewünschtes Ergebnis zu bekommen. Das Beispiel in diesem Abschnitt können Sie mit der Datei MehrfachIfElse.py herunterladen.

1. Öffnen Sie ein Python-Editierfenster.

Es öffnet sich ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie nach jeder Zeile [Enter]:

Eins = int(input("Geben Sie eine Zahl zwischen 1 und 10 ein: "))

Zwei = int(input("Geben Sie eine Zahl zwischen 1 und 10 ein: "))

if (Eins >= 1) and (Eins <= 10):

if (Zwei >= 1) and (Zwei <= 10):

print("Ihre Geheimzahl ist: ", Eins * Zwei)

else:

print("Ungültiger zweiter Wert!")

else:

print("Ungültiger erster Wert!")

Dies ist lediglich eine Erweiterung des Beispiels in IfElse.py, das Sie in dem Abschnitt Die »if…else«-Anweisung in einer Anwendung verwenden dieses Kapitels kennengelernt haben. Beachten Sie aber, dass die Einrückung anders ist. Die zweite if...else-Anweisung ist innerhalb der ersten if...else-Anweisung eingerückt. Die Einrückung sagt Python, dass die Anweisungen verschachtelt sind.

3. Wählen Sie RUN|RUN MODULE aus.

Es wird eine Python-Shell mit der Aufforderung angezeigt, eine Zahl zwischen 1 und 10 einzugeben.

4. Geben Sie 5 ein und drücken Sie [Enter].

Die Shell bittet Sie, noch eine Zahl zwischen 1 und 10 einzugeben.

5. Geben Sie 2 ein und drücken Sie [Enter].

Sie sehen die Kombination der beiden Zahlen als Ausgabe, wie in Abbildung 7.8 zu sehen.

Abbildung 7.8: Mit der Einführung mehrerer Stufen können Sie komplexere Aufgaben ausführen.

Dieses Beispiel hat die gleiche Funktionalität, was die Prüfung der Eingabe angeht, wie das Beispiel IfElse.py. Geben Sie beispielsweise eine Zahl außerhalb des erlaubten Bereichs ein, wird eine Fehlermeldung ausgegeben. Die Fehlermeldung ist aber an den ersten beziehungsweise zweiten Eingabewert angepasst, sodass der Benutzer weiß, welcher Wert falsch war.

Spezifische Fehlermeldungen auszugeben ist immer ratsam, da die Benutzer ansonsten verwirrt und frustriert sind. Außerdem helfen Ihnen spezifische Fehlermeldungen, Fehler in Ihrer Anwendung schneller zu finden.

Weitere Entscheidungstypen miteinander kombinieren

Man kann jegliche Kombination aus if-, if...else- und if...elif-Anweisungen benutzen, um ein gewünschtes Ergebnis zu bekommen. Sie können Codeblocks beliebig tief schachteln, um erforderliche Prüfungen durchzuführen. Zum Beispiel zeigt Listing 7.1, wie Sie ein Auswahlmenü für ein Frühstück schreiben können. Dieses Beispiel finden Sie in der Datei MehrfachIfElIf.py bei den Downloads.

print("1. Rührei")

print("2. Brötchen")

print("3. Croissants")

print("4. Müsli")

ErsteAuswahl = int(input("Wählen Sie ein Frühstück aus: "))

if(ErsteAuswahl == 2):

Essen = "Brötchen"

elif (ErsteAuswahl == 3):

Essen = "Croissants"

if (ErsteAuswahl == 1):

print("1. Toast")

print("2. Graubrot")

print("3. Schwarzbrot")

print("4. Vollkorntoast")

Brot = int(input("Wählen Sie ein Brot aus: "))

if (Brot == 1):

print("Sie haben Rührei mit Toast ausgewählt.")

elif (Brot == 2):

print("Sie haben Rührei mit Graubrot ausgewählt.")

elif (Brot == 3):

print("Sie haben Rührei mit Schwarzbrot ausgewählt.")

elif (Brot == 4):

print("Sie haben Rührei mit Vollkorntoast ausgewählt.")

else:

print("Wir haben Rührei, aber diese Brotsorte haben wir nicht.")

elif (ErsteAuswahl == 2) or (ErsteAuswahl == 3):

print("1. Marmelade")

print("2. Frischkäse")

print("3. Nussnougatcreme")

Belag = int(input("Wählen Sie einen Belag aus: "))

if(Belag == 1):

print("Sie haben " + Essen + " mit Marmelade ausgewählt.")

elif(Belag == 2):

print("Sie haben " + Essen + " mit Frischkäse ausgewählt.")

elif(Belag == 3):

print("Sie haben " + Essen + " mit Nussnougatcreme ausgewählt.")

else:

print("Wir haben "+ Essen + ", aber diesen Belag haben wir nicht.")

elif(ErsteAuswahl == 4):

print("Sie haben Müsli ausgewählt!")

else:

print("Dieses Frühstück bieten wir nicht an!")

Listing 7.1: Ein Auswahlmenü für ein Frühstück programmieren

Dieses Beispiel hat ein paar interessante Besonderheiten. Zum einen könnten Sie denken, dass eine if...elif-Anweisung immer eine else-Klausel haben muss. Dieses Beispiel zeigt eine Situation, wo Sie eine solche Klausel nicht brauchen. Sie verwenden am Anfang eine if...elif-Anweisung, um sicherzustellen, dass Essen den richtigen Wert enthält, aber es gibt keine anderen Optionen, um die Sie sich kümmern müssen.

Die Auswahlmethode ist dieselbe, die Sie auch schon in vorherigen Beispielen gesehen haben. Ein Benutzer gibt einen Wert in einem gültigen Bereich ein, um ein gewünschtes Ergebnis zu bekommen. Drei der Entscheidungen benötigen eine zweite Entscheidung und Ihnen wird ein Auswahlmenü für diese Entscheidungen angezeigt. Wenn Sie beispielsweise Rührei auswählen, brauchen Sie keinen Belag, aber für Croissants oder Brötchen dürfen Sie einen Belag auswählen.

Beachten Sie, dass dieses Beispiel Variablen und Text auf besondere Art miteinander verknüpft. Da sowohl Croissants als auch Brötchen einen Belag haben können, brauchen Sie eine Methode, wie Sie genau ausgeben können, welches Essen serviert wird. Die Variable Essen, die etwas zuvor in der Anwendung definiert wurde, wird als Teil der Ausgabe verwendet, nachdem ein Belag ausgewählt wurde.

Sie verstehen dieses Beispiel am besten, wenn Sie es ausprobieren. Probieren Sie verschiedene Menükombinationen aus, damit Sie sehen, wie die Anwendung funktioniert. Abbildung 7.9 zeigt zum Beispiel, was passiert, wenn Sie Croissants mit Nussnougatcreme auswählen.

Abbildung 7.9: Viele Anwendungen verwenden mehrstufige Menüs.

8

Sich wiederholende Aufgaben ausführen

In diesem Kapitel

Wird eine Aufgabe eine bestimmte Anzahl von Malen ausgeführt

Wird eine Aufgabe bis zur vollständigen Abarbeitung ausgeführt

Platzieren Sie eine Schleife in einer anderen

Alle Beispiele in diesem Buch haben eine Schrittfolge nur genau einmal ausgeführt und waren dann beendet. Im richtigen Leben läuft es jedoch nicht so. Viele Aufgaben, die Menschen machen müssen, wiederholen sich. Zum Beispiel sagt Ihr Arzt Ihnen, dass Sie mehr Sport treiben und jeden Tag 100 Liegestütze machen sollen. Wenn Sie dann nur einen Liegestütz machen, bringt Ihnen das nicht viel und Sie haben nicht die Anweisungen des Arztes befolgt. Da Sie natürlich genau wissen, wie viele Liegestütze Sie machen sollen, können Sie diese Aufgabe auch eine bestimmte Anzahl von Malen ausführen. Python ermöglicht Ihnen eine ganz ähnliche Art der Wiederholung mit der for-Anweisung.

Leider wissen Sie nicht immer, wie oft man eine Aufgabe ausführen muss. Zum Beispiel, wenn Sie in einem Stapel Münzen nach einer besonderen Rarität suchen. Nimmt man nur die erste Münze vom Stapel, schaut sie an und stellt dann fest, dass es nicht die gesuchte ist, löst das die Aufgabe nicht. Ihr Stapel enthält wahrscheinlich mehr als eine Münze. Nur nachdem Sie jede Münze im Stapel angeschaut haben, können Sie sagen, dass die Aufgabe erledigt ist. Da Sie nicht wissen, wie viele Münzen in dem Stapel sind, wissen Sie im Vorhinein nicht, wie oft Sie die Aufgabe ausführen müssen. Sie wissen erst, dass die Aufgabe beendet ist, wenn der Stapel weg ist. Python macht solche Wiederholungen mit der while-Anweisung.

In den meisten Programmiersprachen heißt jede Art der Wiederholung bestimmter Ereignisse Schleife. Man kann sich die Wiederholung als ein Kreis vorstellen, durch den der Code immer wieder läuft und Aufgaben ausführt, bis die Schleife beendet ist. Schleifen sind ein wichtiger Teil von Anwendungen, so wie Menüs auch. Tatsächlich könnte man die meisten modernen Anwendungen ohne Schleifen nicht schreiben.

In manchen Fällen müssen Sie Schleifen in anderen Schleifen erstellen. Um beispielsweise eine Multiplikationstabelle zu erstellen, benutzen Sie eine Schleife geschachtelt in einer anderen Schleife. Die innere Schleife berechnet die Spaltenwerte und die äußere Schleife arbeitet die Reihen ab. Sie werden ein solches Beispiel noch weiter hinten in diesem Kapitel sehen. Machen Sie sich jetzt also keine Gedanken, wie diese Sachen funktionieren.

Daten mit der »for«-Anweisung verarbeiten

Das Schleifenkonstrukt, auf das die meisten Entwickler zuerst treffen, ist die for-Anweisung. Es ist schwer vorstellbar, dass eine Programmiersprache eine solche Struktur nicht anbietet. Bei der for-Anweisung wird die Schleife eine festgelegte Anzahl von Malen ausgeführt und Sie kennen die Anzahl der Ausführungen, bevor die Schleife überhaupt beginnt. Da bei einer for-Schleife im Vorhinein schon alles bekannt ist, ist die for-Anweisung die einfachste Schleife, die man benutzen kann. Um sie zu verwenden, müssen Sie wissen, wie oft die Schleife ausgeführt werden soll. Die folgenden Abschnitte beschreiben die for-Schleife ausführlich.

Die »for«-Anweisung

Die for-Schleife beginnt mit einer for-Anweisung. Die for-Anweisung beschreibt, wie die Schleife auszuführen ist. Die for-Schleife in Python arbeitet sich durch eine Sequenz eines bestimmten Typs. Dabei spielt es keine Rolle, ob es sich dabei um eine Sequenz mit Buchstaben einer Zeichenkette oder um Elemente in einer Liste handelt. Sie können sogar einen Wertebereich angeben, indem Sie die Funktion range() verwenden. Hier kommt eine einfache for-Anweisung:

for Buchstabe in "Hallo!":

Die Anweisung beginnt mit dem Schlüsselwort for. Die nächste Komponente ist eine Variable, die ein einzelnes Element einer Sequenz enthält. In diesem Fall heißt die Variable Buchstabe. Das Schlüsselwort in sagt Python, dass als Nächstes die Sequenz kommt. In diesem Fall ist die Sequenz die Zeichenkette »Hallo!«. Die for-Anweisung wird immer mit einem Doppelpunkt beendet, wie es auch bei den Entscheidungsanweisungen aus Kapitel 7 der Fall war.

Unter der for-Anweisung stehen eingerückt die Aufgaben, die Sie in der for-Schleife ausführen wollen. Python betrachtet jede eingerückte Anweisung unter der for-Anweisung als Teil der for-Schleife. Und auch das funktioniert bei der for-Schleife genauso wie bei den Entscheidungsanweisungen aus Kapitel 7.

Eine einfache »for«-Schleife erstellen

Am besten lernen Sie, wie eine for-Schleife wirklich arbeitet, wenn Sie selbst eine erstellen. In diesem Beispiel wird eine Zeichenkette als Sequenz verwendet. Die for-Schleife verarbeitet jeden Buchstaben in der Zeichenkette, bis ihr die Buchstaben ausgehen. Dieses Beispiel finden Sie in der Beispieldatei SimplesFor.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie nach jeder Zeile [Enter]:

BuchstabenPos = 1

for Buchstabe in "Hallo!":

print("Buchstabe ", BuchstabenPos, " ist ", Buchstabe)

BuchstabenPos += 1

Das Beispiel startet mit der Definition einer Variablen, BuchstabenPos, die die Anzahl der bisher verarbeiteten Buchstaben nachhält. Immer, wenn die Schleife beendet ist, wird BuchstabenPos um 1 erhöht.

Die for-Anweisung arbeitet sich durch die Sequenz aus Buchstaben in der Zeichenkette "Hallo!". Es schreibt jeden Buchstaben der Reihe nach in Buchstabe. Der darauf folgende Code zeigt den aktuellen Wert von BuchstabenPos an und den zugehörigen Buchstaben, der in Buchstabe steht.

3. Wählen Sie RUN|RUN MODULE aus.

Ein Python-Shell-Fenster öffnet sich. Die Anwendung zeigt die Buchstabenreihe mit den entsprechenden Buchstabenpositionen an, wie Sie in Abbildung 8.1 sehen.

Abbildung 8.1: Verwenden Sie die for-Schleife, um jeden Buchstaben einer Zeichenkette nacheinander zu verarbeiten.

Die Ausführung mit der »break«-Anweisung steuern

Im richtigen Leben gibt es häufig Ausnahmen. Sie möchten beispielsweise, dass eine Produktionsstraße Uhren herstellt. Irgendwann geht der Produktionsstraße aber ein benötigtes Teil aus. Ist das Teil nicht vorhanden, muss die Produktionsstraße mitten im Arbeitsablauf stoppen. Die Anzahl gewünschter Uhren ist nicht vollständig, aber das Fließband muss so lange angehalten werden, bis das fehlende Teil wieder nachgeliefert wurde.

Unterbrechungen gibt es auch im Computer. Sie arbeiten vielleicht gerade online mit Daten von einer Webseite, als es einen Netzwerkausfall gibt und die Verbindung abbricht; der Datenstrom reißt kurzfristig ab, sodass die Anwendung, mit der Sie arbeiten, nichts mehr zum Verarbeiten hat, auch wenn noch nicht alle Aufgaben abgearbeitet wurden.

Die break-Klausel ermöglicht es, eine Schleife abzubrechen. Sie platzieren die break-Klausel aber nicht einfach so in Ihrem Code – Sie umschließen sie mit einer if-Anweisung, die die Bedingung für das Ausführen der break-Klausel festlegt. Die Bedingung könnte in etwa so lauten: Wenn der Datenstrom abbricht, verlasse die Schleife.

In dem nächsten Beispiel erfahren Sie, was passiert, wenn der Zähler bei der Verarbeitung einer Zeichenkette eine bestimmte Größe erreicht. Das Beispiel ist etwas an den Haaren herbeigezogen, damit es einfach bleibt, aber es zeigt, was passieren könnte, wenn ein Datenelement zu lang für die Verarbeitung ist (was möglicherweise auf einen Fehler hindeutet). Dieses Beispiel finden Sie in der herunterladbaren Datei ForBreak.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie nach jeder Zeile [Enter]:

Wert = input("Geben Sie maximal 6 Buchstaben ein: ")

BuchstabenPos = 1

for Buchstabe in Wert:

print("Buchstabe ", BuchstabenPos, " ist ", Buchstabe)

BuchstabenPos += 1

if BuchstabenPos > 6:

print("Die Zeichenkette ist zu lang!")

break

Dieses Beispiel baut auf dem Beispiel aus dem vorherigen Abschnitt auf. Es lässt den Benutzer aber eine Zeichenkette variabler Länge eingeben. Besteht die Zeichenkette aus mehr als sechs Buchstaben, bearbeitet die Anwendung sie nicht weiter.

Die if-Anweisung enthält die Bedingung. Ist BuchstabenPos größer als sechs, bedeutet das, dass die Zeichenkette zu lang ist. Beachten Sie die zweite Einrückungsebene, die für die if-Anweisung verwendet wird. Ist die Bedingung wahr, bekommt der Benutzer eine Fehlermeldung angezeigt, dass die Zeichenkette zu lang ist, und der Code führt ein break aus, um die Schleife zu beenden.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Es öffnet sich ein Python-Shell-Fenster mit einer Eingabeaufforderung, die Sie um Input bittet.

4. Geben Sie Hallo ein und drücken Sie [Enter].

Die Anwendung listet jeden Buchstaben der Zeichenkette auf, wie in Abbildung 8.2 zu sehen.

Abbildung 8.2: Eine kurze Zeichenkette wird erfolgreich von der Anwendung verarbeitet.

5. Wiederholen Sie Schritt 3 und 4, aber geben Sie nun Ich bin zu lang statt Hallo ein.

Die Anwendung zeigt die erwartete Fehlermeldung an und stoppt die Verarbeitung der Zeichenkette bei Buchstabe 6, wie in Abbildung 8.3 zu sehen.

Abbildung 8.3: Zu lange Zeichenketten werden abgeschnitten, damit sie eine gewisse Länge einhalten.

Dieses Beispiel fügt Ihrem Werkzeugkasten mit Tests für Datenfehler die Längenprüfung hinzu. Kapitel 7 hat Ihnen schon gezeigt, wie Sie eine Bereichsprüfung machen können, die sicherstellt, dass ein Wert in gewissen Grenzen bleibt. Die Längenprüfung ist notwendig, damit Daten, speziell Zeichenketten, die Länge eines Datenfeldes nicht überschreiten. Außerdem macht eine kürzere Eingabelänge es Eindringlingen schwerer, bestimmte Hacks auf Ihrem System auszuführen, was Ihr System sicherer macht.

Die Ausführung mit der »continue«-Anweisung steuern

Manchmal möchten Sie jedes Element einer Sequenz prüfen, aber bestimmte Elemente nicht verarbeiten. Zum Beispiel könnten Sie entscheiden, dass Sie alle Informationen über jedes Auto in einer Datenbank verarbeiten, aber nicht die von braunen Autos. Vielleicht brauchen Sie einfach die Daten zu braunen Autos nicht. Die break-Klausel beendet einfach die Schleife, also können Sie sie in dieser Situation nicht gebrauchen. Sonst würden Sie die restlichen Elemente der Sequenz nach dem ersten braunen Auto nicht mehr betrachten.

Die Alternative zur break-Klausel, die viele Entwickler verwenden, ist die continue-Klausel. Wie die break-Klausel, ist die continue-Klausel auch hier Teil der if-Anweisung. Aber bei der continue-Klausel wird mit dem nächsten Element der Sequenz weitergemacht, anstatt sie zu beenden.

Die folgenden Schritte zeigen Ihnen, wie sich die continue-Klausel von der break-Klausel unterscheidet. In diesem Beispiel weigert sich der Code, den Buchstaben a zu verarbeiten, während alle anderen Buchstaben des Alphabets aber okay sind. Dieses Beispiel finden Sie in der herunterladbaren Datei ForContinue.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie nach jeder Zeile [Enter]:

BuchstabenPos = 1
for Buchstabe in "Hallo!":

if Buchstabe == "a":

continue

print("a gefunden. Wird nicht verarbeitet.")

print("Buchstabe ", BuchstabenPos, " ist ", Buchstabe)

BuchstabenPos += 1

Dieses Beispiel basiert auf dem Beispiel aus dem Abschnitt Eine einfache »for«-Schleife erstellen etwas weiter vorne in diesem Kapitel. Dieses Beispiel fügt jedoch noch eine if-Anweisung mit der continue-Klausel in den if-Codeblock ein. Beachten Sie die print()-Funktion im if-Codeblock. Sie werden diesen Text nie zu Gesicht bekommen, da der aktuelle Schleifendurchlauf abrupt abbricht.

3. Wählen Sie RUN|RUN MODULE aus.

Ein Python-Shell-Fenster wird geöffnet. Die Anwendung zeigt die Buchstabensequenz mit den Buchstabenpositionen wie in Abbildung 8.4 an. Schauen Sie sich aber den Effekt der continue-Klausel mal an – der Buchstabe a wird nicht verarbeitet.

Abbildung 8.4: Verwenden Sie die continue-Klausel, um die Verarbeitung bestimmter Elemente zu verhindern.

Die »pass«-Klausel

Die Sprache Python enthält etwas, was man normalerweise nicht in anderen Sprachen findet: einen Platzhalter für Code, der eigentlich nichts bewirkt. Er kann ähnlich wie die continue-Klausel verwendet werden, hat aber keinen Effekt auf die Schleifenausführung. Pass ist nützlich, wenn man an einer Stelle weiß, dass dort noch Code geschrieben werden soll, dieser aber noch nicht fertig ist. verwendetDie folgenden Schritte beschreiben exakt das gleiche Beispiel wie im Abschnitt Die Ausführung mit der »continue«-Anweisung steuern zuvor, aber diesmal wird stattdessen die pass-Klausel verwendet. Dieses Beispiel finden Sie in der herunterladbaren Datei ForPass.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie nach jeder Zeile [Enter]:

BuchstabenPos = 1

for Buchstabe in "Hallo!":

if Buchstabe == "a":

pass

print("a gefunden. Wird nicht verarbeitet.")

print("Buchstabe ", BuchstabenPos, " ist ", Buchstabe)

BuchstabenPos += 1

3. Wählen Sie RUN|RUN MODULE aus.

Ein Python-Shell-Fenster öffnet sich. Die Anwendung gibt die Buchstabensequenz mit der Buchstabenposition aus, wie in Abbildung 8.5 zu sehen. Beachten Sie, was die pass-Klausel macht – der Buchstabe a wird auch hier nicht verarbeitet. Zusätzlich wird der Text, der im Beispiel mit der continue-Klausel nicht angezeigt wurde, hier angezeigt.

Abbildung 8.5: Die Verwendung der pass-Klausel führt Code nach einer ungewünschten Eingabe aus.

Die Ausführung mit der »else«-Anweisung steuern

Python hat noch eine weitere Schleifenklausel, die Sie in keiner anderen Sprache finden werden: else. Die else-Klausel ermöglicht die Ausführung von Code, wenn die Schleife nicht vorzeitig durch ein break verlassen wurde. Das ist nützlich, wenn man nur etwas machen will, wenn die Schleife vollständig durchlaufen wurde. Das nächste Beispiel zeigt, wie das funktioniert. Dieses Beispiel finden Sie in der herunterladbaren Datei ForElse.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie nach jeder Zeile [Enter]:

Wert = input("Geben Sie maximal 6 Buchstaben ein: ")

BuchstabenPos = 1

for Buchstabe in Wert:

if(BuchstabenPos > 6):

break

print("Buchstabe ", BuchstabenPos, " ist ", Buchstabe)

BuchstabenPos += 1
else:

print("Die Zeichenkette hatte nicht mehr als 6 Buchstaben.")

Dieses Beispiel basiert auf dem Beispiel aus Eine einfache »for«-Schleife erstellen weiter vorne in diesem Kapitel. Gibt der Benutzer nicht mehr als sechs Zeichen ein, wird der Text aus dem else-Zweig ausgegeben.

3. Wählen Sie RUN|RUN MODULE aus.

Ein Python-Shell-Fenster öffnet sich mit einer Eingabeaufforderung.

4. Geben Sie Hallo ein und drücken Sie [Enter].

Die Anwendung listet jeden Buchstaben der Zeichenkette auf. Zusätzlich sagt Ihnen die Anwendung, dass Sie nicht mehr als sechs Zeichen eingegeben haben. Mal überlegen, ja, stimmt!

5. Wiederholen Sie Schritt 3 und 4. Geben Sie jetzt jedoch Das ist ein langer Text. ein und drücken Sie [Enter].

Da die Zeichenkette mehr als sechs Zeichen hat, wird die Schleife vorzeitig durch das break verlassen. In diesem Fall wird der Text in der else-Klausel nicht ausgegeben. Beide Ergebnisse – mit Ausführung des else-Zweigs und ohne – sehen Sie in Abbildung 8.6.

Abbildung 8.6: Der Code in der else-Klausel wird nur dann ausgeführt, wenn die Schleife nicht vorzeitig durch ein break verlassen wurde.

Daten mit der »while«-Anweisung verarbeiten

Sie verwenden die while-Anweisung für Situationen, wo Sie nicht genau wissen, wie viele Daten die Anwendung verarbeiten muss. Statt Python mitzuteilen, dass es eine bestimmte Anzahl an Elementen verarbeiten soll, sagen Sie ihm mit der while-Anweisung, dass es Elemente verarbeiten soll, bis eine bestimmte Bedingung erfüllt ist. Diese Schleife ist nützlich, wenn Sie zum Beispiel Aufgaben ausführen müssen, wie Dateien unbekannter Größe herunterzuladen oder Daten aus einer Onlinequelle zu streamen, zum Beispiel bei einem Internetradiosender. Jede Situation, in der im Vorhinein nicht klar ist, wie viele Daten die Anwendung zu verarbeiten hat, ist ein guter Kandidat für eine while-Schleife, die im Folgenden ausführlich beschrieben wird.

Die »while«-Anweisung

Die while-Anweisung verwendet eine Bedingung statt einer Sequenz. Die Bedingung legt fest, dass die while-Schleife so lange eine Aufgabe ausführen soll, bis die Bedingung nicht mehr wahr ist. Denken Sie zum Beispiel an einen Konditor, bei dem eine Schlange mit Kunden vor der Theke steht. Der Verkäufer bedient so lange Kunden, bis keiner mehr in der Schlange steht. Die Schlange kann (und wird wahrscheinlich auch) wachsen, während Kunden bedient werden, also ist es im Vorhinein unmöglich zu sagen, wie viele Kunden am Ende bedient wurden. Alle Verkäufer wissen, dass es wichtig ist, so lange Kunden zu bedienen, bis kein Kunde mehr da ist. So könnte eine while-Anweisung aussehen:

while Summe < 5:

Die Anweisung beginnt mit dem Schlüsselwort while. Dann kommt eine Bedingung. In diesem Beispiel wird die Schleife ausgeführt, solange die Summe kleiner als 5 ist. Die Anweisung endet mit einem Doppelpunkt und alle Aufgaben der Schleife werden unter der Anweisung eingerückt.

Da die while-Schleife die darin vorkommenden Aufgaben nicht eine bestimmte Anzahl von Malen ausführt, ist es möglich, eine Endlosschleife zu programmieren. Das bedeutet, dass die Schleife niemals endet, da der Wahrheitswert der Bedingung nie den Wert False bekommt. Sagen wir mal, dass Summe auf 0 gesetzt wird, wenn die Schleife beginnt und die Bedingung lautet, dass Summe kleiner als 5 ist. Erhöht sich der Wert von Summe in der Schleife nicht irgendwie, dann macht die Schleife endlos so weiter (zumindest so lange, bis der Computer heruntergefahren wird). Endlosschleifen können unterschiedliche und seltsame Probleme verursachen, zum Beispiel das System langsam machen oder sogar einfrieren. Also vermeiden Sie Endlosschleifen lieber. Sie müssen bei der while-Schleife immer genau darüber nachdenken, wann und wie die Schleife beendet sein wird (im Gegensatz zu der for-Schleife, wo das Ende der Sequenz das Ende der Schleife genau festlegt). Wenn Sie mit der while-Schleife arbeiten, müssen Sie drei Aufgaben erledigen:

1. Treffen Sie Vorbereitungen für die Bedingung (zum Beispiel Summe gleich 0 setzen).

2. Geben Sie die Bedingung in der while-Anweisung an (wie Summe < 5).

3. Aktualisieren Sie die Variablen der Bedingung in der Schleife so, dass die Schleife zu einem Ende kommen kann (fügen Sie zum Beispiel Summe += 1 in den while-Codeblock ein).

Wie auch bei der for-Anweisung, können Sie das Standardverhalten der while-Anweisung beeinflussen. Es stehen hier genau dieselben vier Klauseln zum Ändern des Verhaltens der while-Schleife zur Verfügung:

break: Beendet die aktuelle Schleife.

continue: Beendet sofort die Bearbeitung des aktuellen Elements.

pass: Beendet die Bearbeitung des aktuellen Elements, nachdem sämtliche Anweisungen in dem if-Block ausgeführt wurden.

else: Wird ausgeführt, wenn die Schleife nicht vorzeitig durch ein break beendet wurde.

Die »while«-Anweisung in einer Anwendung verwenden

Sie können die while-Schleife auf ganz vielfältige Weise einsetzen, aber das erste Beispiel ist zunächst ganz simpel. Es gibt einfach den aktuellen Wert von Summe aus, während es vor jedem Durchlauf den Wert von Summe in der Bedingung prüft. Die folgenden Schritte zeigen Ihnen, wie Sie das Beispiel implementieren und testen können. Sie finden es auch in der herunterladbaren Datei SimplesWhile.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie nach jeder Zeile [Enter]:

Summe = 0

while Summe < 5:

print(Summe)

Summe += 1

Der Beispielcode demonstriert die drei Aufgaben, die Sie erledigen müssen, wenn Sie eine einfache while-Schleife programmieren wollen. Zuerst wird Summe gleich 0 gesetzt, was dem ersten Schritt mit den Vorbereitungen für die Bedingung entspricht. Die Bedingung selbst erscheint als Teil der while-Anweisung. Das Ende des while-Blocks setzt den letzten Schritt um. Natürlich gibt der Code den aktuellen Wert von Summe aus, bevor der Wert aktualisiert wird.

Eine while-Schleife bietet Ihnen eine Flexibilität, die Sie mit der for-Schleife nicht bekommen. Dieses Beispiel zeigt eine sehr einfache Methode, um Summe zu aktualisieren. Sie können aber jegliche Methode, die die Ziele der Anwendung umsetzt, zur Aktualisierung verwenden. Niemand sagt, dass Sie Summe auf eine ganz bestimmte Weise aktualisieren müssen. Außerdem kann die Bedingung so komplex sein, wie Sie das wollen. Zum Beispiel können Sie den aktuellen Wert von drei oder vier Variablen prüfen, wenn Sie das möchten. Natürlich wird die Wahrscheinlichkeit größer, eine Endlosschleife zu generieren, je komplexer die Bedingung ist. Es gibt also gute, praktische Gründe, dass Sie die Bedingung nicht allzu komplex gestalten sollten.

3. Wählen Sie RUN|RUN MODULE aus.

Python führt die while-Schleife aus und zeigt eine Zahlenreihe wie die in Abbildung 8.7 an.

Abbildung 8.7: Diese einfache while-Schleife gibt eine Zahlenreihe aus.

Schleifen verschachteln

In manchen Situationen können Sie entweder eine for-Schleife oder eine while-Schleife verwenden, um dasselbe Ergebnis zu bekommen. Die Methoden sind verschieden, aber das Ergebnis ist dasselbe. In dem nächsten Beispiel programmieren Sie einen Generator für Multiplikationstabellen, indem Sie eine while-Schleife in einer for-Schleife schachteln. Da Sie gerne möchten, dass die Ausgabe hübsch aussieht, formatieren Sie diese auch etwas (siehe Kapitel 11). Dieses Beispiel finden Sie in der Datei VerschachtelteSchleifen.py.

1. Öffnen Sie ein Python-Editierfenster. Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie nach jeder Zeile [Enter]:

X = 1

Y = 1

print("{:>4}".format(" "), end=" ")

for X in range(1,11):

print("{:>4}".format(X), end=" ")

print()

for X in range(1,11):

print("{:>4}".format(X), end=" ")

while Y <= 10:

print("{:>4}".format(X * Y), end=" ")

Y += 1

print()

Y=1

Dieses Beispiel beginnt mit der Definition der Variablen X und Y, die die Zeilen- und Spaltennummern der Tabelle enthalten sollen. X ist die Variable für die Zeilen und Y die Variable für die Spalten.

Damit die Tabelle lesbar ist, muss das Beispiel einen Kopf oben und an der Seite erzeugen. Sieht der Benutzer eine 1 oben und eine 1 an der Seite und schaut sich die Stelle an, an der sich die Werte kreuzen, findet er das Ergebnis der Multiplikation der beiden Zahlen.

Die erste print()-Anweisung fügt ein Leerzeichen ein (da in der linken oberen Ecke der Tabelle nichts angezeigt werden soll; schauen Sie sich am besten Abbildung 8.8 an, damit Sie der Erklärung besser folgen können). Die Formatierungsanweisung besagt, dass 4 Plätze in der Ausgabe reserviert werden sollen und dort jeweils ein Leerzeichen eingefügt werden soll. Der Teil {:>4} des Codes bestimmt also die Spaltenbreite und format(´ ´) sagt, was an dieser Stelle eingefügt werden soll. Das Attribut end() der print()-Anweisung macht aus dem letzten Zeichen der Zeile, dem Zeilenumbruch, ein einfaches Leerzeichen (ansonsten würde nach jeder ausgegebenen Zahl in der Schleife eine neue Zeile anfangen).

Die erste for-Schleife gibt die Zahlen von 1 bis 10 am Kopf der Tabelle aus. Die Funktion range() erstellt die Zahlensequenz für Sie. Wenn Sie die range()-Funktion verwenden, geben Sie einen Anfangswert, hier 1, und einen Endwert, in diesem Fall 11, an.

Zu diesem Zeitpunkt befindet sich die Einfügemarke am Ende der Kopfzeile. Damit sie in die nächste Zeile kommt, steht im Code ein print()-Aufruf ohne einen Parameter.

Auch wenn das nächste Codestück recht kompliziert aussieht, können Sie es doch gut verstehen, wenn Sie es sich Zeile für Zeile anschauen. Die Multiplikationstabelle zeigt die Werte von 1*1 bis 10*10 an, also braucht man zehn Zeilen und zehn Spalten, um diese Informationen anzuzeigen. Die for-Anweisung sagt Python, dass es zehn Reihen anlegen soll.

Schauen Sie sich noch mal Abbildung 8.8 an und insbesondere den Reihenkopf. Das erste print()-Aufruf zeigt die Werte in der Kopfzeile an. Natürlich muss auch das formatiert werden und dazu werden im Code vier Leerzeichen verwendet, die mit einem zusätzlichen Leerzeichen abgeschlossen werden statt eines Zeilenumbruchs, damit in die Zeile noch etwas geschrieben werden kann.

Als Nächstes kommt die while-Schleife. Diese Schleife schreibt die Spalten in jeweils einer Zeile. Die Spaltenwerte sind die Ergebnisse der Multiplikation X * Y. Wieder wird die Ausgabe so formatiert, dass sie vier Plätze einnimmt. Die while-Schleife endet damit, dass Y durch Y += 1 aktualisiert wird.

Jetzt sind Sie wieder in der for-Schleife. Die print()-Anweisung beendet die aktuelle Zeile. Zusätzlich muss Y wieder auf 1 zurückgesetzt werden, sodass die nächste Zeile wieder mit 1 beginnt.

3. Wählen Sie RUN|RUN MODULE aus.

Sie sehen die Multiplikationstabelle aus Abbildung 8.8.

Abbildung 8.8: Dank ihrer Formatierung schmeichelt die Multiplikationstabelle dem Auge.

9

Mit Fehlern umgehen lernen

In diesem Kapitel

Probleme in der Kommunikation mit Python definieren

Fehlerquellen kennenlernen

Fehlerbedingungen behandeln

Festlegen, dass ein Fehler aufgetreten ist

Ihre eigenen Fehlerindikatoren programmieren

Aufgaben nach einem Fehler ausführen

Die meisten Programme, egal welcher Komplexität, beinhalten Fehler. Friert Ihre Anwendung ohne ersichtlichen Grund ein, ist das ein Fehler. Wenn Sie eine dieser seltsamen Nachrichtendialoge sehen, ist das auch ein Fehler. Es können aber auch Fehler auftreten, die Sie gar nicht bemerken. Eine Anwendung könnte eine falsche Berechnung auf einer von Ihnen eingegebenen Zahlenreihe machen und daraufhin eine falsche Ausgabe generieren, von der Sie erst erfahren, wenn Ihnen jemand anders sagt, dass sie falsch ist, oder wenn Sie dem Problem selbst irgendwann auf den Grund gehen. Fehler müssen sich auch nicht immer gleich verhalten. Vielleicht sehen Sie sie bei manchen Gelegenheiten und bei anderen wieder nicht. Zum Beispiel kann ein Fehler nur auftreten, wenn das Wetter schlecht ist oder das Netzwerk überlastet ist. Zusammengefasst können Fehler also in allen möglichen Situationen und aus allen möglichen Gründen auftreten. Dieses Kapitel erzählt Ihnen etwas über verschiedene Fehlerarten und was Sie tun können, wenn sie in Ihrer Anwendung auftreten.

Es sollte Sie nicht verwundern, dass Fehler auftreten können – Anwendungen werden von Menschen gemacht und Menschen machen nun einmal Fehler. Die meisten Entwickler nennen Anwendungsfehler Ausnahmen (im Englischen »exceptions«), womit angedeutet wird, dass sie nicht im Regelfall, sondern in Ausnahmefällen auftreten. Da Ausnahmen in Anwendungen auftreten können, müssen Sie sie erkennen können und wann immer möglich etwas dagegen tun. Der Vorgang des Findens und Behandelns von Ausnahmen wird Fehlerbehandlung oder Ausnahmebehandlung genannt. Damit Sie Fehler vernünftig behandeln können, müssen Sie wissen, warum sie auftreten und welche Fehlerquellen es gibt. Haben Sie den Fehler entdeckt, müssen Sie ihn behandeln, indem Sie die Ausnahme abfangen. Das Abfangen einer Ausnahme bedeutet, dass Sie sie untersuchen und möglicherweise etwas dagegen tun. Daher beschäftigt sich ein weiterer Teil dieses Kapitels damit, wie Sie eine Fehlerbehandlung in Ihrem eigenen Programm durchführen können.

Manchmal entdeckt Ihr Code einen Fehler in der Anwendung. Geschieht das, müssen Sie selbst eine Ausnahme auslösen oder werfen (im Englischen »throw«). Beide Begriffe werden für dieselbe Sache verwendet, nämlich, dass Ihr Code einen Fehler festgestellt hat, den er gerade selbst nicht behandeln kann oder will, und diesen an ein anderes Stück Code weitergibt, damit dieser ihn behandelt (analysiert, bearbeitet und mit ein bisschen Glück auch behebt). In manchen Fällen verwenden Sie dann auch benutzerdefinierte Nachrichten, um Informationen weiterzugeben. Auch wenn Python ein großes Angebot an generischen Fehlernachrichtenobjekten hat, gibt es trotzdem noch besondere Situationen, wo etwas anderes gebraucht wird. Vielleicht möchten Sie spezielle Unterstützung für eine Datenbankanwendung zur Verfügung stellen, aber Python bietet für diese Möglichkeit keine generische Nachricht an. Es ist wichtig zu wissen, wann man eine Ausnahme lokal und wann vom aufrufenden Code behandeln lässt und wann spezielle Ausnahmen erzeugt werden müssen, sodass jeder Teil der Anwendung weiß, wie die Ausnahme zu behandeln ist – alles Themen, die in diesem Kapitel behandelt werden.

Es wird auch Situationen geben, in denen Sie sicherstellen müssen, dass Ihre Anwendung eine Ausnahme elegant behandelt, auch wenn das bedeutet, dass die Anwendung beendet werden muss. Zum Glück hat Python die finally-Klausel, die immer ausgeführt wird, auch wenn ein Fehler auftritt. In den Codeblock der Klausel können Sie Code zum Schließen von Dateien oder zum Erledigen anderer wichtiger Aufgaben hineinschreiben. Auch wenn Sie diese Klausel vielleicht nicht so häufig verwenden werden, wird sie als letztes Thema in diesem Kapitel erklärt.

Warum versteht mein Python mich nicht?

Entwickler sind oft frustriert von Programmiersprachen und Computern, weil sie meinen, dass diese scheinbar nicht dieselbe Sprache sprechen und es daher Kommunikationsprobleme gibt. Natürlich sind sowohl Programmiersprachen als auch Computer leblose Dinge – beide ereifern sich für nichts. Programmiersprachen und Computer denken auch nicht; sie verstehen alles, was der Entwickler ihnen sagt, wörtlich. Und genau da liegt das Problem.

Weder Python noch der Computer werden »schon wissen, was Sie meinen«, wenn Sie Anweisungen als Code eingeben. Beide folgen genau den Anweisungen, die Sie Letzterem geben, und verstehen diese wörtlich genauso, wie Sie sie eingeben. Vielleicht wollten Sie Python nicht sagen, dass es eine Datendatei löschen soll, wenn irgendeine seltsame Bedingung auftritt. Aber wenn Sie die Bedingung nicht klar formulieren, wird Python die Datei löschen, ob es die Bedingung nun gibt oder nicht. Tritt ein Fehler dieser Art auf, sagen die Leute üblicherweise, dass die Anwendung einen Bug hat. Bugs sind einfach Programmierfehler, die Sie mithilfe eines Debuggers entfernen können. (Ein Debugger ist ein spezielles Werkzeug, mit dem Sie die Ausführung des Programms anhalten oder pausieren, den Inhalt von Variablen untersuchen und im Allgemeinen die Anwendung auseinandernehmen können, um nach dem Fehler zu suchen.)

Fehler treten häufig dann auf, wenn Entwickler etwas annehmen, das einfach nicht stimmt. Das beinhaltet auch Annahmen über den Benutzer der Anwendung, dem vielleicht egal ist, mit welcher außerordentlichen Sorgfalt Sie das Programm geschrieben haben. Der Benutzer wird in jedem Fall falsche Daten eingeben. Python interessiert es nicht oder weiß nicht, dass es falsche Daten sind, und verarbeitet sie, auch wenn Sie eigentlich solche falschen Daten nicht zulassen wollten. Python kennt den Unterschied zwischen richtigen und falschen Daten nicht; es verarbeitet die Daten einfach anhand der Regeln, die Sie festgelegt haben, und daher müssen Sie Regeln vorgeben, die die Benutzer vor sich selbst schützen.

Python ist weder proaktiv noch kreativ – solche Eigenschaften haben nur Entwickler. Tritt ein Netzwerkfehler auf oder macht der Benutzer etwas Unvorhergesehenes, wird Python keine Lösung aus dem Hut zaubern, um das zu beheben. Es verarbeitet lediglich Code. Wenn Sie keinen Code schreiben, der den Fehler behandelt, wird die Anwendung sich höchstwahrscheinlich unkontrolliert verhalten und abstürzen – und reißt möglicherweise alle Benutzerdaten mit sich. Natürlich kann ein Entwickler nicht alle Fehlersituationen vorhersagen und das ist auch der Grund, warum die meisten komplexen Programme Fehler haben – in diesem Fall Fehler aufgrund von Versäumnissen.

Obwohl es absurd ist, zu denken, es existiere idiotensicherer Code, denken manche Entwickler, sie könnten solchen Code schreiben. Schlaue Entwickler wissen aber, dass eine bestimmte Anzahl an Fehlern trotzdem den Review-Prozess übersteht, dass die Natur und Benutzer weiterhin unerwartete Dinge tun werden und dass selbst der schlauste Entwickler nicht alle Fehlersituationen vorhersehen kann. Denken Sie immer daran, dass Ihr Programm Fehler enthalten kann, die Ausnahmen auslösen werden; so sind Sie geistig gut darauf eingestellt, Ihre Anwendung verlässlicher zu machen.

Fehlerquellen erkennen

Vielleicht können Sie die möglichen Fehlerquellen in Ihrer Anwendung durch Kaffeesatzlesen erraten, aber das ist keine wirklich effiziente Methode. Fehler lassen sich eigentlich in sehr gut definierte Kategorien einordnen, die Ihnen dabei helfen vorherzusagen (zumindest in gewissem Maße), wo und wann sie auftreten werden. Wenn Sie diese Kategorien während der Arbeit an Ihrer Anwendung im Hinterkopf behalten, werden Sie sehr viel eher potenzielle Fehlerquellen ausmachen, bevor sie auftreten und möglichen Schaden anrichten können. Die zwei Hauptkategorien sind:

Fehler, die zu einem bestimmten Zeitpunkt auftreten

Fehler, die einen bestimmten Typ haben

Die folgenden Abschnitte beschreiben diese beiden Kategorien ausführlicher. Es ist wichtig, dass Sie sich über Fehlerklassifikationen Gedanken machen, um potenzielle Fehler in Ihrer Anwendung zu finden und zu beheben, bevor sie sich zu einem Problem auswachsen.

Klassifizieren, wann Fehler auftreten

Fehler können zu bestimmten Zeitpunkten auftreten. Die häufigsten Zeitpunkte sind:

Zur Kompilierzeit

Zur Laufzeit

Egal, wann ein Fehler auftritt, bringt er Ihre Anwendung dazu, sich danebenzubenehmen. Die folgenden Abschnitte beschreiben die beiden Zeitpunkte.

Kompilierzeit

Ein Fehler zur Kompilierzeit tritt dann auf, sobald Sie Python bitten, Ihre Anwendung auszuführen. Bevor Python die Anwendung ausführen kann, muss es sie übersetzen und in eine für den Computer verständliche Form bringen. Ein Computer braucht Maschinencode, der speziell auf seinen Prozessor und seine Architektur abgestimmt ist. Sind die von Ihnen geschriebenen Anweisungen fehlerhaft oder fehlen Informationen, kann Python diese Übersetzung nicht durchführen. Es zeigt Ihnen dann einen Fehler an, den Sie beheben müssen, bevor die Anwendung ausgeführt werden kann.

Glücklicherweise sind Fehler zur Kompilierzeit am einfachsten zu finden und zu beheben. Da die Anwendung niemals mit einem Kompilierungsfehler starten würde, sieht der Benutzer Fehler dieser Kategorie nie. Diese Sorte Fehler beheben Sie, während Sie programmieren.

Das Auftreten eines Fehlers zur Kompilierzeit deutet darauf hin, dass es auch noch weitere Schreibfehler oder andere Probleme im Code geben könnte. Es macht sich immer bezahlt, auch den umliegenden Code zu prüfen, ob es nicht noch andere Fehler gibt, die während der Kompilierzeit nicht erkannt werden.

Laufzeit

Ein Laufzeitfehler tritt auf, wenn Python den Code, den Sie geschrieben haben, kompiliert hat und der Computer beginnt, den Code ausführen. Es gibt verschiedene Arten von Laufzeitfehlern und manche lassen sich schwerer finden als andere. Sie erkennen einen Laufzeitfehler daran, dass die Anwendung auf einmal aufhört zu laufen und ein Dialogfenster mit einer Ausnahme anzeigt oder wenn der Benutzer sich über fehlerhafte Ausgaben beschwert (oder zumindest über die Instabilität der Anwendung).

Nicht alle Laufzeitfehler führen zu einer Ausnahme. Manche Laufzeitfehler machen das Programm instabil (die Anwendung friert ein), erzeugen fehlerhafte Ausgaben oder beschädigen Daten. Laufzeitfehler können andere Anwendungen beeinflussen oder unvorhergesehenen Schaden auf dem System anrichten, auf dem die Anwendung läuft. Alles in allem können Laufzeitfehler Ihnen ganz schön Kummer machen, je nachdem mit welcher Sorte Fehler Sie es zu diesem Zeitpunkt zu tun haben.

Viele Laufzeitfehler werden von fehlerhaftem Code verursacht. Sie können sich beispielsweise beim Namen einer Variablen vertun, sodass Python während der Ausführung die Daten in eine falsche Variable schreibt. Das Auslassen eines optionalen, aber notwendigen Parameters beim Aufruf einer Methode kann auch zu Problemen führen. Dies sind Beispiele für Fehler, die entstehen, weil man einfach etwas falsch programmiert hat. Normalerweise findet man diese Fehler mithilfe eines Debuggers oder indem Sie einfach Ihren Code Zeile für Zeile durchgehen, um nach Fehlern zu suchen.

Laufzeitfehler können auch durch externe Einflüsse entstehen, die nichts mit Ihrem Code zu tun haben. Zum Beispiel könnte der Benutzer falsche Daten eingeben, auf die die Anwendung nicht vorbereitet ist, und damit eine Ausnahme verursachen. Ein Netzwerkfehler kann zum Beispiel eine benötigte Datei unzugänglich machen. Manchmal gibt es auch Funktionsstörungen in der Hardware des Computers, die nicht reproduzierbare Anwendungsfehler verursachen. Das sind Beispiele für Fehler durch Auslassung, von der sich Ihre Anwendung aber erholen kann, wenn sie mit Fehlerbehandlungsroutinen ausgerüstet ist. Es wichtig, dass Sie an beide Fehlerarten bei der Programmierung Ihrer Anwendung denken – Fehler, die durch Fehler im Programmcode entstehen, und Fehler, die durch fehlende Fehlerbehandlung entstehen.

Fehlertypen unterscheiden

Sie können Fehler anhand ihres Typs unterscheiden, nämlich anhand der Art, wie sie entstehen. Wenn man Fehlertypen kennt, weiß man, wo in einer Anwendung man nach möglichen Problemen suchen muss. Ausnahmen funktionieren genauso wie viele andere Dinge im Leben auch. Zum Beispiel wissen Sie, dass elektrische Geräte ohne Strom nicht funktionieren. Versuchen Sie also, Ihren Fernseher einzuschalten, und es tut sich nichts, dann werden Sie wahrscheinlich nachschauen, ob der Stecker auch richtig in der Steckdose sitzt.

Sie finden Fehler schneller, früher und souveräner, sodass Ihnen auch weniger Fehldiagnosen passieren, wenn Sie die unterschiedlichen Fehlerarten kennen. Gute Entwickler wissen, dass Fehler einfacher zu beheben sind, solange sich eine Anwendung noch in der Entwicklung befindet, als wenn sie schon produktiv eingesetzt wird, da Benutzer grundsätzlich ungeduldig sind und Fehler sofort und ordentlich behoben haben wollen. Außerdem ist es immer einfacher, Fehler in einem frühen Stadium der Anwendung zu finden, als kurz vor ihrer Fertigstellung, da einfach weniger Code zum Durchsuchen existiert.

Der Trick ist, zu wissen, wo man suchen muss. Nimmt man dies als Grundlage, kann man in Python (und den meisten anderen Programmiersprachen) folgende Fehlertypen unterscheiden:

Syntaktische Fehler

Semantische Fehler

Logische Fehler

Die folgenden Abschnitte untersuchen jeden dieser Fehlertypen genauer. Ich habe die Abschnitte nach der Schwierigkeit, den Fehler zu finden, angeordnet, beginnend mit der Fehlersorte, die am einfachsten zu finden ist. Einen syntaktischen Fehler findet man meist am leichtesten; ein logischer Fehler ist generell am schwersten zu ermitteln.

Syntaktische Fehler

Immer, wenn Sie sich irgendwie verschreiben, erzeugen Sie einen syntaktischen Fehler. Manche syntaktischen Fehler sind in Python sehr einfach zu finden, da das Programm dann einfach nicht läuft. Der Interpreter zeigt Ihnen vielleicht sogar, wo der Fehler aufgetreten ist, indem er den fehlerhaften Code markiert und eine Fehlermeldung ausgibt. Es gibt aber auch syntaktische Fehler, die sehr schwer zu finden sind. Zum Beispiel unterscheidet Python Groß- und Kleinschreibung, sodass Sie eine Variable vielleicht an einer Stelle großschreiben, obwohl Sie sie kleingeschrieben definiert haben, was zu einem Fehler führen kann, da Python die Variable so nicht erkennen kann. Es kann dann sehr mühselig sein, die eine Stelle zu finden, wo Sie sich verschrieben haben.

Die meisten syntaktischen Fehler treten zur Kompilierzeit auf und der Interpreter zeigt Ihnen auch wo. Diese Fehler sind leicht zu beheben, da Ihnen der Interpreter auch im Allgemeinen sehr präzise sagt, was Sie beheben müssen. Selbst wenn der Interpreter das Problem nicht findet, verhindern syntaktische Fehler trotzdem die korrekte Ausführung der Anwendung. Daher werden alle Fehler, die vom Interpreter nicht gefunden werden, in der Testphase auffallen. Nur wenige syntaktische Fehler können es in ein Produktivsystem schaffen, wenn Sie Ihre Anwendung vernünftig testen.

Semantische Fehler

Wenn Sie eine Schleife schreiben, die einmal mehr als beabsichtigt ausgeführt wird, dann erhalten Sie normalerweise keine Fehlermeldung von der Anwendung. Die Anwendung wird fröhlich weiterlaufen, weil sie denkt, dass sie alles richtig macht, aber trotzdem kann der zusätzliche Schleifendurchlauf alle möglichen Datenfehler verursachen. Solche Fehler nennt man semantische Fehler.

Semantische Fehler treten auf, wenn der Sinn einer Schrittfolge zur Erledigung einer Aufgabe falsch ist – das Ergebnis ist falsch, auch wenn der Code offensichtlich genau das tut, was er soll. Semantische Fehler sind schwer zu finden und oft brauchen Sie dann einen Debugger, um sie zu entdecken. (Kapitel 19 stellt Tools vor, die Sie verwenden können, um Aufgaben, wie das Debuggen von Anwendungen, auszuführen.)

Logische Fehler

Manche Entwickler machen zwischen semantischen und logischen Fehlern keinen Unterschied, aber es gibt doch Unterschiede. Ein semantischer Fehler tritt auf, wenn der Code im Grunde richtig, aber die Implementierung falsch ist (zum Beispiel, wenn eine Schleife zu viel ausgeführt wird). Logische Fehler treten auf, wenn der Entwickler einen Denkfehler macht. In den meisten Fällen tritt das auf, wenn der Entwickler einen Vergleichsoperator oder einen logischen Operator falsch verwendet. Logische Fehler können aber noch in vielen anderen Situationen auftreten. Zum Beispiel könnte ein Entwickler annehmen, dass Daten immer auf der lokalen Festplatte gespeichert werden. Das könnte aber dazu führt, dass die Anwendung sich anders verhält, wenn sie stattdessen versucht, die Daten von einem Netzlaufwerk herunterzuladen.

Logische Fehler sind schwer zu beheben, da das Problem nicht am eigentlichen Code liegt, dieser aber trotzdem nicht korrekt geschrieben ist. Der Denkprozess, der zur Erstellung des Codes führte, war fehlerhaft; daher wird der Entwickler, der den Code geschrieben hat, den Fehler wahrscheinlich auch nicht finden. Kluge Entwickler suchen sich ein zweites Paar Augen, das ihnen bei der Suche nach logischen Fehlern hilft. Es ist auch gut, eine formale Anwendungsspezifikation zu haben, da dadurch die Logik hinter den Aufgaben der Anwendung auch formal geprüft wird.

Ausnahmen abfangen

Gewöhnlich sollte ein Benutzer nie ein Dialogfenster mit einer Ausnahme sehen. Ihre Anwendung sollte die Ausnahme immer abfangen und behandeln, bevor der Benutzer sie sieht. Natürlich ist es wie immer im richtigen Leben anders – Benutzer bekommen von Zeit zu Zeit unerwartete Ausnahmen zu Gesicht. Trotzdem sollte das Ziel beim Schreiben einer Anwendung sein, jede potenzielle Ausnahme abzufangen. Die folgenden Abschnitte beschreiben, wie man Ausnahmen abfangen und behandeln kann.

Integrierte Ausnahmen

In Python wurden schon eine Menge Ausnahmen integriert – weit mehr, als Sie sich vielleicht vorstellen können. Eine Liste dieser Ausnahmen finden Sie unter https://docs.python.org/3.4/library/exceptions.html. In der Dokumentation sind die Ausnahmen in Kategorien eingeteilt. Im Folgenden finden Sie einen kurzen Überblick über die Ausnahmekategorien in Python, mit denen Sie regelmäßig arbeiten werden:

Basisklassen: Die Basisklassen stellen die Grundbausteine (wie Exception, die Oberklasse aller Ausnahmen) für andere Ausnahmen zur Verfügung. Ihnen werden aber manche dieser Ausnahmen, wie die Ausnahme ArithmeticError, auch begegnen, wenn Sie mit einer Anwendung arbeiten.

Konkrete Ausnahmen: In Programmen können schwerwiegende Fehler auftreten – Fehler, die man nicht leicht beheben kann, da es keine gute Methode für ihre Behandlung gibt oder sie ein Ereignis ankündigen, um das sich die Anwendung kümmern muss. Python generiert zum Beispiel eine MemoryError-Ausnahme, wenn dem System kein Speicher mehr zur Verfügung steht. Das Beheben dieses Fehlers ist schwierig, da es nicht immer möglich ist, Speicher, der für andere Aufgaben genutzt wird, freizugeben. Drückt der Benutzer eine Tastenkombination zur Unterbrechung (zum Beispiel [Strg]+[C] oder [Entf], generiert Python eine KeyboardInterrupt-Ausnahme. Die Anwendung muss sich um diese Ausnahme kümmern, bevor sie mit anderen Dingen fortfährt.

Ausnahmen im Betriebssystem: Das Betriebssystem kann Ausnahmen erzeugen, die Python dann an Ihre Anwendung weitergibt. Versucht Ihre Anwendung beispielsweise, eine Datei zu öffnen, die es nicht gibt, generiert das Betriebssystem eine FileNotFoundError-Ausnahme.

Warnungen: Python versucht, Sie vor unerwarteten Ereignissen oder Aktionen zu warnen, die später zu einem Fehler führen können. Versuchen Sie beispielsweise, eine Ressource, zum Beispiel ein Icon, falsch zu verwenden, erzeugt Python eine ResourceWarning-Ausnahme. Wichtig zu wissen ist, dass dies nur eine Warnung und nicht ein wirklicher Fehler ist. Sie zu ignorieren, kann Sie später in Schwierigkeiten bringen, aber wenn Sie wollen, können Sie sie ignorieren.

Die grundlegende Ausnahmebehandlung

Damit Sie Ausnahmen behandeln können, müssen Sie Python mitteilen, dass Sie das tun wollen, und dann Code schreiben, der die Behandlung durchführt. Es gibt zahlreiche Möglichkeiten, wie Sie an diese Aufgabe herangehen können. Die folgenden Abschnitte beschreiben zunächst die einfachste Methode und fahren dann mit den schwierigeren Methoden, die eine größere Flexibilität anbieten, fort.

Eine einzelne Ausnahme behandeln

In Kapitel 7 hatten IfElse.py und die anderen Beispiele die schreckliche Angewohnheit, Ausnahmen auszugeben, wenn der Benutzer unerwartete Eingaben machte. Ein Teil der Lösung ist, den Wertebereich zu prüfen. Das hilft aber nicht, wenn der Benutzer Hallo statt des eigentlich erwarteten Zahlenwertes eingibt. Die Ausnahmebehandlung bietet eine komplexere Möglichkeit, das Problem zu lösen, wie in den folgenden Schritten beschrieben. Dieses Beispiel finden Sie in der herunterladbaren Datei EinfacheAusnahme1.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

try:

Wert = int(input("Geben Sie eine Zahl zwischen 1 und 10 ein:"))

except ValueError:

print("Sie müssen eine Zahl zwischen 1 und 10 eingeben!")

else:

if (Wert > 0) and (Wert <= 10):

print("Sie haben eingegeben: ", Wert)

else:

print("Sie haben einen falschen Wert eingegeben!")

Für den Code im try-Block werden Ausnahmen abgefangen. In diesem Fall bedeutet Ausnahmebehandlung, dass Ausnahmen bei der Eingabe des Benutzers, die mit den Aufrufen von int(input()) angefordert wird, abgefangen werden. Tritt eine Ausnahme außerhalb dieses Blocks auf, werden diese nicht behandelt. Man könnte nun meinen, dass man dann einfach den gesamten Code in den try-Block schreibt, sodass überall Ausnahmen abgefangen werden. Aber Sie sollten Ihre Ausnahmebehandlung kurz und spezifisch für die möglichen Probleme eines Codestücks schreiben, damit das Problem einfacher gefunden werden kann.

Der except-Block hält in diesem Beispiel nach einer ganz bestimmten Ausnahme, der ValueError-Ausnahme, Ausschau. Erzeugt der Benutzer nun eine ValueError-Ausnahme, weil er Hallo statt einer Zahl eingibt, wird dieser Ausnahmeblock ausgeführt. Sollte der Benutzer irgendeine andere Ausnahme auslösen, würde der except-Block diese nicht behandeln.

Der else-Block enthält den Code, der ausgeführt wird, wenn der try-Block erfolgreich ausgeführt wurde (also keine Ausnahme ausgelöst wurde). Der Rest des Codes befindet sich in diesem Block, damit er nicht ausgeführt wird, wenn der Benutzer keinen gültigen Wert eingegeben hat. Gibt der Benutzer eine Ganzzahl ein, führt der Code eine Bereichsprüfung durch, um zu testen, ob sie auch im gewünschten Wertebereich liegt.

3. Wählen Sie RUN|RUN MODULE aus.

Es öffnet sich ein Python-Shell-Fenster. Die Anwendung bittet Sie, eine Zahl zwischen 1 und 10 einzugeben.

4. Geben Sie Hallo ein und drücken Sie [Enter].

Die Anwendung zeigt eine Fehlermeldung an, wie in Abbildung 9.1 zu sehen.

Abbildung 9.1: Wenn Sie einen falschen Datentyp eingeben, wird eine Fehlermeldung statt einer Ausnahme ausgegeben.

5. Wiederholen Sie Schritt 3 und 4, aber geben Sie 5.5 statt Hallo ein.

Die Anwendung generiert wieder dieselbe Fehlermeldung, wie sie in Abbildung 9.1 zu sehen ist.

6. Wiederholen Sie nochmals Schritt 3 und 4, aber geben Sie 22 statt Hallo ein.

Die Anwendung gibt die erwartete Bereichsfehlermeldung aus, wie in Abbildung 9.2 zu sehen. Die Ausnahmebehandlung kümmert sich nicht um die Bereichsfehler. Sie müssen den Wert immer noch separat prüfen.

Abbildung 9.2: Die Ausnahmebehandlung prüft, ob die Zahl im richtigen Wertebereich liegt.

7. Wiederholen Sie nochmals Schritt 3 und 4, aber geben Sie 7 statt Hallo ein.

Dieses Mal gibt die Anwendung aus, dass Sie einen korrekten Wert, nämlich 7, eingegeben haben. Auch wenn es nach sehr viel Arbeit aussieht, all diese Prüfungen zu programmieren, Sie können nicht sicher sein, dass Ihre Anwendung ohne sie korrekt funktionieren würde.

8. Wiederholen Sie nochmals Schritt 3 und 4, aber drücken Sie [Strg]+[C], [MacBef]+[C] oder die entsprechende Tastenkombination Ihres Systems, statt etwas einzugeben.

Die Anwendung erzeugt eine KeyboardInterrupt-Ausnahme, wie in Abbildung 9.3 gezeigt. Da diese Ausnahme nicht abgefangen wird, ist das für den Benutzer noch ein Problem. Etwas weiter hinten in diesem Kapitel werden Sie Methoden kennenlernen, wie man dieses Problem behebt.

Abbildung 9.3: Die Ausnahmebehandlung in diesem Beispiel kümmert sich nur um Ausnahmen vom Typ ValueError.

Die »except«-Klausel ohne Angabe einer Ausnahme verwenden

Sie können in Python einen generischen Block für die Ausnahmebehandlung definieren, der nach keiner bestimmten Ausnahme sucht. Aber in den meisten Fällen sollten Sie aus den folgenden Gründen eine Ausnahmebehandlung für einen speziellen Ausnahmetyp vorziehen:

Ausnahmen, die Sie beim Entwurf der Anwendung nicht bedacht haben, bleiben unbemerkt.

Andere können genau nachvollziehen, welche Ausnahmen Ihre Anwendung abfangen kann.

Ausnahmen werden korrekt behandelt, da für sie spezieller Code existiert.

Manchmal benötigen Sie jedoch auch die Option, eine allgemeine Ausnahmebehandlung durchzuführen, zum Beispiel, wenn Sie mit Bibliotheken von Drittanbietern oder einem externen Dienst arbeiten. Die folgenden Schritte zeigen, wie Sie eine except-Klausel ohne einen damit verbundenen spezifischen Ausnahmetyp verwenden. Dieses Beispiel finden Sie in der Beispieldatei EinfacheAusnahme2.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

try:

Wert = int(input("Geben Sie eine Zahl zwischen 1 und 10 ein:"))

except:

print("Sie müssen eine Zahl zwischen 1 und 10 eingeben!")

else:

if (Wert > 0) and (Wert <= 10):

print("Sie haben eingegeben: ", Wert)

else:

print("Sie haben einen falschen Wert eingegeben!")

Der einzige Unterschied zwischen diesem und dem vorhergehenden Beispiel ist, dass die except-Klausel nicht die ValueError-Ausnahme als speziellen Ausnahmetyp angibt. Damit wird nun auch jede andere Ausnahme im try-Block abgefangen.

3. Wählen Sie RUN|RUN MODULE aus.

Es öffnet sich ein Python-Shell-Fenster. Die Anwendung bittet Sie, eine Zahl zwischen 1 und 10 einzugeben.

4. Geben Sie Hallo ein und drücken Sie [Enter].

Die Anwendung zeigt eine Fehlermeldung an (siehe Abbildung 9.1).

5. Wiederholen Sie Schritt 3 und 4, aber geben Sie 5.5 statt Hallo ein.

Die Anwendung generiert wieder dieselbe Fehlermeldung (siehe wieder Abbildung 9.1).

6. Wiederholen Sie nochmals Schritt 3 und 4, aber geben Sie 22 statt Hallo ein.

Die Anwendung gibt wie erwartet und beim letzten Beispiel die Bereichsfehlermeldung aus (siehe Abbildung 9.2).

7. Wiederholen Sie nochmals Schritt 3 und 4, aber geben Sie 7 statt Hallo ein.

Die Anwendung gibt wieder aus, dass Sie einen korrekten Wert, nämlich 7, eingegeben haben.

8. Wiederholen Sie nochmals Schritt 3 und 4, aber drücken Sie [Strg]+[C], [MacBef]+[C] oder die entsprechende Tastenkombination Ihres Systems, statt etwas einzugeben.

Sie sehen die Fehlermeldung, die eigentlich zu einem Eingabefehler gehört, wie in Abbildung 9.4 zu sehen. Diese Fehlermeldung ist falsch und könnte den Benutzer verwirren. Das Gute ist aber, dass die Anwendung nicht abgestürzt ist, Sie daher keine Daten verlieren würden und sich die Anwendung von dem Fehler erholen kann. Die generische Ausnahmebehandlung kann Vorteile haben, aber Sie sollten sie mit Bedacht verwenden.

Abbildung 9.4: Die generische Ausnahmebehandlung fängt die KeyboardInterrupt-Ausnahme ab.

Ausnahmeparameter verwenden

Die meisten Ausnahmen bieten keine Parameter an (eine Liste mit Werten, in denen Sie zusätzliche Informationen finden). Die Ausnahme tritt entweder auf oder eben nicht. Es gibt allerdings auch Ausnahmen, die Parameter zur Verfügung stellen, und Sie werden sie später in diesem Buch noch in Aktion sehen. Die Parameter verraten Ihnen mehr über die Ausnahme und geben Details an, dass Sie sie behandeln müssen.

Der Vollständigkeit halber enthält dieses Kapitel ein einfaches Beispiel, das eine Ausnahme mit einem Parameter generiert. Sie können den Rest dieses Abschnitts ohne Bedenken überspringen, da dieses Thema später im Buch noch detaillierter behandelt wird. Dieses Beispiel finden Sie in der herunterladbaren Beispieldatei AusnahmeMitParametern.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

import sys

try:

Datei = open("meineDatei.txt")

except IOError as e:

print("Fehler beim Öffnen der Datei!\r\n" +

"Fehlernummer: {0}\r\n".format(e.errno) +

"Fehlertext: {0}".format(e.strerror))

else:

print("Datei wie geplant geöffnet.")

Datei.close();

Wählen Sie Run|Run Module aus.

Dieses Beispiel verwendet ein paar komplexere Funktionen. Die import-Anweisung holt sich Code aus einer anderen Datei. Kapitel 10 erklärt, wie man dieses Python-Feature verwendet.

Die Funktion open() öffnet eine Datei und bietet über die Variable Datei Zugriff darauf. Kapitel 15 zeigt, wie Dateizugriffe funktionieren. Geht man davon aus, dass die Datei meineDatei.txt nicht im Anwendungsverzeichnis existiert, kann das Betriebssystem sie nicht öffnen und wird Python mitteilen, dass die Datei nicht existiert.

Der Versuch, eine nicht existente Datei zu öffnen, generiert eine Ausnahme vom Typ IOError. Diese spezielle Ausnahme bietet Zugriff auf zwei Parameter:

• errno: Gibt den Betriebssystemfehler als Integer zurück.

• strerror: Enthält die Fehlerinformation als für Menschen verständliche Zeichenkette.

Die as-Klausel schreibt die Ausnahmeinformationen in eine Variable e, auf die Sie bei Bedarf zugreifen können, um weitere Informationen zu bekommen. Der except-Block enthält einen print()-Aufruf, der die Fehlerinformationen so formatiert, dass sie eine gut lesbare Fehlermeldung ergeben.

Sollte es eine meineDatei.txt im Anwendungspfad geben, wird der else-Zweig ausgeführt. In diesem Fall sehen Sie eine Nachricht, dass die Datei ganz normal geöffnet wurde. Der Code schließt die Datei dann wieder, ohne etwas damit gemacht zu haben.

3. Wählen Sie RUN|RUN MODULE aus.

Es öffnet sich ein Python-Shell-Fenster. Die Anwendung zeigt die Fehlermeldung beim Öffnen der Datei an, wie in Abbildung 9.5 zu sehen.

Abbildung 9.5: Der Versuch, eine nicht existente Datei zu öffnen, wird immer fehlschlagen.

Eine Liste mit Ausnahmeparametern ausgeben lassen

Die Parameterliste, die für eine Ausnahme verfügbar ist, hängt zum einen vom Typ der Ausnahme ab und zum anderen von dem, was der Sender zur Verfügung stellt. Es ist nicht immer leicht herauszufinden, welche Zusatzinformationen man bekommen kann. Eine Methode ist es, einfach alles mit Code wie dem folgenden ausgeben zu lassen (dieses Beispiel steht auch zum Download in der Datei AusnahmeParameterListe1.py zur Verfügung):

import sys

try:

Datei = open("meineDatei.txt")

except IOError as e:

for Param in e.args:

print(Arg)

else:

print("Datei wie geplant geöffnet.")

Datei.close();

Die Eigenschaft args enthält immer eine Liste mit den Ausnahmeparametern im String-Format. Sie können eine einfache for-Schleife verwenden, um alle Parameter ausgeben zu lassen. Das einzige Problem bei diesem Ansatz ist, dass Sie nicht die Parameternamen bekommen. So bekommen Sie zwar die Ausgabeinformationen (in diesem Fall ist es offensichtlich, was ausgegeben wird), aber Sie wissen nicht, wozu diese gehören.

Eine kompliziertere Methode, um dieses Problem zu lösen, ist die Ausgabe von Namen und Inhalten der Parameter. Der folgende Code zeigt sowohl die Namen als auch die Werte jedes Parameters an (dieses Beispiel finden Sie in der Datei AusnahmeParameter Liste2.py.):

try:

Datei = open("meineDatei.txt")

except IOError as e:

for Eintrag in dir(e):

if (not Eintrag.startswith("_")):

try:

print(Eintrag, " = ", __getattribute__(Eintrag))

except AttributeError:

print("Attribut ", Eintrag, " nicht

zugreifbar.")

else:

print("Datei wie geplant geöffnet.")

Datei.close();

In diesem Beispiel holen Sie sich zuerst mit der Funktion dir() eine Auflistung der Attribute, die zu dem Fehlerparameterobjekt gehören. Die Rückgabe der Funktion ist eine Liste mit Strings, die die Namen der Attribute, die Sie ausgeben können, enthält. Nur die Parameter, die nicht mit einem Unterstrich (_) beginnen, enthalten sinnvolle Informationen über die Ausnahme. Auf manche der Einträge kann man jedoch nicht zugreifen, daher müssen Sie den Ausgabecode mit einem weiteren try...except-Block umgeben (siehe auch den Abschnitt Verschachtelte Ausnahmebehandlung später in diesem Kapitel für detailliertere Informationen).

Der Attributname ist einfach, da er in Eintrag steht. Um den Wert, der zu diesem Attribut gehört, zu bekommen, müssen Sie die Funktion __getattribute__() verwenden und den Namen des gewünschten Attributs angeben. Bei der Ausführung des Codes sehen Sie sowohl den Namen als auch den Wert jedes Attributs, die mit einem bestimmten Fehlerparameterobjekt mitgeliefert werden.

In diesem Beispiel bekommen Sie die folgende Ausgabe:

args  =  (2, 'No such file or directory')

Attribut  characters_written  nicht zugreifbar.

errno  =  2
filename  =  meineDatei.txt
filename2  =  None
strerror  =  No such file or directory
winerror  =  None
with_traceback  =  <built-in method with_traceback of FileNotFound Error object at 0x000000000312F268>

Mehrere Ausnahmen mit einer einzigen »except«-Klausel behandeln

Die meisten Anwendungen können mehrere Ausnahmen für eine einzige Zeile Code generieren. Diese Tatsache haben Sie schon etwas früher in diesem Kapitel im Beispiel Einfache Ausnahme1.py gesehen. Wie Sie mehrere Ausnahmen behandeln, kommt ein bisschen auf Ihre Ziele für Ihre Anwendung, die Ausnahmetypen und die Qualifikation Ihrer Benutzer an. Wenn Sie weniger qualifizierte Benutzer haben, ist es manchmal einfacher, diesen zu sagen, dass es einen schwerwiegenden Fehler in der Anwendung gab und die Detailinformationen in eine Logdatei in das Anwendungsverzeichnis oder eine zentrale Stelle zu schreiben.

Man kann nur dann eine einzige except-Klausel für mehrere Ausnahmen verwenden, wenn der gemeinsame Codeblock die Anforderungen aller Ausnahmetypen erfüllt. Andernfalls müssen Sie jede Ausnahme separat behandeln. Die folgenden Schritte zeigen Ihnen, wie Sie mehrere Ausnahmen mit nur einer except-Klausel behandeln. Dieses Beispiel finden Sie in der herunterladbaren Beispieldatei MehrereAusnahmen1.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

try:

Wert = int(input("Geben Sie eine Zahl zwischen 1 und 10 ein:"))

except (ValueError, KeyboardInterrupt):

print("Sie müssen eine Zahl zwischen 1 und 10 eingeben!")

else:

if (Wert > 0) and (Wert <= 10):

print("Sie haben eingegeben: ", Wert)

else:

print("Sie haben einen falschen Wert eingegeben!")

Dieser Code sieht dem Code aus EinfacheAusnahme1.py sehr ähnlich. Beachten Sie aber, dass die except-Klausel nun beide Ausnahmen, ValueError und KeyboardInterrupt, abfängt. Außerdem stehen diese Ausnahmen in Klammern und werden durch ein Komma getrennt.

3. Wählen Sie RUN|RUN MODULE aus.

Es öffnet sich ein Python-Shell-Fenster. Die Anwendung bittet Sie, eine Zahl zwischen 1 und 10 einzugeben.

4. Geben Sie Hallo ein und drücken Sie [Enter].

Die Anwendung zeigt eine Fehlermeldung an (siehe Abbildung 9.1).

5. Wiederholen Sie die Schritte 3 und 4, aber geben Sie 22 statt Hallo ein.

Die Anwendung gibt die erwartete Bereichsfehlermeldung aus (siehe Abbildung 9.2).

6. Wiederholen Sie die Schritte 3 und 4, aber drücken Sie jetzt [Strg]+[C], [MacBef]+[C] oder das Tastenkürzel, das auf Ihr System zutrifft, ohne irgendetwas einzugeben.

Sie sehen die Fehlermeldung, die normalerweise bei einer fehlerhaften Eingabe angezeigt wird (siehe Abbildung 9.1).

7. Wiederholen Sie die Schritte 3 und 4, aber geben Sie 7 statt Hallo ein.

Dieses Mal gibt die Anwendung schließlich aus, dass Sie einen korrekten Wert, nämlich 7, eingegeben haben.

Mehrere Ausnahmen mit mehreren »except«-Klauseln abfangen

Hat man es mit mehreren Ausnahmen zu tun, ist es meist besser, jede Ausnahme in eine eigene except-Klausel zu schreiben. Auf diese Weise können Sie für jede Ausnahme eine angepasste Ausnahmebehandlung programmieren und der Benutzer kann einfacher verstehen, was genau schiefgegangen ist. Natürlich bedeutet dieser Ansatz auch sehr viel mehr Arbeit. Die folgenden Schritte zeigen, wie Sie eine Ausnahmebehandlung mit mehreren except-Klauseln ausführen. Dieses Beispiel finden Sie auch in der Beispieldatei Mehrere Ausnahmen2.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

try:

Wert = int(input("Geben Sie eine Zahl zwischen 1 und 10 ein:"))

except ValueError:

print("Sie müssen eine Zahl zwischen 1 und 10 eingeben!")

except KeyboardInterrupt:

print("Sie haben Strg + C gedrückt!")

else:

if (Wert > 0) and (Wert <= 10):

print("Sie haben eingegeben: ", Wert)

else:

print("Sie haben einen falschen Wert eingegeben!")

Schauen Sie sich die except-Klauseln in diesem Beispiel an. Jede except-Klausel behandelt eine andere Ausnahme. Sie können auch eine Kombination aus den vorgestellten Methoden verwenden, indem Sie mit manchen except-Klauseln nur eine Ausnahme und mit anderen mehrere Ausnahmen behandeln. Python ermöglicht es Ihnen, die Methode herauszupicken, die am besten zu Ihrem aktuellen Problem bei der Ausnahmebehandlung passt.

3. Wählen Sie RUN|RUN MODULE aus.

Es öffnet sich ein Python-Shell-Fenster. Die Anwendung bittet Sie, eine Zahl zwischen 1 und 10 einzugeben.

4. Geben Sie Hallo ein und drücken Sie [Enter].

Die Anwendung zeigt eine Fehlermeldung an (siehe Abbildung 9.1).

5. Wiederholen Sie die Schritte 3 und 4, aber geben Sie 22 statt Hallo ein.

Die Anwendung gibt die erwartete Bereichsfehlermeldung aus (siehe Abbildung 9.2).

6. Wiederholen Sie die Schritte 3 und 4, aber drücken Sie jetzt [Strg]+[C], [MacBef]+[C] oder das Tastenkürzel, das auf Ihr System zutrifft, ohne irgendetwas einzugeben.

Die Anwendung gibt eine spezifische Meldung aus, die dem Benutzer sagt, was schiefgelaufen ist, wie man in Abbildung 9.6 sieht.

7. Wiederholen Sie die Schritte 3 und 4, aber geben Sie 7 statt Hallo ein.

Dieses Mal gibt die Anwendung schließlich aus, dass Sie einen korrekten Wert, nämlich 7, eingegeben haben.

Abbildung 9.6: Mit der Verwendung mehrerer except-Klauseln können
Sie spezifische Fehlermeldungen ausgeben.

Ausnahmebehandlung: vom Spezifischen zum weniger Spezifischen

Eine Strategie für die Ausnahmebehandlung ist, spezifische except-Klauseln für alle bekannten Ausnahmen anzugeben und generische except-Klauseln für alle unbekannten Ausnahmen. Sie können sich die von Python verwendete Ausnahmehierarchie unter https://docs.python.org/3.4/library/exceptions.html#exception-hierarchy anschauen. In diesem Diagramm ist die oberste Ausnahme BaseException. Die meisten Ausnahmen werden von der Klasse Exception abgeleitet. Für Fehler bei mathematischen Berechnungen können Sie zum Beispiel die allgemeinere Ausnahme ArithmeticError oder die speziellere Ausnahme ZeroDivisionError verwenden.

Python wertet die except-Klauseln in der Reihenfolge aus, in der sie im Code stehen. Die erste Klausel wird zuerst untersucht, die zweite als Zweites und so weiter. Mit den folgenden Schritten erstellen Sie ein Beispiel, an dem Sie sehr gut sehen können, wie wichtig die korrekte Ausnahmereihenfolge ist. In diesem Beispiel führen Sie Aufgaben aus, die mathematische Fehler erzeugen. Dieses Beispiel finden Sie auch als herunterladbare Datei in Mehrere Ausnahmen3.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

try:

Wert1 = int(input("Geben Sie die erste Zahl ein: "))

Wert2 = int(input("Geben Sie die zweite Zahl ein: "))

Ausgabe = Wert1/Wert2
except ValueError:

print("Sie müssen eine ganze Zahl eingeben!")

except KeyboardInterrupt:

print("Sie haben Strg + C gedrückt!")

except ArithmeticError:

print("Ein unbekannter mathematischer Fehler ist aufgetreten!")

except ZeroDivisionError:

print("Sie haben versucht, durch 0 zu teilen!")

else:

print(Ausgabe)

Der Code bittet den Benutzer zuerst, zwei Eingaben zu machen: Wert1 und Wert2. Die ersten zwei except-Klauseln behandeln unerwartete Eingaben. Die zweiten zwei except-Klauseln behandeln mathematische Fehler, wie das Teilen durch 0. Funktioniert alles wie gewünscht, dann wird der else-Zweig ausgeführt, der das Ergebnis der Berechnung ausgibt.

3. Wählen Sie RUN|RUN MODULE aus.

Es öffnet sich ein Python-Shell-Fenster. Die Anwendung bittet Sie, die erste Zahl einzugeben.

4. Geben Sie Hallo ein und drücken Sie [Enter].

Wie erwartet gibt Python die Fehlermeldung für die ValueError-Ausnahme aus. Es macht sich immer bezahlt, bekannte Fehler auszuschließen.

5. Wählen Sie RUN|RUN MODULE wieder aus.

Es öffnet sich ein Python-Shell-Fenster. Die Anwendung bittet Sie, die erste Zahl einzugeben.

6. Geben Sie 8 ein und drücken Sie [Enter].

Die Anwendung bittet Sie, die zweite Zahl einzugeben.

7. Geben Sie 0 ein und drücken Sie [Enter].

Sie sehen die Fehlermeldung für die ArithmeticError-Ausnahme, wie in Abbildung 9.7 zu sehen. Sie sollten aber eigentlich die Fehlermeldung für die ZeroDivisionError-Ausnahme sehen, da diese spezifischer ist als die ArithmeticError-Ausnahme.

Abbildung 9.7: Die Reihenfolge, in der Python Ausnahmen behandelt, ist wichtig.

8. Kehren Sie die Reihenfolge der beiden except-Klauseln folgendermaßen um:

except ZeroDivisionError:

print("Sie haben versucht, durch 0 zu teilen!")

except ArithmeticError:

print("Ein unbekannter mathematischer Fehler ist aufgetreten!")

9. Führen Sie die Schritte 5 bis 7 noch mal aus.

Dieses Mal sehen Sie die Fehlermeldung für die ZeroDivisionError-Ausnahme, da die except-Klauseln nun in der richtigen Reihenfolge stehen.

10. Führen Sie die Schritte 5 bis 7 noch mal aus, aber geben Sie als zweite Zahl 2 statt 0 ein.

Bei dieser Ausführung gibt die Anwendung schließlich den Wert 4.0 aus, wie in Abbildung 9.8 zu sehen.

Beachten Sie, dass die Ausgabe, die in Abbildung 9.8 gezeigt wird, eine Fließkommazahl ist. Eine Division ergibt einen Fließkommazahlwert, es sei denn, Sie geben mit dem Operator für die Ganzzahldivision (//) an, dass Sie einen Integer als Ergebnis haben möchten.

Abbildung 9.8: Gibt man vernünftige Werte ein, kommt auch ein vernünftiger Wert heraus.

Verschachtelte Ausnahmebehandlung

Manchmal ist es notwendig, eine Ausnahmebehandlungsroutine in eine andere zu schreiben. Dies wird Verschachtelung genannt. Bei der Verschachtelung von Ausnahmebehandlungsroutinen schaut Python immer zuerst in den inneren Ebenen nach, ob die Ausnahme dort behandelt wird, und arbeitet sich dann nach außen vor. Sie können Ausnahmebehandlungsroutinen beliebig tief schachteln, um Ihren Code sicher zu machen.

Einer der häufigsten Gründe, warum man die Ausnahmebehandlung in zwei Ebenen durchführt, ist, wenn Sie eine Eingabe vom Benutzer erwarten und diese in eine Schleife einbetten, um zu garantieren, dass Sie auch wirklich eine Eingabe vom Benutzer bekommen. Die folgenden Schritte zeigen Ihnen, wie so ein Programm funktioniert. Dieses Beispiel finden Sie in der Beispieldatei MehrereAusnahmen4.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

Nochmal = True

while Nochmal:

try:

Wert = int(input("Geben Sie eine ganze Zahl ein: "))

except ValueError:

print("Sie müssen eine ganze Zahl eingeben!")

try:

Wiederholen = input("Nochmal versuchen (j/n)? ")

except:

print("OK, bis zum nächsten Mal!")

Nochmal = False

else:

if (str.upper(Wiederholen) == "N"):

Nochmal = False

except KeyboardInterrupt:

print("Sie haben Strg+C gedrückt!")

print("Bis zum nächsten Mal!")

Nochmal = False

else:

print(Wert)

Nochmal = False

Der Code startet mit einer Eingabeschleife. Schleifen werden häufig zu diesem Zweck in Anwendungen verwendet, da die Anwendung nicht jedes Mal beendet werden soll, wenn ein Eingabefehler auftritt. Dies ist eine sehr vereinfachte Schleife und normalerweise schreibt man eine separate Funktion für diesen Code. Zu Beginn der Schleife bittet die Anwendung den Benutzer, eine ganze Zahl einzugeben. Das kann jeder beliebige Integer-Wert sein. Gibt der Benutzer keine ganze Zahl ein oder drückt [Strg]+[C], [MacBef]+[C] oder ein entsprechend anderes Tastaturkürzel zur Unterbrechung, kommt der Code für die Ausnahmebehandlung ins Spiel. Andernfalls gibt der Code den vom Benutzer eingegebenen Wert aus und setzt Nochmal auf False, wodurch die Schleife beendet wird. Eine ValueError-Ausnahme tritt auf, wenn der Benutzer einen Fehler macht. Da Sie nicht wissen, warum der Benutzer einen falschen Wert eingegeben hat, müssen Sie nachfragen, ob der Benutzer es noch einmal probieren möchte. Natürlich könnte die zweite Eingabe auch wieder zu einer Ausnahme führen. Der innere try...except-Block kümmert sich um mögliche Ausnahmen bei der zweiten Eingabe.

Beachten Sie die Verwendung der Funktion str.upper() bei der Verarbeitung der zweiten Eingabe des Benutzers. Diese Funktion erlaubt dem Benutzer, entweder j oder J als gültige Eingabe einzugeben. Immer, wenn Sie den Benutzer um eine Texteingabe bitten, die Sie gegen mögliche Antworten prüfen wollen, sollten Sie die Buchstaben in Großbuchstaben umwandeln, sodass Sie nur einen einzigen Vergleich machen müssen (Verringerung möglicher Fehler).

Die Ausnahme KeyboardInterrupt zeigt zwei Meldungen an und beendet dann automatisch die Schleife, indem Nochmal auf False gesetzt wird. Die Keyboard Interrupt-Ausnahme tritt nur dann auf, wenn der Benutzer eine spezielle Tastenkombination drückt, die die Anwendung beenden soll. Zu diesem Zeitpunkt möchte der Benutzer wahrscheinlich nicht mehr mit der Anwendung arbeiten.

3. Wählen Sie RUN|RUN MODULE aus.

Es öffnet sich ein Python-Shell-Fenster. Die Anwendung bittet den Benutzer, eine ganze Zahl einzugeben.

4. Geben Sie Hallo ein und drücken Sie [Enter].

Die Anwendung zeigt eine Fehlermeldung an und fragt, ob Sie es noch einmal versuchen.

5. Geben Sie J ein und drücken Sie [Enter].

Die Anwendung bittet Sie noch einmal, eine ganze Zahl einzugeben, wie in Abbildung 9.9 zu sehen.

Abbildung 9.9: Die Verwendung einer Schleife hilft der Anwendung, die Ausführung nach einem Fehler fortzuführen.

6. Geben Sie 5.5 ein und drücken Sie [Enter].

Die Anwendung zeigt wieder die Fehlermeldung an und fragt Sie, ob Sie es noch einmal versuchen wollen.

7. Drücken Sie [Strg]+[C], [MacBef]+[C] oder eine andere Tastenkombination, um die Anwendung zu beenden.

Die Anwendung wird beendet, wie in Abbildung 9.10 gezeigt. Beachten Sie, dass die Nachricht aus der inneren Ausnahmebehandlungsroutine kommt. Die Anwendung kommt nie zur äußeren Ausnahme, da die innere Ausnahmebehandlung generische Ausnahmen behandelt.

Abbildung 9.10: Die innere Ausnahmebehandlung kümmert sich um weitere Eingaben.

8. Wählen Sie RUN|RUN MODULE aus.

Sie sehen ein Python-Shell-Fenster. Die Anwendung bittet den Benutzer, eine ganze Zahl einzugeben.

9. Drücken Sie [Strg]+[C], [MacBef]+[C] oder eine andere Tastenkombination, um die Anwendung zu beenden.

Die Anwendung wird beendet, wie in Abbildung 9.11 zu sehen. Beachten Sie, dass die Meldung die aus der äußeren Ausnahme ist. In Schritt 7 und 9 beendet der Benutzer die Anwendung, indem er eine Tastenkombination zur Unterbrechung eingibt. Die Anwendung verwendet jedoch zwei verschiedene Ausnahmebehandlungen, um mit diesem Problem umzugehen.

Abbildung 9.11: Die äußere Ausnahmebehandlung kümmert sich um Ausnahmen
bei der ersten Eingabe.

Ausnahmen auslösen

Bisher haben die Beispiele in diesem Kapitel auf Ausnahmen reagiert. Es passiert etwas und die Anwendung bietet für dieses Ereignis eine Ausnahmebehandlung an. Es können jedoch auch Situationen auftreten, bei denen Sie zur Entwurfszeit der Anwendung nicht wissen, wie Sie diesen Fehler behandeln können. Vielleicht können Sie diesen Fehler nicht an der aktuellen Stelle behandeln, sondern müssen ihn an eine andere Stelle weiterleiten, wo er behandelt werden kann. Kurz gefasst muss Ihre Anwendung also in manchen Situationen in der Lage sein, eine Ausnahme zu generieren. Dieser Vorgang heißt Auslösen (oder manchmal auch Werfen) einer Ausnahme. Die folgenden Abschnitte beschreiben häufig auftretende Situationen, in denen Sie Ausnahmen mit bestimmten Methoden auslösen.

Ausnahmen unter außergewöhnlichen Umständen auslösen

Das Beispiel in diesem Abschnitt zeigt, wie Sie eine einfache Ausnahme auslösen können und dass dazu nichts Besonderes notwendig ist. Die folgenden Schritte erzeugen einfach eine Ausnahme, die dann sofort behandelt wird. Dieses Beispiel finden Sie in der herunterladbaren Datei AusnahmeAuslösen1.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

try:

raise ValueError
except ValueError:

print("Ausnahme vom Typ ValueError!")

Einen solchen Code werden Sie wahrscheinlich nicht programmieren, aber er demonstriert an einem sehr einfachen Beispiel sehr gut, wie das Auslösen einer Ausnahme funktioniert. In diesem Fall erscheint das raise in einem try...except-Block. Ein sehr einfacher raise-Aufruf gibt nur den Namen der auszulösenden (oder zu werfenden) Ausnahme an. Sie können als Teil der Ausgabe auch Parameter angeben, um zusätzliche Informationen zu übergeben.

Beachten Sie, dass dieser try...except-Block keinen else-Zweig hat, da es nach dem Aufruf nichts weiter zu tun gibt. Auch wenn Sie einen try...except-Block selten so verwenden werden, haben Sie jedoch die Möglichkeit dazu. Wenn Ihnen eine solche Situation begegnet, dann denken Sie daran, dass die else-Klausel immer optional ist. Allerdings müssen Sie zumindest eine except-Klausel angeben.

3. Wählen Sie RUN|RUN MODULE aus.

Es öffnet sich ein Python-Shell-Fenster. Die Anwendung zeigt den erwarteten Ausnahmetext an, wie in Abbildung 9.12 zu sehen.

Abbildung 9.12: Für das Auslösen einer Ausnahme müssen Sie lediglich raise verwenden.

Fehlerinformationen an den Aufrufer übergeben

Python bietet mit dem Übergeben von Informationen an den Aufrufer (der Code, der Ihren Code aufruft) eine außergewöhnlich flexible Ausnahmebehandlung an, egal welche Ausnahme Sie verwenden. Natürlich kann es sein, dass der Aufrufer gar nicht weiß, dass es diese Informationen gibt, und darum wird auch viel über dieses Thema diskutiert. Wenn Sie mit Code, der von jemand anderem geschrieben wurde, arbeiten und nicht wissen, ob zusätzliche Informationen verfügbar sind, können Sie die Technik, die in dem Kasten Eine Liste mit Ausnahmeparametern ausgeben lassen etwas weiter vorne in diesem Kapitel beschrieben ist, verwenden.

Vielleicht haben Sie sich schon gefragt, ob Sie bei einer ValueError-Ausnahme aufschlussreichere Informationen zur Verfügung stellen könnten, als es die ursprüngliche Python-Version tut. Die folgenden Schritte zeigen Ihnen, wie Sie die Ausgabe so abändern können, dass sie hilfreiche Informationen enthält. Dieses Beispiel finden Sie in der herunterladbaren Datei AusnahmeAuslösen2.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

try:

Ex = ValueError()

Ex.strerror = "Der Wert muss zwischen 1 und 10 liegen."

raise Ex
except ValueError as e:

print("Ausnahme vom Typ ValueError!", e.strerror)

Normalerweise hat die ValueError-Ausnahme kein Attribut strerror (ein üblicher Name für einen Fehlerstring), aber Sie können es einfach durch Zuweisung eines Wertes erstellen. Wird in dem Beispiel die Ausnahme ausgelöst, wird diese von der except-Klausel ganz normal abgefangen, man hat aber zusätzlich über die Variable e Zugriff auf die Attribute der Ausnahme. Sie können dann auf das Attribut e.strerror zugreifen, um die neuen Informationen abzufragen.

3. Wählen Sie RUN|RUN MODULE aus.

Es öffnet sich ein Python-Shell-Fenster. Die Anwendung zeigt die erweiterte ValueError-Ausnahme an, wie in Abbildung 9.13 zu sehen.

Abbildung 9.13: Sie können zusätzliche Informationen zu einer Ausnahme hinzufügen.

Benutzerdefinierte Ausnahmen erzeugen und verwenden

Python bietet Ihnen eine Fülle an Standardausnahmen an, die Sie wann immer möglich verwenden sollten. Diese Ausnahmen sind unglaublich flexibel und Sie können sie bei Bedarf sogar anpassen (wenn triftige Gründe dafür sprechen), um besondere Anforderungen zu erfüllen. Der Abschnitt Fehlerinformationen an den Aufrufer übergeben in diesem Kapitel zeigt zum Beispiel, wie Sie eine ValueError-Ausnahme anpassen, um zusätzliche Informationen zu übergeben. Aber manchmal sind Sie gezwungen, eine benutzerdefinierte Ausnahme zu erzeugen, da keine der Standardausnahmen für Ihren Zweck passt. Vielleicht drückt der Name der Ausnahme für den Betrachter nicht wirklich das aus, was sie eigentlich macht. Vielleicht brauchen Sie für bestimmte Datenbankaufgaben oder für die Verwendung eines Dienstes eine benutzerdefinierte Ausnahme.

Das Beispiel in diesem Abschnitt sieht zu diesem Zeitpunkt etwas kompliziert aus, da Sie bisher noch nicht mit Klassen gearbeitet haben. Kapitel 14 stellt Klassen vor und zeigt Ihnen, wie diese funktionieren. Sie können diesen Abschnitt problemlos überspringen, wenn Sie zuvor erst Kapitel 14 lesen wollen.

Das Beispiel in diesem Abschnitt zeigt Ihnen eine schnelle Methode, wie Sie Ihre eigenen Ausnahmen erstellen können. Dazu müssen Sie eine neue Klasse erzeugen, die eine schon existierende Klasse als Ausgangspunkt nimmt. Zur Vereinfachung erstellt dieses Beispiel eine Klasse, die auf der Funktionalität der ValueError-Ausnahme aufbaut. Der Vorteil dieser Methode gegenüber der Methode aus dem vorherigen Abschnitt Fehlerinformationen an den Aufrufer übergeben besteht darin, dass derjenige, der die Ausnahme benutzt, genau sieht, was die Ausnahme mehr als die herkömmliche ValueError-Ausnahme kann; zusätzlich ist die abgeänderte Ausnahme einfacher zu benutzen. Dieses Beispiel finden Sie in der Datei BenutzerdefinierteAusnahme.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

class BenutzerdefinierterValueError(ValueError):

def __init__(self,arg):

self.strerror = arg

self.args = {arg}

try:

raise BenutzerdefinierterValueError("Der Wert muss zwischen 1 und 10 liegen.")

except BenutzerdefinierterValueError as e:

print("Ausnahme vom Typ BenutzerdefinierterValueError!", e.strerror)

Dieses Beispiel implementiert im Grunde die Funktionalität des Beispiels im Abschnitt Fehlerinformationen an den Aufrufer übergeben dieses Kapitels. Es wird jedoch derselbe Fehler sowohl in strerror als auch in args gespeichert, sodass der Entwickler auf beides zugreifen kann (wie es normalerweise der Fall wäre).

Der Code beginnt mit der Erzeugung der Klasse BenutzerdefinierterValueError, die die Klasse ValueError als Basis verwendet. Mit der Funktion __init__() wird implementiert, dass eine neue Instanz der Klasse erzeugt werden kann. Stellen Sie sich die Klasse als Bauplan vor und eine Instanz als Gebäude, das nach diesem Bauplan gebaut wird.

Beachten Sie, dass das Attribut strerror den Wert direkt zugewiesen bekommt, während args ihn als Array übergeben bekommt. Das Attribut args enthält normalerweise ein Array aller Ausnahmewerte. Dieses Vorgehen ist also ganz normal, auch wenn args wie hier nur einen Wert enthält.

Der Code zur Verwendung der Ausnahme ist beträchtlich einfacher als der Code zur direkten Anpassung der ValueError-Ausnahme. Sie müssen einfach nur raise mit dem Namen der Ausnahme und den zu übergebenden Parametern aufrufen – alles in einer Zeile.

3. Wählen Sie RUN|RUN MODULE aus.

Es öffnet sich ein Python-Shell-Fenster. Die Anwendung zeigt den Ausnahmetext wie bei der Instanziierung der Ausnahme angegeben an und wie in Abbildung 9.14 zu sehen.

Abbildung 9.14: Benutzerdefinierte Ausnahmen können Ihren Code lesbarer machen.

Die »finally«-Klausel verwenden

Normalerweise möchten Sie jede auftretende Ausnahme so behandeln, dass die Anwendung nicht abstürzt. Aber manchmal können Sie das Problem einfach nicht lösen, und Ihre Anwendung wird mit ziemlicher Sicherheit abstürzen. An diesem Punkt angelangt, möchten Sie dann aber, dass Ihre Anwendung kontrolliert abstürzt. Das bedeutet, dass vorher zum Beispiel alle Dateien geschlossen werden, sodass der Benutzer keine Daten verliert. Es ist entscheidend und ein wichtiger Punkt bei einem abstürzenden Programm, dass der Schaden an Daten und System möglichst gering gehalten wird.

Die finally-Klausel ist ein Teil der Strategie für abstürzende Anwendungen. Man verwen-det diese Klausel für jegliche erforderliche Last-Minute-Aufgaben. Normalerweise ist die finally-Klausel recht kurz und verwendet nur Aufrufe, die sehr wahrscheinlich problemlos klappen. Es ist wichtig, Dateien zu schließen, Benutzer abzumelden und andere nötige Aufgaben zu erledigen, um dann die Anwendung abstürzen zu lassen, bevor irgendetwas anderes Schreckliches passiert (zum Beispiel ein Systemabsturz). Mit diesen notwendigen Aktionen im Hinterkopf zeigt das folgende einfache Beispiel die Verwendung der finally-Klausel. Das Beispiel finden Sie in der Datei AusnahmeMitFinally.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

import sys

try:

raise ValueError

print("Ausnahme wird ausgelöst.")

except ValueError:

print("Ausnahme vom Typ ValueError!")

sys.exit()

finally:

print("Hier kümmere ich mich um alle Last-Minute-Aufgaben.")

print("Dieser Code wird niemals ausgeführt.")

In diesem Beispiel löst der Code eine ValueError-Ausnahme aus. Die except-Klausel wird ganz normal ausgeführt. Der Aufruf von sys.exit() bedeutet, dass die Anwendung beendet wird, nachdem die Ausnahme behandelt wurde. Vielleicht kann die Anwendung sich in diesem konkreten Fall nicht mehr fangen, wird aber so ganz normal beendet und darum wird auch das letzte print nicht mehr ausgeführt.

Die finally-Klausel wird immer ausgeführt. Es ist dabei egal, ob die Ausnahme ausgelöst wird oder nicht. Der Code in diesem Block muss so allgemeingültig sein, dass er immer ausgeführt werden kann. Arbeiten Sie beispielsweise mit einer Datei, schreiben Sie Code zum Schließen der Datei in diesen Block, damit die Daten nicht durch das Verbleiben im Hauptspeicher beschädigt statt auf Festplatte gespeichert werden.

3. Wählen Sie RUN|RUN MODULE aus.

Es öffnet sich ein Python-Shell-Fenster. Die Anwendung zeigt die Meldungen aus der except-Klausel und aus der finally-Klausel an, wie in Abbildung 9.15 zu sehen. Der Aufruf sys.exit() verhindert die Ausführung von weiterem Code.

Abbildung 9.15: Verwenden Sie die finally-Klausel, damit bestimmte Aktionen vor dem Beenden der Anwendung auf jeden Fall noch ausgeführt werden.

4. Kommentieren Sie raise ValueError aus, indem Sie zwei Doppelkreuze wie folgt voranstellen:

## raise ValueError

Das Entfernen der Ausnahme zeigt, wie die finally-Klausel tatsächlich funktioniert.

5. Speichern Sie die Datei auf Festplatte, damit Python die Änderungen auf jeden Fall berücksichtigt.

6. Wählen Sie RUN|RUN MODULE aus.

Es öffnet sich ein Python-Shell-Fenster. Die Anwendung zeigt mehrere Nachrichten an, inklusive der Meldung aus der finally-Klausel, wie in Abbildung 9.16 zu sehen. Dieser Teil des Beispiels demonstriert, dass die finally-Klausel immer ausgeführt wird, und daher sollten Sie sie mit Bedacht verwenden.

Abbildung 9.16: Merken Sie sich gut, dass die finally-Klausel immer ausgeführt wird.

Teil III

Häufig benötigte Programmieraufgaben

In diesem Teil . . .

Greifen Sie auf Python-Module zu.

Schneiden Sie Strings nach Belieben auseinander.

Erstellen Sie Listen aus Objekten, die Sie verwalten wollen.

Verwenden Sie Collections, um Ihre Daten effizient zu strukturieren.

Schreiben Sie Klassen, um Ihren Code wiederverwendbar zu machen.

10

Mit Modulen arbeiten

In diesem Kapitel

Strukturieren Sie Ihren Code

Fügen Sie Ihrer Anwendung Code von außerhalb hinzu

Finden Sie gespeicherte Codebibliotheken

Schauen Sie sich den Code von Bibliotheken an

Beschaffen und lesen Sie die Dokumentation für Python-Bibliotheken

Die Beispiele in diesem Buch sind sehr kurz und die Funktionalität der daraus resultierenden Anwendungen ist ebenfalls sehr limitiert. Selbst die kleinsten »echten« Anwendungen enthalten mehrere Tausend Zeilen Code. Tatsächlich sind Anwendungen mit mehreren Millionen Zeilen Code die Regel. Nun stellen Sie sich vor, Sie müssten mit einer Datei arbeiten, die mehrere Millionen Zeilen Code enthält – Sie würden niemals etwas wiederfinden. Sie brauchen also eine Methode, wie Sie Ihren Code in kleinere Stückchen, die einfacher zu handhaben sind, teilen können, so wie die Beispiele in diesem Buch. Die Python-Lösung besteht darin, Code in separate Codegruppen zu packen, die sich Module nennen. Häufig verwendete Module, die Quellcode für allgemeine Zwecke enthalten, nennen sich Bibliotheken.

Module sind in separaten Dateien enthalten. Damit Sie das Modul verwenden können, müssen Sie Python Bescheid sagen, dass es die Datei suchen und in die aktuelle Anwendung laden soll. Der Prozess, sich Code aus externen Dateien zu besorgen, nennt sich Importieren. Sie importieren ein Modul oder eine Bibliothek, um den darin enthaltenen Code zu verwenden. Ein paar Beispiele im Buch haben die Verwendung der import-Anweisung schon gezeigt, aber in diesem Kapitel wird die import-Anweisung ausführlich erklärt, damit Sie wissen, wie Sie sie benutzen können.

Als Teil der initialen Vorbereitungen erstellt Python einen Zeiger auf die universellen Bibliotheken, die es verwendet. Daher können Sie einfach die import-Anweisung mit dem Namen der Bibliothek hinzufügen und Python findet diese dann. Trotzdem zahlt es sich aus, wenn Sie wissen, wo Sie diese Dateien auf der Festplatte finden, falls Sie sie mal aktualisieren müssen oder Ihre eigenen Module und Bibliotheken zu der Liste der Dateien hinzufügen wollen, die Python benutzen kann.

Der Bibliothekscode ist in sich abgeschlossen und gut dokumentiert (zumindest in den meisten Fällen). Manche Entwickler meinen, dass sie nie in den Code der Bibliotheken schauen müssen, und in gewissem Maße haben sie recht – Sie müssen den Bibliothekscode nicht anschauen, nur um ihn zu verwenden. Sie möchten den Code vielleicht aber anschauen, damit Sie wissen, wie er funktioniert. Außerdem können Sie sich von dem Code der Bibliotheken neue Programmiertechniken abschauen, die Sie vielleicht sonst nicht kennengelernt hätten. Das Anschauen des Bibliothekscodes ist nicht zwingend notwendig, aber kann ganz hilfreich sein.

Eine wichtige Sache, die Sie wissen müssen, ist, wie Sie die Dokumentation der PythonBibliotheken aufrufen und verwenden können. Dieses Kapitel zeigt Ihnen, wie Sie bei der Anwendungserstellung die Dokumentation öffnen und verwenden können.

Code gruppieren

Es ist wichtig, Teile des Codes zusammenzufassen, damit er einfacher zu verwenden, zu ändern und zu verstehen ist. Wächst eine Anwendung mit der Zeit, wird Code in einer einzelnen Datei immer schwerer zu finden sein. Irgendwann wird es unmöglich, den Code zu warten, da die Datei zu groß geworden ist, um damit vernünftig arbeiten zu können.

Der Begriff Code wird in diesem speziellen Fall sehr weit gefasst. Codegruppen können Folgendes beinhalten:

Klassen

Funktionen

Variablen

Ausführbarer Code

Die Sammlung aus Klassen, Funktionen, Variablen und ausführbarem Code innerhalb eines Moduls wird Attribute genannt. Ein Modul hat Attribute, auf die Sie über ihre Namen zugreifen können. Abschnitte weiter hinten in diesem Kapitel erklären genau, wie der Modulzugriff funktioniert.

Der ausführbare Code kann sogar in einer anderen Sprache als Python geschrieben sein. Zum Beispiel kommt es häufig vor, dass es Module gibt, die in C/C++ geschrieben wurden statt in Python. Entwickler verwenden ausführbaren Code, um die Python-Anwendung schneller zu machen, weniger Ressourcen zu verwenden und um die Ressourcen einer bestimmten Plattform besser zu nutzen. Die Verwendung von ausführbarem Code hat den Nachteil, dass Ihre Anwendung weniger portabel (auf anderen Systemen lauffähig) ist, es sei denn, Sie haben für jede Plattform, die Sie unterstützen wollen, eigene Module mit ausführbarem Code. Außerdem können zweisprachige Anwendungen schwieriger zu warten sein, da die Entwickler beide Sprachen beherrschen müssen.

Die gebräuchlichste Methode, ein Modul zu erstellen, ist, eine separate Datei zu erstellen, die den Code enthält, den Sie von dem Rest des Anwendungscodes trennen wollen. Sie möchten vielleicht eine Druckfunktion schreiben, die von einer Anwendung an mehreren Stellen verwendet wird. Die Druckfunktion ist nicht dazu gedacht, allein für sich zu existieren, sondern sie ist Teil der gesamten Anwendung. Sie wollen sie vom Rest trennen, da sie an vielen verschiedenen Stellen verwendet wird und Sie den Code möglicherweise noch in einer anderen Anwendung benutzen wollen. Die Wiederverwendbarkeit von Code ist einer der wichtigsten Gründe, warum man Module erstellen sollte.

Damit die Beispiele in diesem Kapitel einfacher zu verstehen sind, verwenden sie alle ein gemeinsames Modul. Das Modul tut nichts wirklich Aufregendes, aber man kann daran die Prinzipien der Arbeit mit Modulen gut demonstrieren. Öffnen Sie ein Editierfenster und erstellen Sie eine neue Datei mit dem Namen MeineBibliothek.py. Geben Sie den Code aus Listing 10.1 ein und speichern Sie die Datei. (Dieses Modul können Sie ebenfalls herunterladen.)

def HalloSagen(Name):

print("Hallo ", Name)

return

def AufWiedersehenSagen(Name):

print("Auf Wiedersehen ", Name)

return

Listing 10.1: Ein einfaches Beispielmodul

Der Beispielcode enthält die beiden einfachen Funktionen HalloSagen() und AufWiedersehenSagen(). In beiden Fällen übergeben Sie einen Namen für die Ausgabe und die Funktion gibt ihn mit einer Grußformel auf dem Bildschirm aus. Danach gibt die Funktion die Steuerung wieder an den Aufrufer zurück. Normalerweise würden Sie natürlich komplexere Funktionen schreiben, aber diese Funktionen sind für die Zwecke dieses Kapitels bestens geeignet.

Module importieren

Um ein Modul zu verwenden, müssen Sie es importieren. Python platziert den Modulcode dann zusammen mit dem Rest Ihrer Anwendung in den Hauptspeicher – so, als wenn Sie eine große Datei geschrieben hätten. Es wird keine Datei auf der Festplatte geändert – die Dateien sind immer noch voneinander getrennt, aber die Art und Weise, wie Python den Code betrachtet, ändert sich.

Es gibt zwei Methoden, Module zu importieren. Jede Methode wird unter bestimmten Umständen verwendet:

import: Sie verwenden die import-Anweisung, wenn Sie ein komplettes Modul importieren wollen. Dies ist die gebräuchlichste Methode, mit der Entwickler Module importieren, da sie Zeit spart und nur eine Zeile Code benötigt. Aber diese Methode verbraucht auch mehr Speicher als die im nächsten Absatz beschriebene Methode, die nur die benötigten Attribute importiert.

from...import: Man verwendet die from...import-Anweisung, wenn man nur einzelne Attribute eines Moduls importieren möchte. Diese Methode spart Ressourcen ein, ist aber auch komplizierter. Außerdem gibt Python sofort einen Fehler aus, wenn Sie ein Attribut verwenden, das Sie nicht importiert haben. Natürlich enthält das Modul immer noch das Attribut, aber Python findet es nicht, da Sie es nicht importiert haben.

Da Sie nun etwas mehr darüber wissen, wie man Module importiert, sollten wir uns den Modulen etwas ausführlicher widmen. Die folgenden Abschnitte erklären Ihnen, wie Sie mit den zwei in Python verfügbaren Methoden Module importieren können.

Das aktuelle Python-Verzeichnis ändern

Das Verzeichnis, das Python verwendet, um auf Code zuzugreifen, legt fest, welche Module Sie laden können. Die Bibliotheksdateien von Python stehen immer auf der Liste der Speicherorte, auf die Python zugreifen kann, aber Python kennt Ihr Verzeichnis, in dem Sie Ihren Quellcode verwalten, so lange nicht, bis Sie ihm sagen, dass es dort nachschauen soll. Am einfachsten können Sie das ändern, indem Sie mit den folgenden Schritten das aktuelle Python-Verzeichnis auf Ihr Quellcodeverzeichnis zeigen lassen:

1. Öffnen Sie eine Python-Shell.

Das Python-Shell-Fenster erscheint.

2. Geben Sie import os ein und drücken Sie [Enter].

Dieser Schritt importiert die Python-Bibliothek os. Sie müssen diese Bibliothek laden, um das Verzeichnis (den Ort, in dem Python auf Ihrer Festplatte nachschaut) auf das Verzeichnis mit dem Code für dieses Buch zeigen zu lassen.

3. Geben Sie os.chdir("C:\MPplfD\Kapitel10") ein und drücken Sie [Enter].

Sie müssen das Verzeichnis angeben, das die heruntergeladenen Beispieldateien oder Ihre eigenen Projektdateien auf der Festplatte enthält. Das Buch verwendet das in Kapitel 4 beschriebene Standardverzeichnis. Python kann nun das Verzeichnis mit den Beispieldateien für den Zugriff auf die in diesem Kapitel erzeugten Beispiele verwenden.

Die »import«-Anweisung verwenden

Die import-Anweisung wird am häufigsten für den Import eines Moduls in Python verwendet. Diese Methode ist schnell und garantiert, dass das gesamte Modul direkt verwendet werden kann. Die folgenden Schritte zeigen Ihnen, wie Sie die import-Anweisung benutzen können.

1. Öffnen Sie eine Python-Shell.

Ein Python-Shell-Fenster erscheint.

2. Ändern Sie das aktuelle Verzeichnis auf das Verzeichnis mit den Beispieldateien.

Folgen Sie den Anweisungen aus dem Kasten Das aktuelle Python-Verzeichnis ändern.

3. Geben Sie import MeineBibliothek ein und drücken Sie [Enter].

Python importiert die Inhalte aus der Datei MeineBibliothek.py, die Sie in dem Abschnitt Code gruppieren in diesem Kapitel angelegt haben. Die gesamte Bibliothek steht nun zur Verfügung.

Python speichert die Datei zusätzlich im Unterverzeichnis __pycache__ zwischen. Wenn Sie in Ihr Quellcodeverzeichnis gucken, nachdem Sie zum ersten Mal MeineBibliothek importiert haben, werden Sie dort das Verzeichnis __pycache__ finden. Wenn Sie das Modul ändern wollen, müssen Sie dieses Verzeichnis löschen. Andernfalls wird Python weiterhin die ursprüngliche zwischengespeicherte Datei verwenden, statt der aktualisierten Version Ihrer Quellcodedatei.

4. Geben Sie dir(MeineBibliothek) ein und drücken Sie [Enter].

Sie sehen eine Auflistung des Modulinhalts, der die Funktionen HalloSagen() und AufWiedersehenSagen() enthält, wie in Abbildung 10.1 zu sehen. (Eine Erklärung für die anderen Einträge finden Sie im Abschnitt Sich den Modulinhalt anschauen in diesem Kapitel.)

Abbildung 10.1: Die Auflistung des Verzeichnisses zeigt, dass Python beide Funktionen aus dem Modul importiert.

5. Geben Sie MeineBibliothek.HalloSagen("Stefan") ein und drücken Sie [Enter].

Die Funktion HalloSagen() gibt, wie erwartet, den Text aus, wie auch in Abbildung 10.2 zu sehen.

Abbildung 10.2: Die Funktion HalloSagen() gibt die erwartete Grußformel aus.

Beachten Sie, dass Sie dem Attributnamen, der in diesem Fall die Funktion HalloSagen() ist, den Modulnamen voranstellen müssen, nämlich Meine Bibliothek. Die zwei Elemente werden durch einen Punkt getrennt. Jeder Aufruf eines Moduls, das Sie importiert haben, folgt demselben Schema.

6. Geben Sie MeineBibliothek.AufWiedersehenSagen("Sandra") ein und drücken Sie [Enter].

Die Funktion AufWiedersehenSagen() gibt den erwarteten Text aus.

7. Schließen Sie die Python-Shell.

Das Python-Shell-Fenster schließt sich.

Die »from…import«-Anweisung verwenden

Die from...import-Anweisung bietet den Vorteil, dass Sie nur die Attribute eines Moduls importieren, die Sie tatsächlich brauchen. Das bedeutet, dass das Modul weniger Speicher und andere Systemressourcen verbraucht als die Verwendung der import-Anweisung. Außerdem vereinfacht die from...import-Anweisung die Verwendung des Moduls, da manche Befehle, wie dir(), weniger Informationen anzeigen oder nur die Informationen, die Sie tatsächlich brauchen. Der Punkt ist, dass Sie nur das bekommen, was Sie brauchen, und nichts weiter. Die folgenden Schritte zeigen die Verwendung der from...import-Anweisung.

1. Öffnen Sie eine Python-Shell.

Ein Python-Shell-Fenster erscheint.

2. Ändern Sie das aktuelle Verzeichnis auf das Verzeichnis mit den Beispieldateien.

Folgen Sie den Anweisungen aus dem Kasten Das aktuelle Python-Verzeichnis ändern.

3. Geben Sie from MeineBibliothek import HalloSagen() ein und drücken Sie [Enter].

Python importiert die Funktion HalloSagen(), die Sie im Abschnitt Code gruppieren am Anfang dieses Kapitels erstellt haben. Nur diese spezielle Funktion kann jetzt verwendet werden.

Sie können trotzdem noch das gesamte Modul importieren, wenn Sie das möchten. Sie können entweder eine Liste von zu importierenden Funktionen (die Namen können mit Kommas getrennt werden, wie in from MeineBibliothek import HalloSagen, AufWiedersehenSagen) schreiben oder das Sternchen anstelle eines spezifischen Attributnamen. Das Sternchen symbolisiert ein Platzhalterzeichen, sodass alles importiert wird.

4. Geben Sie dir(MeineBibliothek) ein und drücken Sie [Enter].

Python gibt eine Fehlermeldung aus, wie Abbildung 10.3 zeigt. Python importiert nur die Module, die Sie explizit angefordert haben, das bedeutet, dass das Modul Meine Bibliothek nicht im Speicher liegt – nur die von Ihnen importierten Attribute sind im Speicher.

Abbildung 10.3: Die from...import-Anweisung importiert nur die Elemente, die Sie explizit angefragt haben.

5. Geben Sie dir(HalloSagen) ein und drücken Sie [Enter].

Es wird eine Auflistung der Attribute ausgegeben, die mit der Funktion HalloSagen() verknüpft sind, wie in Abbildung 10.4 zu sehen. Sie müssen diese Attribute jetzt noch nicht kennen, aber manche davon werden Sie noch später in diesem Buch verwenden.

Abbildung 10.4: Sie können die Funktion dir() verwenden, um über die von Ihnen importierten Attribute mehr zu erfahren.

6. Geben Sie HalloSagen("Doro") ein und drücken Sie [Enter].

Die Funktion HalloSagen() gibt den zu erwartenden Text aus, wie in Abbildung 10.5 gezeigt.

Importieren Sie Attribute mit der from...import-Anweisung, dann brauchen Sie dem Attributnamen den Modulnamen nicht voranzustellen. Dadurch kann man einfacher auf die Attribute zugreifen.

Abbildung 10.5: Für die Funktion HalloSagen() wird der Modulname nicht mehr benötigt.

Die Verwendung der from...import-Anweisung kann auch Probleme machen. Haben zwei Attribute denselben Namen, können Sie nur eins davon importieren. Die import-Anweisung beugt Namenskollisionen vor, wenn Sie sehr viele Attribute importieren müssen. Sie sollten also Vorsicht walten lassen, wenn Sie die from...import-Anweisung benutzen.

7. Geben Sie AufWiedersehenSagen("Tobi") ein und drücken Sie [Enter].

Sie haben nur die Funktion HalloSagen() importiert, daher kennt Python die Funktion AufWiedersehenSagen() nicht und zeigt eine Fehlermeldung an. Die selektive Natur der from...import-Anweisung kann Probleme verursachen, wenn Sie annehmen, dass ein nicht importiertes Attribut verfügbar ist.

8. Schließen Sie die Python-Shell.

Das Python-Shell-Fenster wird geschlossen.

Module finden

Um den Code eines Moduls zu verwenden, muss Python dieses Modul finden und in den Speicher laden können. Die Informationen über die Speicherorte sind in Python als Pfade hinterlegt. Bei jeder Aufforderung an Python, ein Modul zu importieren, durchkämmt Python alle Dateien in seiner Pfadliste. Die Pfadinformationen kommen aus drei verschiedenen Quellen:

Umgebungsvariablen: Kapitel 3 erklärt, welche Umgebungsvariablen es gibt. Zum Beispiel ist PYTHONPATH eine, die Python sagt, wo auf der Festplatte es Module findet.

Aktuelles Verzeichnis: Am Anfang dieses Kapitels haben Sie erfahren, wie Sie das aktuelle Python-Verzeichnis ändern können, damit Python alle Module findet, die von Ihrer Anwendung verwendet werden.

Standardverzeichnisse: Selbst, wenn Sie keine Umgebungsvariablen definiert haben und das aktuelle Python-Verzeichnis keine nützlichen Module enthält, findet Python immer noch seine Standardbibliotheken in einer Liste mit Standardverzeichnissen, die auch in der Liste mit den Pfadinformationen steht.

Es ist hilfreich, wenn Sie wissen, wie die aktuelle Pfadliste aussieht, da das Fehlen eines Pfads dazu führen kann, dass Ihre Anwendung nicht kompiliert. Die folgenden Schritte zeigen Ihnen, wie Sie sich die aktuellen Pfadinformationen anschauen können.

1. Öffnen Sie eine Python-Shell.

Ein Python-Shell-Fenster öffnet sich.

2. Geben Sie import sys ein und drücken Sie [Enter].

3. Geben Sie for p in sys.path ein und drücken Sie [Enter].

Python rückt die nächste Zeile für Sie automatisch ein. Das Attribut sys.path enthält immer eine Auflistung der Standardpfade.

4. Geben Sie print(p) ein und drücken Sie zweimal [Enter].

Sie sehen eine Liste mit den Pfadinformationen, wie in Abbildung 10.6 zu sehen. Es kann sein, dass sich Ihre Liste von der in Abbildung 10.6 unterscheidet, da diese von Ihrem System, der installierten Python-Version und den installierten Python-Features abhängt.

Abbildung 10.6: Das Attribut sys.path enthält eine Auflistung der
einzelnen Pfade für Ihr System.

Das Attribut sys.path enthält schon einige Pfadinformationen, aber eventuell nicht alle, die Python tatsächlich finden kann. Wird ein Pfad mit sys.path nicht angezeigt, können Sie immer noch an einem anderen Ort nachschauen, wo Python seine Pfadinformationen speichert.

Die folgenden Schritte zeigen Ihnen, wie man das macht.

1. Geben Sie import os ein und drücken Sie [Enter].

2. Geben Sie os environ[´PYTHONPATH´].split(os.pathsep) ein und drücken Sie [Enter].

Ist die PYTHONPATH-Variable konfiguriert, sehen Sie nun eine Liste mit Pfaden, wie in Abbildung 10.7 gezeigt. Gibt es diese Variable aber nicht, bekommen Sie stattdessen eine Fehlermeldung.

Abbildung 10.7: Sie müssen Informationen aus Umgebungsvariablen separat abrufen.

Beachten Sie, dass sowohl sys.path als auch os.environ[´PYTHONPATH´] den Eintrag C:\MPplfD\Kapitel10 enthält. Das Attribut sys.path stellt die Pfade bequem als Auflistung zur Verfügung und daher können Sie sie mit einer for-Schleife im Beispiel durchlaufen. Die Umgebungsvariable enthält die Pfade als eine lange Zeichenkette, die durch jeweils ein Semikolon getrennt werden, sodass Sie die Zeichenkette erst einmal mit der Funktion split() in eine lesbare Form bringen müssen. Sie müssen der Funktion split() eine Zeichenkette übergeben, nach der sie in der zu teilenden Zeichenkette suchen soll. Die Konstante (also eine Variable, die einen sich nicht ändernden Wert enthält) os.pathsep enthält den Separator für Pfade für das aktuelle Betriebssystem, sodass Sie denselben Code auf jedem beliebigen System, auf dem Python läuft, wiederverwenden können.

3. Schließen Sie die Python-Shell.

Das Python-Shell-Fenster schließt sich.

Sie können der Auflistung unter sys.path auch Elemente hinzufügen oder daraus löschen. Wenn Sie beispielsweise Kapitel 9 zu der Modulliste hinzufügen wollen, geben Sie in das Python-Shell-Fenster sys.path.append("C:\\ MPplfD\\Kapitel09") ein und drücken [Enter]. Listen Sie sich nun die Inhalte der sys.path-Variablen wieder auf, werden Sie feststellen, dass der neue Eintrag hinzugefügt wurde. Um einen Eintrag zu entfernen, können Sie entsprechend sys.path.remove("C:\\MPplfD\\Kapitel09") eingeben und [Enter] drücken.

Sich den Modulinhalt anschauen

Python stellt Ihnen viele verschiedene Methoden zur Verfügung, um sich den Modulinhalt anzuschauen. Die Methode, die die meisten Entwickler einsetzen, ist die Verwendung der Funktion dir(), die Ihnen sagt, welche Attribute dieses Modul enthält.

Schauen Sie sich Abbildung 10.1 etwas weiter vorne in diesem Kapitel an. Zusätzlich zu den Funktionseinträgen HalloSagen() und AufWiedersehenSagen(), die zuvor erklärt wurden, besitzt die Liste noch weitere Einträge. Diese Attribute werden von Python automatisch für Sie erzeugt. Diese Attribute haben die folgenden Aufgaben oder enthalten die folgenden Informationen:

__builtins__: Enthält eine Liste aller integrierten Attribute, die im Modul verfügbar sind. Python fügt diese Attribute automatisch für Sie hinzu.

__cached__: Gibt Ihnen den Namen und Speicherort der gecachten Datei zurück, die zu dem Modul gehört. Der Pfad wird relativ zu dem aktuellen Python-Verzeichnis angegeben.

__doc__: Gibt Hilfeinformationen über das Modul aus – natürlich nur, falls Sie diese zuvor auch eingetragen haben. Geben Sie beispielweise os.__doc__ ein und drücken [Enter], gibt Ihnen Python die Hilfeinformationen, die zu der Bibliothek os gehören, aus.

__file__: Gibt Ihnen Namen und Speicherort des Moduls zurück. Der Pfad wird relativ zu dem aktuellen Python-Verzeichnis angegeben.

__initializing__: Gibt an, ob sich das Modul gerade in der Initialisierungsphase befindet. Normalerweise gibt dieses Attribut den Wert False zurück. Dieses Attribut ist nützlich, wenn Sie warten müssen, bis ein Modul geladen ist, bevor Sie ein anderes Modul, das von diesem Modul abhängig ist, importieren können.

__loader__: Gibt die Informationen über den Lader für dieses Modul aus. Der Lader ist eine Software, die sich die Module holt und in den Hauptspeicher lädt, damit Python sie verwenden kann. Das ist ein Attribut, das Sie wahrscheinlich selten (wenn überhaupt) benutzen werden.

__name__: Teilt Ihnen den Namen des Moduls mit.

__package__: Dieses Attribut wird intern vom Importsystem verwendet, um die Module einfacher laden und verwalten zu können. Dieses Attribut ist für Sie eher weniger von Interesse.

Sie können diese Attribute sogar noch weiter aufschlüsseln. Geben Sie dir(MeineBibliothek. HalloSagen) ein und drücken Sie [Enter]. Sie sehen die Einträge, die in Abbildung 10.8 abgebildet sind.

Manche dieser Einträge, wie __name__, waren auch schon in der Auflistung für das Modul vertreten. Vielleicht möchten Sie aber auch etwas über andere Einträge wissen. Zum Beispiel könnten Sie sich dafür interessieren, was __sizeof__ tut. Ein Methode, um zusätzliche Informationen zu bekommen, ist help("__sizeof__") einzugeben und [Enter] zu drücken. Sie bekommen ein paar dürftige (aber nützliche) Hilfeinformationen geliefert, wie in Abbildung 10.9 zu sehen.

Abbildung 10.8: Gehen Sie in der Modulhierarchie so weit nach unten, wie benötigt, um die von Ihnen in Python verwendeten Module zu verstehen.

Abbildung 10.9: Versuchen Sie mal über ein Attribut, das Sie interessiert, ein paar Hilfeinformationen zu bekommen.

Python wird nicht gleich explodieren, wenn Sie dieses Attribut mal ausprobieren. Selbst wenn die Shell mal Probleme macht, können Sie jederzeit eine neue starten. Eine andere Methode, etwas über ein Modul zu erfahren, ist also, es einfach mal auszuprobieren. Geben Sie beispielsweise MeineBibliothek.HalloSagen().__sizeof__() ein und drücken Sie [Enter], dann wird Ihnen die Größe von HalloSagen() in Bytes angezeigt, wie man in Abbildung 10.10 sieht.

Abbildung 10.10: Beim Testen der Attribute bekommen Sie ein besseres Gefühl dafür, wie sie funktionieren.

Im Gegensatz zu anderen Programmiersprachen steht in Python der Quellcode für die integrierten Sprachbibliotheken frei zur Verfügung. Wenn Sie beispielsweise in das Verzeichnis \Python34\Lib schauen, sehen Sie eine Liste mit .py-Dateien, die Sie problemlos in IDLE öffnen können. Versuchen Sie mal, die Bibliothek os.py zu öffnen, die Sie schon für verschiedene Zwecke in diesem Kapitel verwendet haben. Sie werden dann den Inhalt, der in Abbildung 10.11 abgebildet ist, auch sehen.

Das Anschauen des Quellcodes kann Ihnen neue Programmiertechniken eröffnen und Sie können besser verstehen, wie die Bibliothek funktioniert. Je mehr Sie mit Python arbeiten, desto besser werden Sie es zum Erstellen toller Anwendungen einsetzen können.

Passen Sie auf, dass Sie den Quellcode der Bibliothek nur anschauen, aber nicht aus Versehen ändern. Sollten Sie ihn aus Versehen ändern, könnte es sein, dass Ihre Anwendungen nicht mehr richtig funktionieren. Noch schlimmer – Sie könnten kleine Fehler einbauen, die dann nur auf Ihrem System existieren und nirgendwo sonst. Seien Sie stets vorsichtig, wenn Sie den Quellcode der integrierten Bibliotheken öffnen.

Die Python Module Documentation verwenden

Immer, wenn Sie schnell Hilfe brauchen, können Sie die doc()-Funktion verwenden. Aber es gibt noch eine bessere Methode, um die Module und Bibliotheken im Python-Pfad zu untersuchen – die Python Module Documentation (die Moduldokumentation). Diese Dokumentation finden Sie meist als Module Docs in dem Python-Verzeichnis auf Ihrem System. Man benutzt auch den Begriff pydoc. Wie auch immer Sie es nennen, die Python Module Documentation erleichtert das Leben der Entwickler. Die folgenden Abschnitte erklären Ihnen, wie man mit dieser Dokumentation arbeitet.

Abbildung 10.11: Das Anschauen des Quellcodes eines Moduls kann zum Verstehen des Moduls beitragen.

Die pydoc-Anwendung öffnen

Pydoc ist eine normale Python-Anwendung. Sie finden sie in dem Verzeichnis \Python34\ Lib als Datei pydoc.py auf Ihrem System. Sie können sie, genauso wie alle anderen .py-Dateien, in IDLE öffnen und sich anschauen, wie sie funktioniert. Sie können sie mit der Module-Docs-Verknüpfung aus dem Python-Verzeichnis auf Ihrem System heraus oder mit einem Befehl in der Kommandozeile starten. Falls Sie Python auf Windows ausführen, beachten Sie bitte den nachfolgenden Kasten.

Die Anwendung erstellt einen lokalen Server, auf den Sie über Ihren Browser zugreifen können, um sich Informationen zu den Python-Modulen und Bibliotheken anzuschauen. Sobald Sie also diese Anwendung starten, erscheint ein Kommandozeilenfenster (oder Terminal-Fenster), so wie in Abbildung 10.12 zu sehen.

Abbildung 10.12: Wenn pydoc aufgerufen wird, öffnet sich ein Kommandozeilen- oder Terminal-Fenster, in dem der Server gestartet wird.

Auf pydoc in Windows zugreifen

Bei der Windows-Installation von Python gibt es ein Problem. Die Verknüpfung existiert im Python-Verzeichnis nicht. Natürlich ist das sehr verwirrend, weil Benutzer das Gefühl haben, dass mit ihrem System oder Python etwas nicht stimmt. Aber die Verknüpfung ist schlicht und einfach nicht vorhanden, Sie können pydoc aber trotzdem benutzen. Die Verknüpfung können Sie sich mit den folgenden Schritten schnell selbst erstellen:

1. Klicken Sie mit der rechten Maustaste auf den Desktop und wählen Sie NEU|VERKNÜPFUNG aus dem erscheinenden Kontextmenü aus.

Der Assistent VERKNÜPFUNG ERSTELLEN erscheint.

2. Geben Sie C:\Python34\python.exe C:\Python34\Lib\pydoc.py –b ein und klicken Sie auf WEITER.

Dieser Befehl startet einen pydoc-Server, mit dem Sie auf die Modulinformationen zugreifen können.

3. Geben Sie pydoc ein und klicken Sie auf FERTIGSTELLEN.

Windows erstellt für Sie eine neue Verknüpfung. Mit dieser Verknüpfung können Sie dann auf die Hilfeinformationen für die Module zugreifen.

Wie bei anderen Servern auch fragt Ihr System wahrscheinlich die Ausführungsberechtigungen ab. Sie bekommen dann vielleicht eine Warnung Ihrer Firewall, dass pydoc versucht, auf das lokale System zuzugreifen. Sie müssen pydoc die entsprechenden Berechtigungen für Ihr System erteilen, damit Sie es verwenden können. Sollte Ihr installierter Virenscanner sich melden, müssen Sie auch hier die entsprechenden Berechtigungen erteilen, damit pydoc ausgeführt werden kann. Auf manchen Betriebssystemen, wie Windows, müssen Sie pydoc eventuell mit erhöhten Berechtigungen ausführen.

Normalerweise öffnet der Server dann ein neues Browserfenster für Sie, wie in Abbildung 10.13 zu sehen. Dieses Fenster enthält Links auf die verschiedenen Module, die auf Ihrem System vorhanden sind, inklusive aller benutzerdefinierten Module, die Sie erstellt und in den Python-Pfad aufgenommen haben. Um sich die Informationen über ein Modul anzuschauen, können Sie direkt auf seinen Link klicken.

Abbildung 10.13: Ihr Browser zeigt Ihnen einige Links als Teil der Indexseite an.

Die Befehlszeile stellt Ihnen zwei Befehle zum Steuern des Servers zur Verfügung. Sie müssen einfach nur den mit dem Befehl verknüpften Buchstaben eingeben und [Enter] drücken, um ihn auszuführen. Es gibt folgende Befehle:

b: Startet eine neue Instanz des Standardbrowsers mit der Indexseite.

q: Stoppt den Server.

Wenn Sie mit dem Nachlesen der Hilfeinformationen fertig sind, beenden Sie unbedingt den Server durch Eingabe von q und Drücken der Taste [Enter] in der Befehlszeile. Das Beenden des Servers gibt die verwendeten Ressourcen wieder frei und stellt sicher, dass der Server nicht die ganze Zeit im Hintergrund ausgeführt wird.

Die Links für den Schnellzugriff verwenden

Schauen Sie sich noch mal Abbildung 10.13 an. Rechts oben auf der Seite sehen Sie drei Links. Mit diesen Links haben Sie schnellen Zugriff auf die von der Seite bereitgestellten Funktionen. Der Browser startet immer mit der Seite MODULE INDEX. Wenn Sie zu dieser Seite zurückkehren wollen, klicken Sie einfach auf den Link MODULE INDEX.

Der Link TOPICS bringt Sie auf die in Abbildung 10.14 gezeigte Seite. Diese Seite enthält Links zu wichtigen Python-Themen. Wenn Sie beispielsweise mehr über boolesche Werte erfahren wollen, klicken Sie auf den Link BOOLEAN. Die Seite, die Sie nun sehen, beschreibt, wie boolesche Werte in Python funktionieren. Am Ende der Seite gibt es Links, die zu verwandten Themen führen und Ihnen weitere nützliche Informationen anzeigen.

Abbildung 10.14: Auf der Seite TOPICS finden Sie Informationen zu grundlegenden Python-Themen, zum Beispiel zu booleschen Werten.

Der Link KEYWORDS bringt Sie zu der in Abbildung 10.15 dargestellten Seite. Sie sehen eine Liste mit von Python unterstützten Schlüsselwörtern. Wenn Sie beispielsweise mehr darüber erfahren wollen, wie man for-Schleifen erstellt, klicken Sie auf den Link FOR.

Abbildung 10.15: Die Seite KEYWORDS enthält eine Liste mit Schlüsselwörtern, die von Python unterstützt werden.

Einen Suchbegriff eingeben

Die Seiten enthalten rechts oben auch zwei Textfelder. Neben dem ersten Textfeld befindet sich die Schaltfläche GET und neben dem zweiten die Schaltfläche SEARCH. Wenn Sie in das erste Textfeld einen Suchbegriff eingeben und auf GET klicken, wird Ihnen die Dokumentation zu dem entsprechenden Modul oder Attribut angezeigt. Abbildung 10.16 zeigt, was Sie sehen, wenn Sie print eingeben und auf GET klicken.

Abbildung 10.16: Mit GET bekommen Sie Informationen zu einem bestimmten Suchbegriff.

Wenn Sie in das zweite Textfeld einen Suchbegriff eingeben und auf SEARCH klicken, sehen Sie alle Themen, die mit diesem Suchbegriff etwas zu tun haben könnten. Abbildung 10.17 zeigt die typischen Ergebnisse, wenn Sie print eingeben und auf SEARCH klicken. Sie können dann auf einen Link klicken, zum Beispiel CALENDAR, um weitere Informationen zu bekommen.

Abbildung 10.17: Mit SEARCH wird Ihnen eine Themenliste zu einem bestimmten Suchbegriff angezeigt.

Die Ergebnisse anschauen

Die Ergebnisse auf einer Themenseite hängen sehr vom Thema ab. Manche Themen sind kurz, wie das für print in Abbildung 10.16. Es gibt aber auch sehr ausführlich beschriebene Themen. Wenn Sie beispielsweise auf den Link CALENDAR aus Abbildung 10.17 klicken, würden Sie sehr viele Informationen angezeigt bekommen, wie in Abbildung 10.18 zu sehen.

Abbildung 10.18: Manche Seiten enthalten sehr viele Informationen.

In diesem Beispiel bekommen Sie Informationen über Module, Fehler, Funktionen, Daten und jede Menge anderer Informationen über die Kalenderdruckfunktionen. Die Menge der angezeigten Informationen hängt zum Teil von der Komplexität des Themas und zum Teil von der Menge der Informationen ab, die der Entwickler zum Modul zur Verfügung gestellt hat. Wenn Sie zum Beispiel den Link MEINEBIBLIOTHEK auf der MODULE INDEX-Seite anklicken, würden Sie nur eine Liste mit Funktionen und keine Dokumentation sehen.

11

Mit Zeichenketten arbeiten

In diesem Kapitel

Vergleichen Sie Zeichenketten miteinander

Verwenden Sie Sonderzeichen in Zeichenketten

Arbeiten Sie mit einzelnen Zeichen

Führen Sie String-spezifische Aufgaben aus

Suchen Sie etwas in einer Zeichenkette

Formatieren Sie eine Zeichenkette so, wie Sie sie haben wollen

Ihr Computer versteht keine Zeichenketten. Das ist eine simple Tatsache. Computer verstehen nur Zahlen, keine Buchstaben. Wenn Sie eine Zeichenkette auf dem Bildschirm sehen, sieht der Computer eigentlich eine Reihe von Zahlen. Da Menschen aber nun mal Zeichenketten so gut verstehen, müssen Programme in der Lage sein, damit klarzukommen. Glücklicherweise macht Python Ihnen die Arbeit mit Zeichenketten relativ einfach. Es übersetzt die Zeichenkette, die Sie verstehen, in die Zahlen, die der Computer versteht, und umgekehrt.

Damit Zeichenketten einen Nutzen haben, muss man sie manipulieren können. Das bedeutet zum Beispiel, dass Sie Zeichenketten auseinandernehmen und nur die Teile behalten können, die Sie brauchen, oder in der Zeichenkette nach einer bestimmten Information suchen können. Dieses Kapitel beschreibt, wie Sie mit Python Zeichenketten zusammensetzen, auseinanderschneiden und nur die benötigten Teile verwenden können, nachdem Sie gefunden haben, was Sie brauchen. Die Bearbeitung von Zeichenketten ist ein wichtiger Bestandteil von Programmen, da Menschen darauf angewiesen sind, dass Computer diese Arbeit für sie übernehmen (auch wenn der Computer keine Ahnung hat, was eine Zeichenkette ist).

Nachdem Sie die Zeichenkette haben, die Sie wollen, müssen Sie sie dem Benutzer angemessen präsentieren. Dem Computer ist es egal, wie er die Zeichenkette ausgibt, also bekommen Sie meist die richtigen Informationen, aber ihnen fehlt der richtige Pfiff. Manchmal kann der String sogar schwer zu lesen sein. Zu wissen, wie man Zeichenketten für die Anzeige nett formatiert, ist sehr wichtig, da die Benutzer die Informationen in einer Form präsentiert bekommen müssen, die sie auch verstehen. Nachdem Sie dieses Kapitel beendet haben, wissen Sie, wie man Zeichenketten erstellt, ändert und so formatiert, dass der Benutzer genau die richtigen Informationen sieht.

Zeichenketten sind anders

Für die meisten angehenden Entwickler (und sogar manche, die schon lange programmieren) ist es nicht so leicht zu verstehen, dass Computer wirklich nur 0en und 1en verstehen. Sogar große Zahlen bestehen nur aus 0en und 1en. Vergleiche werden mit 0en und 1en ausgeführt. Daten werden von A nach B durch 0en und 1en geschafft. Kurz: Zeichenketten gibt es für den Computer nicht (und Zahlen auch nur in geringem Maße). 0en und 1en miteinander zu kombinieren, um Zahlen darzustellen, ist noch relativ einfach. Zeichenketten sind sehr viel schwieriger, da der Computer diese Informationen als Zahlen verarbeiten, aber als Buchstaben darstellen muss.

In der Informatik gibt es keine Zeichenketten. Zeichenketten werden aus Zeichen zusammengesetzt und einzelne Buchstaben sind eigentlich numerische Werte. Wenn Sie in Python mit Zeichenketten arbeiten, erstellen Sie also in Wirklichkeit eine Gruppe aus Zeichen, die der Computer als numerische Werte interpretiert. Und darum sind die folgenden Abschnitte so wichtig. Sie sollen Ihnen klarmachen, warum Zeichenketten oder Strings so anders sind. Wenn Sie dieses Thema verstanden haben, erspart Ihnen das später jede Menge Kopfschmerzen.

Ein Zeichen durch Zahlen definieren

Um ein Zeichen zu erzeugen, müssen Sie erst eine Beziehung zwischen diesem Zeichen und einer Zahl herstellen. Außerdem müssen sich alle einig sein, wenn eine bestimmte Zahl in einem Programm auftaucht und von der Anwendung als Zeichen aufgefasst wird, dass diese Zahl in ein Zeichen übersetzt wird. Die gebräuchlichste Methode dafür ist die Verwendung des American Standard Code for Information Interchange (ASCII). Python verwendet den ASCII-Zeichensatz, um zum Beispiel die Zahl 65 in den Buchstaben A zu übersetzen. Die Tabelle unter www.asciitable.com zeigt die verschiedenen Zahlenwerte und deren Zeichenäquivalente.

Jedem Zeichen, das Sie verwenden, muss ein anderer Zahlenwert zugeordnet sein. Der Buchstabe A hat den Wert 65. Um ein kleines a zu erzeugen, müssen Sie eine andere Zahl verwenden, nämlich 97. Der Computer betrachtet A und a als komplett verschiedene Zeichen, im Gegensatz zu uns Menschen, die das als kleine und große Version desselben Buchstabens erkennen.

Die numerischen Werte, die in diesem Kapitel verwendet werden, sind als Integer-Zahlen dargestellt. Trotzdem betrachtet der Computer sie als 0en und 1en. Beispielsweise ist der Buchstabe A eigentlich die Zahl 01000001 und der Buchstabe a eigentlich der Wert 0100001. Wenn Sie also ein A auf dem Bildschirm sehen, sieht der Computer stattdessen einen binären Wert.

Hätte man nur einen einzigen Zeichensatz, mit dem man sich auseinandersetzen müsste, wäre das schön. Leider konnten sich nicht alle auf eine einzige Menge mit Zahlenwerten, die für bestimmte Buchstaben stehen, einigen. Ein Teil des Problems ist, dass ASCII keine Zeichen unterstützt, die in anderen Sprachen verwendet werden. Außerdem kann man mit diesem Zeichensatz keine Sonderzeichen darstellen. Tatsächlich gibt es sehr viele verschiedene Zeichensätze. Sie finden einige der wichtigsten Zeichensätze unter www.columbia.edu/kermit/csettables.html. Klicken Sie auf einen der Zeichensatzeinträge, um sich die spezielle Zuordnung zwischen Zahlen und Zeichen anzuschauen. Die meisten Zeichensätze nehmen ASCII als Ausgangsbasis.

Zeichen zur Erstellung von Zeichenketten verwenden

Python erwartet keine Höchstleistungen von Ihnen, um Zeichenketten zu erstellen. Der Begriff Zeichenkette vermittelt aber schon einen guten Eindruck davon, was da geschieht. Stellen Sie sich Perlen oder etwas anderes vor, das Sie zu einer Kette verbinden wollen. Sie fädeln eine Perle nach der anderen zu einer Kette auf. Vielleicht entsteht dabei am Ende ein schöner Schmuck – für Sie oder den Tannenbaum. Der Punkt ist, dass diese Dinge aus einzelnen Perlen bestehen.

Für Halsketten wie auch für Zeichenketten in Computern gilt dasselbe Prinzip. Sehen Sie eine Zeichenkette, wissen Sie, dass diese aus einzelnen Zeichen durch die verwendete Programmiersprache zusammengesetzt wurde. Die Sprache erzeugt eine Struktur, die die Zeichen zusammenhält. Also weiß die Programmiersprache und nicht der Computer, dass so viele Zahlen nacheinander (jede Zahl repräsentiert ein Zeichen) eine Zeichenkette, zum Beispiel einen Satz, ergeben.

Vielleicht fragen Sie sich, warum man wissen muss, wie Python mit Zeichen umgeht. Viele der Funktionen und speziellen Features, die Python anbietet, arbeiten mit einzelnen Zeichen und man sollte wissen, dass Python diese Zeichen einzeln betrachtet. Auch wenn Sie einen Satz daraus erkennen, fasst Python dies als einzelne Zeichen auf.

Anders als in anderen Sprachen, kann man in Python doppelte oder einfache Anführungsstriche für Strings verwenden. Zum Beispiel ist »Hallo Du!« mit doppelten Anführungsstrichen genauso ein String wie 'Hallo Du!' mit einfachen Anführungsstrichen. Python unterstützt auch dreifache doppelte und einfache Anführungsstriche, mit denen Sie Zeichenketten erzeugen können, die sich über mehrere Zeilen erstrecken. Die folgenden Schritte führen Sie durch ein Beispiel, das ein paar von Python angebotene Funktionen für Zeichenketten demonstriert. Dieses Beispiel finden Sie in der Datei EinfacheZeichenkette.py.

1. Öffnen Sie ein Python-Editierfenster.

Es öffnet sich ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

print(´Hallo Du (Einfache Anführungsstriche)!´)

print("Hallo Du (Doppelte Anführungsstriche)! ")

print("""Dies ist eine Zeichenkette, die über mehrere Zeilen geht und dreifache doppelte Anführungsstriche verwendet. Sie können auch dreifache einfache Anführungsstriche verwenden.""")

Jeder der drei print()-Funktionsaufrufe zeigt eine andere Methode, um mit Strings zu arbeiten. Es ist egal, ob Sie die Zeichenkette in einfache oder doppelte Anführungsstriche setzen. Bei der Verwendung dreifacher Anführungsstriche (entweder einfach oder doppelt) darf der Text über mehrere Zeilen gehen.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Es öffnet sich ein Python-Shell-Fenster. Die Anwendung gibt den Text aus. Beachten Sie, dass der mehrzeilige Text, genauso wie im Quellcode, in drei Zeilen ausgegeben wird (siehe Abbildung 11.1), da dies eine Art der Formatierung ist. Sie können die mehrzeilige Formatierung verwenden, wenn Sie sicherstellen wollen, dass der ausgegebene Text genau da umbricht, wo Sie das möchten.

Abbildung 11.1: Zeichenketten bestehen aus einzelnen Zeichen, die miteinander verknüpft sind.

Zeichenketten mit Sonderzeichen erstellen

Manche Zeichenketten enthalten Sonderzeichen. Diese Zeichen unterscheiden sich von den alphanumerischen Zeichen und Punktionszeichen, die Sie normalerweise verwenden. Sonderzeichen kann man in folgende Kategorien einteilen:

Steuerzeichen: Ein Programm braucht eine Methode, um festzustellen, dass ein bestimmtes Zeichen eigentlich nicht angezeigt werden, sondern der Anzeigesteuerung dienen soll. Alle Steuerzeichen haben Einfluss auf die Einfügemarke, also der Linie, die Sie sehen, wenn Sie am Bildschirm Text eingeben. Zum Beispiel sehen Sie Tabulatoren normalerweise nicht. Der Tabulator erzeugt einen Abstand zwischen zwei Elementen und die Größe des Abstands wird durch einen Tabulator-Stopp festgelegt. So ähnlich ist es auch, wenn Sie eine neue Zeile beginnen wollen. Sie können eine Kombination aus einem Zeilenumbruch verwenden (der die Einfügemarke an den Anfang der Zeile setzt) und einem Zeilenvorschub (der die Einfügemarke in die nächste Zeile bringt).

Akzentuiert: Zeichen mit Akzenten, wie das Akut (´), Gravis ('), Zirkumflex (^), Umlautzeichen oder Diärese (¨), Tilde (~) oder Ring (°), repräsentieren in den meisten Fällen speziell ausgesprochene Laute. Sie müssen Sonderzeichen verwenden, um alphabetische Zeichen mit diesen Akzenten zu schreiben.

Grafische Symbole: Sie können mit manchen Zeichen ganz simple Zeichnungen erstellen. Sie können sich unter http://jrgraphix.net/r/Unicode/2500-257F ein paar blockgrafische Zeichen anschauen. Manche Leute verwenden den ASCII-Zeichensatz auch, um tatsächliche Kunst zu erschaffen, siehe www.asciiworld.com.

Typografisch: Eine paar typografische Zeichen, wie zum Beispiel das Absatzzeichen (¶), werden bei bestimmten Textarten verwendet, speziell in Editorprogrammen.

Weitere: Abhängig vom Zeichensatz ist die Auswahl an Zeichen schier endlos. Für jeden Zweck finden Sie ein Zeichen. Sie müssen Python nun aber irgendwie mitteilen, wie es diese Sonderzeichen anzeigen soll.

Ganz oft braucht man bei der Arbeit mit Zeichenketten, sogar bei ganz einfachen Zeichenketten in Konsolenanwendungen, auch Steuerzeichen. Python stellt Ihnen dazu Escape-Sequenzen zur Verfügung, mit denen Sie Steuerzeichen direkt definieren können.

Eine Escape-Sequenz verleiht einem normalen Zeichen, zum Beispiel a, eine neue Bedeutung (wie \a, das in der Konsole das ASCII-Piepen auslöst). Die Kombination aus Backslash und Buchstabe (wie das a) wird üblicherweise von Entwicklern als einzelner Buchstabe betrachtet – als Escape-Zeichen oder Escape-Code. Tabelle 11.1 enthält eine Übersicht dieser Escape-Sequenzen.

Escape-Sequenz | Bedeutung
\newline | Wird ignoriert.
\\ | Backslash (\)
\' | Einfacher Anführungsstrich(')
\« | Doppelter Anführungsstrich (»)
\a | ASCII-Piepen (Bell, BEL)
\b | ASCII Rückwärtsschritt (Backspace, BS)
\f | ASCII Formfeed (FF)
\n | ASCII Zeilenvorschub (Linefeed, LF)
\r | ASCII Zeilenumbruch (Carriage Return, CR)
\t | ASCII horizontaler Tabulator (TAB)

\uhhhh

Unicodezeichen (ein spezieller Zeichensatz mit großer weltweiter Akzeptanz) mit einem hexadezimalem Wert, der hhhh ersetzt.

\v | ASCII Vertikaler Tabulator (VT)
\ooo | ASCII-Zeichen mit oktalem numerischem Wert, der ooo ersetzt.
\xhh | ASCII-Zeichen mit hexadezimalem Wert, der hh ersetzt.

Tabelle 11.1: Escape-Sequenzen in Python

Am besten kann man Escape-Sequenzen verstehen, wenn man sie mal ausprobiert. Mit den folgenden Schritten erstellen Sie ein Beispiel, das verschiedene Escape-Sequenzen testet, sodass Sie diese in Aktion sehen können. Sie finden dieses Beispiel in der Datei Sonder zeichen.py.

1. Öffnen Sie ein Python-Editierfenster.

Es öffnet sich ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken am Ende jeder Zeile [Enter]:

print("Ein Teil dieses Textes \r\nsteht in der nächsten Zeile.")

print("Dies ist ein A mit Grave-Akzent: \xC0.")

print("Dies ist ein typografisches Zeichen: \u2562.")

print("Dies ist ein Absatzzeichen: \266.")

print("Dies ist ein Divisionszeichen: \xF7.")

Der Beispielcode verwendet verschiedene Techniken, um dasselbe zu erreichen – ein Sonderzeichen zu erzeugen. Sie können so Steuerzeichen direkt eingeben, wie in der ersten Zeile des Codes. Viele spezielle Buchstaben kann man mit einer zweistelligen hexadezimalen Zahl darstellen (wie in der zweiten und fünften Zeile). Bei manchen muss man jedoch auf Unicode-Zahlen zurückgreifen (das sind immer vier Zahlen), wie in der dritten Zeile. Oktale Werte bestehen aus drei Zahlen und verwenden keine speziellen Zeichen, wie man in der vierten Zeile sieht.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Eine Python-Shell öffnet sich. Die Anwendung gibt den erwarteten Text und die Sonderzeichen aus, wie man in Abbildung 11.2 sieht.

Abbildung 11.2: Sonderzeichen können Sie bei Bedarf verwenden, wenn Sie spezielle Informationen darstellen oder die Ausgabe formatieren wollen.

Die Python-Shell verwendet plattformübergreifend einen Standardzeichensatz. Daher sollte Python überall dieselben Sonderzeichen verwenden, egal, auf welchem System Sie das Beispiel ausprobieren. Trotzdem sollten Sie beim Schreiben einer Anwendung diese auf verschiedenen Systemen testen, um zu sehen, was das Programm macht. Ein Zeichensatz auf dem einen System könnte andere Zahlen für Sonderzeichen verwenden als auf einem zweiten System. Außerdem kann die Auswahl eines Zeichensatzes durch den Benutzer Einfluss darauf haben, wie Sonderzeichen von Ihrer Anwendung dargestellt werden. Testen Sie also sorgfältig, wenn Sie Sonderzeichen in Ihrem Programm verwenden.

Zeichen auswählen

Etwas weiter vorne in diesem Kapitel haben Sie schon festgestellt, dass Zeichenketten aus einzelnen Zeichen aufgebaut sind. Sie sind wie Perlen einer Halskette – jede Perle ist ein eigenständiges Element der gesamten Kette. Python ermöglicht Ihnen den Zugriff auf jedes einzelne Zeichen in einem String. Das ist eine wichtige Funktion, da Sie sie beispielsweise zum Erstellen neuer Zeichenketten verwenden können, die nur einen Teil des ursprünglichen Strings enthalten. Außerdem können Sie Zeichenketten miteinander kombinieren, um neue Strings zu erzeugen. Das Geheimnis dieser Funktion sind eckige Klammern. Sie schreiben einfach eckige Klammern mit einer Zahl darin hinter einen Variablennamen. Hier ein Beispiel:

MeineZeichenkette = "Hallo Welt"

print(MeineZeichenkette[0])

In diesem Beispiel besteht die Ausgabe nur aus dem Buchstaben H. Zeichenketten in Python sind nullbasiert, das bedeutet, dass die Zeichen bei 0 beginnend durchnummeriert sind. Würden Sie nun print(MeineZeichenkette[1]) eingeben, würde Python a ausgeben.

Sie können auch einen ganzen Bereich des Strings auswählen. Geben Sie dazu in den eckigen Klammern einfach die Nummern der Start- und Endzeichen getrennt durch einen Doppelpunkt an. Zum Beispiel würde print(MeineZeichenkette[6:11]) Welt ausgeben. Die Ausgabe würde mit dem siebten Buchstaben beginnen und mit dem zwölften Buchstaben enden (denken Sie daran, dass der Index bei null beginnt). Die folgenden Schritte zeigen ein paar einfache Aufgaben, die Sie mit der Zeichenauswahl unter Python erledigen können. Dieses Beispiel finden Sie in der Datei Zeichen.py.

1. Öffnen Sie ein Python-Editierfenster. Es öffnet sich ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

String1 = "Hallo Welt"

String2 = "Python macht Spaß!"

print(String1[0])

print(String1[0:5])

print(String1[:5])

print(String1[6:])

String3 = String1[:6] + String2[:6]

print(String3)

print(String2[:7]*5)

Das Beispiel beginnt mit der Definition zweier Strings. Danach werden verschiedene Methoden zur Verwendung des Index am ersten String gezeigt. Beachten Sie, dass Sie den Anfangs- oder Endwert eines Bereichs auch auslassen können, wenn Sie alle Zeichen vom Anfang beziehungsweise alle Zeichen bis zum Ende verwenden wollen.

Der nächste Schritt kombiniert zwei Teilzeichenketten miteinander. Im Beispiel werden der Anfang von String1 und der Anfang von String2 miteinander verknüpft, um String3 zu erzeugen.

Die Verwendung des +-Zeichens zur Verknüpfung zweier Zeichenketten wird Konkatenation oder Verkettung genannt. Es ist ein sehr praktischer Operator, den Sie sich unbedingt für die Arbeit mit Zeichenketten merken sollten.

Der letzte Schritt verwendet eine Python-Funktion, die sich Wiederholung nennt. Sie verwenden die Wiederholung, um Kopien von einem String oder Teilstring zu machen.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Ein Python-Shell-Fenster öffnet sich. Die Anwendung gibt eine Reihe von Teilstrings und Kombinationen aus Zeichenketten aus, wie in Abbildung 11.3 zu sehen.

Abbildung 11.3: Sie können einzelne Teile einer Zeichenkette auswählen.

Aus Zeichenketten Kleinholz machen

Die Arbeit mit Zeichenbereichen bietet eine gewisse Flexibilität, aber gibt Ihnen nicht die Möglichkeit, die Zeichenkette zu verändern oder irgendetwas darüber zu erfahren. Vielleicht möchten Sie alle Zeichen in Großbuchstaben umwandeln oder bestimmen, ob die Zeichenkette alle Buchstaben enthält. Zum Glück hat Python Funktionen, die Ihnen Aufgaben dieser Art erleichtern.

Im Folgenden finden Sie die gebräuchlichsten Funktionen:

capitalize(): Schreibt den ersten Buchstaben einer Zeichenkette groß.

center(width, fillchar=" "): Zentriert eine Zeichenkette, sodass sie in die Anzahl der Positionen passt, die in width angegeben ist. Wenn Sie für fillchar ein Zeichen angeben, verwendet die Funktion dieses Zeichen zum Auffüllen.

expandtabs(tabsize=8): Erweitert Tabulatoren in einer Zeichenkette mit dem Abstand, der in tabsize angegeben ist. Die Funktion verwendet den Standardwert 8, wenn tabsize nicht übergeben wurde.

isalnum(): Gibt True zurück, wenn der String mindestens ein Zeichen enthält und alle Zeichen alphanumerisch sind (Zahlen oder Buchstaben).

isalpha(): Gibt True zurück, wenn der String mindestens ein Zeichen enthält und alle Zeichen Buchstaben sind.

isdecimal(): Gibt True zurück, wenn ein Unicode-String nur Dezimalzahlen enthält.

isdigit(): Gibt True zurück, wenn der String nur Ziffern enthält (Zahlen und keine Buchstaben).

islower(): Gibt True zurück, wenn der String mindestens einen Buchstaben enthält und alle Buchstaben kleingeschrieben werden.

isnumeric(): Gibt True zurück, wenn ein Unicode-String nur Zahlenwerte enthält.

isspace():Gibt True zurück, wenn ein String nur Leerzeichen, Tabulatoren, Zeilenvorschübe, Zeilenumbrüche, Form feeds und vertikale Tabs enthält, aber keine Backspaces.

istitle():Gibt True zurück, wenn ein String wie ein Titel formatiert ist, zum Beispiel Hallo Welt. Die Funktion verlangt aber, dass alle Wörter am Anfang großgeschrieben werden, also auch zum Beispiel Verben und Adjektive. Hallo große Welt würde False zurückliefern, während Hallo Große Welt True zurückgäbe.

isupper(): Gibt True zurück, wenn der String mindestens einen Buchstaben enthält und alle Buchstaben großgeschrieben werden.

join(seq): Erzeugt eine Zeichenkette, in der die Wörter in der zugrunde gelegten Zeichenkette durch die Zeichen in seq wiederholt getrennt werden. Wenn Sie beispielsweise den String MeineZeichenkette = "Hallo" haben und print(MeineZeichen kette.join("!*!")) eingeben, wird !Hallo*Hallo! ausgegeben.

len(string): Gibt die Länge der Zeichenkette zurück.

ljust(width,fillchar=" "): Richtet eine Zeichenkette nach links aus, sodass sie in die Anzahl Positionen passt, die mit width angegeben wurde. Geben Sie für fillchar ein Zeichen an, verwendet die Funktion dieses Zeichen zum Auffüllen. Andernfalls verwendet ljust Leerzeichen als Füllzeichen.

lower(): Konvertiert alle großgeschriebenen Buchstaben in einer Zeichenkette in Kleinbuchstaben.

lstrip(): Entfernt alle Leerzeichen am Anfang eines Strings.

max(str): Entfernt das Zeichen aus dem String, das den größten Zahlenwert hat. Zum Beispiel würde ein a (Wert 97) eher entfernt als ein A (Wert 65), da es einen größeren Zahlenwert hat.

min(str): Gibt das Zeichen zurück, das den kleinsten Zahlenwert im String hat. Zum Beispiel würde dann ein A eher zurückgegeben werden als ein a, da es einen kleineren Zahlenwert hat.

rjust(width, fillchar=" "): Richtet eine Zeichenkette nach rechts aus, sodass sie in die Anzahl Positionen passt, die mit width angegeben wurde. Geben Sie für fillchar ein Zeichen an, verwendet die Funktion dieses Zeichen zum Auffüllen. Andernfalls verwendet rjust Leerzeichen als Füllzeichen.

rstrip(): Entfernt alle Leerzeichen am Ende eines Strings.

split(str=" ",num=string.count(str)): Spaltet eine Zeichenkette mithilfe des Trennzeichens str (wenn angegeben) in Teilstrings auf. Als Standardtrennzeichen wird das Leerzeichen verwendet. Enthält Ihr String also die Phrase Ein schöner Tag, würden drei Teilstrings ausgegeben, nämlich Ein, schöner und Tag. Die Variable num wird verwendet, um die Anzahl der zurückgegebenen Teilstrings zu bestimmen. Standardmäßig werden alle Teilstrings, die die Funktion produziert, zurückgegeben.

splitlines(num=string.count(´\n´)): Spaltet einen String, der Zeilenvorschübe (\n) enthält, in einzelne Strings auf. An jedem Zeilenvorschub beginnt ein neuer String. In der Ausgabe kommen die Zeilenvorschübe nicht mehr vor. Mit num können Sie die Anzahl der zurückgegebenen Strings bestimmen.

strip(): Entfernt alle Leerzeichen am Anfang und Ende der Zeichenkette.

swapcase(): Invertiert die Groß- und Kleinschreibung für jeden Buchstaben im String.

title(): Gibt einen String zurück, in dem jeder Anfangsbuchstabe eines Wortes großgeschrieben wird und alle anderen Buchstaben kleingeschrieben werden.

upper(): Wandelt alle Kleinbuchstaben des Strings in Großbuchstaben um.

zfill(width): Gibt einen String zurück, der an der linken Seite mit 0en aufgefüllt wurde, um auf die in width angegebene Länge zu kommen. Diese Funktion wurde für Zeichenketten, die Zahlen enthalten, konzipiert. Das Vorzeichen (falls angegeben) bleibt erhalten.

Das Herumspielen mit diesen Funktionen hilft dabei, sie besser zu verstehen. Die folgenden Schritte zeigen anhand eines Beispiels, welche Dinge Sie mit diesen Funktionen erledigen können. Dieses Beispiel finden Sie in der Datei Funktionen.py.

1. Öffnen Sie ein Python-Editierfenster.

Es öffnet sich ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

MeineZeichenkette = "    Hallo Welt    "

print(MeineZeichenkette.upper())

print(MeineZeichenkette.strip())

print(MeineZeichenkette.center(22, "*"))

print(MeineZeichenkette.strip().center(22,"*"))

print(MeineZeichenkette.isdigit())

print(MeineZeichenkette.istitle())

print(max(MeineZeichenkette))

print(MeineZeichenkette.split())

print(MeineZeichenkette.split()[0])

Zunächst wird im Code eine Variable MeineZeichenkette erzeugt, die vor und nach dem Text Leerzeichen enthält, damit Sie die Funktionen testen können, die mit Leerzeichen arbeiten. Am Anfang werden alle Buchstaben in Großbuchstaben umgewandelt. Eine ganz häufige Aufgabe in der Anwendungsentwicklung ist es, Leerzeichen in einem String zu entfernen. Mit der Funktion strip() können Sie diese Aufgabe hervorragend erledigen. Mit der Funktion center() können Sie sowohl am Anfang als auch am Ende des Strings Füllzeichen einfügen, sodass die Zeichenkette eine bestimmte Größe annimmt. Wenn Sie die Funktionen strip() und center() miteinander kombinieren, bekommen Sie eine andere Ausgabe, als wenn Sie nur die Funktion center() verwenden würden.

Sie können Funktionen miteinander kombinieren, um ein bestimmtes Ergebnis zu bekommen. Python führt die Funktionen eine nach der anderen von links nach rechts aus. Die Reihenfolge der Funktionen beeinflusst die Ausgabe und Entwickler vertun sich dabei häufig. Sollte die Ausgabe anders aussehen, als Sie das beabsichtigt haben, versuchen Sie, sie anders anzuordnen.

Bei manchen Funktionen muss der String als Parameter übergeben werden und nicht über die Zeichenkette als Instanz ausgeführt werden. Die Funktion max() fällt zum Beispiel in diese Kategorie. Hätten Sie MeineZeichenkette.max() eingegeben, hätte Python einen Fehler ausgegeben. Die Aufzählung etwas weiter vorne in diesem Kapitel zeigt, welche Funktionen Strings als Eingabe erwarten. Bei Funktionen, die eine Liste als Ausgabe haben, können Sie auf die einzelnen Elemente der Liste mit einem Index zugreifen. Das Beispiel zeigt, wie man die Funktion split() zum Aufspalten der Zeichenkette in Teilstrings verwendet. Anschließend wird gezeigt, wie man nur auf den ersten Teilstring der Ergebnisliste zugreift. In Kapitel 12 erfahren Sie mehr darüber, wie man mit Listen arbeitet.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Es öffnet sich eine Python-Shell. Die Anwendung gibt einige modifizierte Zeichenketten aus, wie in Abbildung 11.4 zu sehen.

Abbildung 11.4: Die Manipulation von Strings wird durch Funktionen sehr viel flexibler.

Einen Wert in einer Zeichenkette finden

Manchmal wollen Sie bestimmte Informationen in einem String finden. Zum Beispiel könnten Sie herausfinden wollen, ob eine Zeichenkette das Wort »Hallo« enthält. Einer der Hauptgründe, warum Daten erstellt und verwaltet werden, besteht darin, später nach bestimmten Informationen suchen zu können. Zeichenketten bilden dabei keine Ausnahme – sie sind besonders nützlich, wenn Sie schnell und ohne Probleme darin das Gesuchte finden. Python bietet einige Funktionen zum Durchsuchen von Strings. Im Folgenden finden Sie die am häufigsten verwendeten Funktionen:

count(str,beg=0,end=len(string)): Zählt, wie häufig str in einer Zeichenkette vorkommt. Sie können die Suche einschränken, indem Sie einen Startindex in beg oder einen Endindex in end angeben.

endswith(suffix, beg=0,end=len(string)): Gibt True zurück, wenn ein String mit den in suffix angegebenen Zeichen endet. Sie können die Überprüfung durch einen Startindex in beg oder einen Endindex in end einschränken.

find(str, beg=0,end=len(string)): Bestimmt, ob str in einem String vorkommt und gibt den Index der Position aus. Sie können die Suche einschränken, indem Sie einen Startindex in beg oder einen Endindex in end angeben.

index(str,beg=0,end=len(string)): Bewirkt dasselbe wie find(), löst aber eine Ausnahme aus, falls str nicht gefunden wird.

replace(old, new, [, max]): Ersetzt alle Vorkommen der Zeichenfolge old im String durch die Zeichenfolge in new. Sie können die Anzahl der Ersetzungen mit dem Wert max begrenzen.

rfind(str,beg=0,end=len(string)): Bietet dieselbe Funktionalität wie find(), aber sucht rückwärts beginnend am Ende des Strings anstatt am Anfang.

rindex(str,beg=0,end=len(string)): Bietet dieselbe Funktionalität wie index(), aber sucht rückwärts beginnend am Ende des Strings anstatt am Anfang.

startswith(prefix,beg=0,end=len(string)): Gibt True zurück, wenn ein String mit den Zeichen in prefix beginnt. Sie können die Überprüfung mit einem Startindex beg oder einen Endindex end einschränken.

Benötigte Daten zu finden, ist eine grundlegende Aufgabenstellung in der Programmierung – eine, die fast immer gebraucht wird, egal was für eine Anwendung Sie erstellen. Die folgenden Schritte zeigen anhand eines Beispiels, wie Sie mit den Funktionen innerhalb einer Zeichenkette suchen. Dieses Beispiel finden Sie in der Datei SucheInZeichenkette.py.

1. Öffnen Sie ein Python-Editierfenster.

Es öffnet sich ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

Suchen = "Der Apfel ist rot und die Beere ist blau!"

print(Suchen.find("ist"))

print(Suchen.rfind("ist"))

print(Suchen.count("ist"))

print(Suchen.startswith("Der"))

print(Suchen.endswith("Der"))

print(Suchen.replace("Apfel", "Lastwagen").

replace.("Beere","Limousine"))

Am Anfang des Beispiels wird eine Variable Suchen definiert – eine Zeichenkette, die zweimal das Wort »ist« enthält. Diese zwei Instanzen des Wortes sind wichtig, da daran gezeigt wird, wie unterschiedlich die Suche ist, je nachdem, wo damit begonnen wird. Verwendet man find(), beginnt die Suche am Anfang des Strings. Im Gegensatz dazu beginnt rfind die Suche am Ende des Strings.

Natürlich werden Sie nicht immer wissen, wie oft ein bestimmtes Zeichen in einem String vorkommt. Die Funktion count() hilft Ihnen, den Wert dieses Vorkommens zu bestimmen.

Abhängig von den Daten, mit denen Sie arbeiten, sind diese ausgiebig formatiert und Sie können dann ein bestimmtes Vorgehen zu Ihrem Vorteil einsetzen. Zum Beispiel könnten Sie bestimmen, ob ein String (oder Teilstring) mit einer bestimmten Zeichenfolge endet oder beginnt. Sie könnten diese Funktion zum Beispiel ganz einfach einsetzen, um nach einer Kapitelnummer zu suchen.

Der letzte Teil des Codes ersetzt die Wörter Apfel durch Auto und Beere durch Limousine. Beachten Sie, wie der Code auf zwei Zeilen verteilt wird. Diese Technik wird eingesetzt, damit Ihr Code lesbarer wird.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Ein Python-Shell-Fenster öffnet sich. Die Anwendung zeigt die Ausgabe aus Abbildung 11.5. Beachten Sie insbesondere, dass die jeweilige Suche verschiedene Indexe zurückgibt, abhängig davon, wo sie bei der Zeichenkette begonnen hat. Es ist wichtig, dass Sie die richtige Funktion verwenden, damit Sie das gewünschte Ergebnis erhalten.

Abbildung 11.5: Python bietet Funktionen an, die das Suchen und Ersetzen von Teilstrings sehr komfortabel machen.

Zeichenketten formatieren

Mit Python können Sie Zeichenketten auf ganz unterschiedliche Arten formatieren. Das Hauptaugenmerk bei der Formatierung liegt darauf, den String so zu formatieren, dass er zum einen für den Benutzer schön aussieht und zum anderen einfach zu verstehen ist. Mit Formatierung ist hier nicht gemeint, dass die Schriftart geändert wird oder irgendwelche anderen Effekte zum Einsatz kommen, sondern hier ist nur die Darstellung der Daten gemeint. Zum Beispiel möchte der Benutzer vielleicht lieber eine Fließkommazahl als eine Dezimalzahl als Ausgabe haben.

Es gibt viele verschiedene Möglichkeiten, eine Zeichenkette zu formatieren, und in diesem Buch werden Ihnen noch einige begegnen. Am häufigsten wird jedoch die Funktion format() verwendet. Sie definieren eine Formatspezifikation als Teil des Strings und verwenden dann die Funktion format(), um Daten zum String hinzuzufügen. Eine Formatspezifikation kann einfach aus zwei geschweiften Klammern {} bestehen, die Platzhalter für Daten definieren. Sie können die Platzhalter durchnummerieren, um spezielle Effekte zu erzielen. Zum Beispiel würde {0} das erste Datenelement in einem String enthalten. Wenn die Datenelemente nummeriert sind, können Sie diese sogar wiederholt einsetzen, sodass die gleichen Daten mehrmals im String vorkommen können.

Der Formatspezifikation folgt ein Doppelpunkt. Wollen Sie einfach nur eine Formatspezifikation angeben, enthalten die geschweiften Klammern nur den Doppelpunkt und die Formatierung, die Sie verwenden wollen. Zum Beispiel würde {:f} eine Fließkommazahl als Ausgabe erzeugen. Wenn Sie die Einträge nummerieren wollen, erzeugt die Zahl vor dem Doppelpunkt {0:f} eine Fließkommazahl als Ausgabe für das erste Datenelement. Die Formatspezifikation folgt diesem Schema, wobei die kursiven Elemente als Platzhalter dienen:

[[fill] align][sign][#][0][width][,][.precision][type]

Die Spezifikation unter https://docs.python.org/3/library/string.html versorgt Sie mit allen Details, aber im Folgenden finden Sie einen Überblick, was die einzelnen Elemente bedeuten:

fill: Definiert das Füllzeichen, das verwendet wird, wenn die angezeigten Daten zu kurz sind, um den zugewiesenen Platz auszufüllen.

align: Spezifiziert die Ausrichtung der Daten innerhalb des Anzeigebereichs. Sie können die folgenden Ausrichtungen benutzen:

• <: Linksbündig

• >: Rechtsbündig

• ^: Zentriert

• =: Blocksatz
sign: Bestimmt die Verwendung von Vorzeichen in der Ausgabe:

• +: Positive Zahlen haben ein Pluszeichen und negative Zahlen ein Minuszeichen.

• -: Negative Zahlen haben ein Minuszeichen.

• <space>: Positiven Zahlen wird ein Leerzeichen vorangestellt und negative Zahlen haben ein Minuszeichen.

#: Gibt an, dass die Ausgabe ein anderes Anzeigeformat für Zahlen verwenden soll. Zum Beispiel wird hexadezimalen Zahlen 0x vorangestellt.

0: Gibt an, dass die Ausgabe Vorzeichen verwenden soll und mit 0en aufgefüllt wird, um ein konsistentes Ausgabeformat zu erhalten.

width: Bestimmt die volle Breite des Datenfelds (auch wenn die Daten nicht in den angegebenen Bereich passen).

,: Gibt an, dass Zahlen Kommas als Tausendertrennzeichen verwenden sollen.

.precision: Bestimmt die Anzahl der Zeichen nach dem Dezimalpunkt.

type: Definiert den Ausgabetyp, auch wenn der Eingabetyp nicht passt. Die Typen teilen sich in drei Kategorien:

• String: Verwende ein s oder nichts, um einen String anzugeben.

• Integer: Die Integer-Typen sind wie folgt: b (binär), c (Zeichen), d (dezimal), o (oktal), x (hexadezimal mit Kleinbuchstaben), X (hexadezimal mit Großbuchstaben) und n (lokalisierte Dezimalzahl, die die entsprechenden Zeichen für das Tausendertrennzeichen verwendet).

• Fließkommazahl: Es gibt folgende Fließkommazahltypen: e (Exponent mit kleingeschriebenem e als Trennzeichen); E (Exponent mit großgeschriebenem E als Trennzeichen); f (mit kleingeschriebenem f für Nachkommastellen); F (großgeschrieben, Funktionalität mit f identisch); g (allgemeines kleingeschriebenes Format); G (allgemeines großgeschriebenes Format); n (lokalisiertes allgemeines Format, das die entsprechenden Zeichen für das Tausendertrennzeichen verwendet); und % (Prozent).

Die Elemente der Formatspezifikation müssen in der korrekten Reihenfolge erscheinen, ansonsten weiß Python nichts damit anzufangen. Wenn Sie beispielsweise die Ausrichtung vor dem Füllzeichen angeben, gibt Python eine Fehlermeldung aus, statt die Formatierung auszuführen. Die folgenden Schritte zeigen Ihnen, wie die Formatspezifikation funktioniert und demonstriert die Reihenfolge, in der Sie die verschiedenen Formatierungskriterien angeben müssen. Dieses Beispiel finden Sie in der Datei Formatierung.py.

1. Öffnen Sie ein Python-Editierfenster.

Es öffnet sich ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

Formatiert = "{:d}"

print(Formatiert.format(7000))

Formatiert = "{:,d}"

print(Formatiert.format(7000))

Formatiert = "{:^15,d}"

print(Formatiert.format(7000))

Formatiert = "{:*^15,d}"

print(Formatiert.format(7000))

Formatiert = "{:*^15.2f}"

print(Formatiert.format(7000))

Formatiert = "{:*>15X}"

print(Formatiert.format(7000))

Formatiert = "{:*<#15x}"

print(Formatiert.format(7000))

Formatiert = "Ein {0} {1} und ein {0} {2}."

print(Formatiert.format("blaues","Auto","Boot"))

Das Beispiel beginnt mit einer Variablen, die als Dezimalzahl formatiert wird. Es wird dann das Tausendertrennzeichen zur Ausgabe hinzugefügt. Im nächsten Schritt wird der String länger gemacht als benötigt und anschließend zentriert. Schließlich wird ein Sternchen als Füllzeichen für die Ausgabe verwendet.

Natürlich verwendet dieses Beispiel auch noch andere Datentypen. Im nächsten Schritt werden dieselben Daten als Fließkommazahl dargestellt. Das Beispiel stellt die Daten als Hexadezimalzahl sowohl mit Groß- als auch mit Kleinbuchstaben dar. Die Version mit Großbuchstaben ist rechtsbündig, die Version mit Kleinbuchstaben linksbündig ausgerichtet.

Schließlich zeigt das Beispiel, wie Sie nummerierte Felder praktisch einsetzen können. Im Beispiel wird ein netter String erzeugt, indem einer der Eingabewerte wiederholt verwendet wird.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Es öffnet sich ein Python-Shell-Fenster. Die Anwendung gibt die Daten in den verschiedenen Formaten aus, wie in Abbildung 11.6 zu sehen.

Abbildung 11.6: Um Daten genau so darzustellen, wie Sie das wollen, können Sie Formatierungsfunktionen verwenden.

12

Listen verwalten

In diesem Kapitel

Erfahren Sie, warum Listen so wichtig sind

Erstellen Sie Listen

Durchlaufen Sie Listen

Bearbeiten Sie Listenelemente sequenziell

Ändern Sie Listeninhalte

Finden Sie bestimmte Informationen in Listen

Sortieren Sie Listenelemente

Setzen Sie das Counter-Objekt sinnvoll ein

Viele Menschen vergessen schnell, dass die meisten Programmiertechniken aus dem richtigen Leben abgeleitet sind. Das kommt wohl daher, dass Programmierer oft Begriffe verwenden, die andere Leute für Dinge des alltäglichen Lebens nicht verwenden würden. Zum Beispiel würde man einen Aufbewahrungsort als Kiste oder Regal bezeichnen – aber Programmierer bestehen auf den Begriff Variable. Listen bilden dabei eine Ausnahme. Jeder macht sich Listen und verwendet sie auf verschiedene Weisen, um eine Vielzahl von Aufgaben zu erfüllen. Wahrscheinlich sind Sie dort, wo Sie gerade dieses Buch lesen, von Listen unterschiedlichster Arten umgeben. Dieses Kapitel handelt also von etwas, das Sie schon recht häufig einsetzen. Der einzige Unterschied besteht darin, dass Sie Listen nun genauso betrachten müssen, wie Python das tut.

Sie haben vielleicht schon gelesen, dass es schwierig ist, mit Listen zu arbeiten. Manche Leute finden die Arbeit mit Listen nicht so einfach, da sie es nicht gewohnt sind, über die von ihnen erstellten Listen tatsächlich nachzudenken. Wenn Sie eine Liste erstellen, schreiben Sie die Elemente in einer für Sie sinnvollen Reihenfolge auf. Manchmal schreiben Sie die Liste dann noch mal neu, um sie dann anders zu sortieren. Wollen Sie die Liste durchgehen, verwenden Sie vielleicht Ihren Finger als Hilfestellung, um das Auffinden von Elementen einfacher zu gestalten. Alles, was Sie normalerweise mit einer Liste tun würden, können Sie auch in Python tun. Der Unterschied besteht allerdings darin, dass Sie sich genau überlegen müssen, was Sie machen, damit Python auch versteht, was Sie erreichen wollen.

Listen sind in Python unglaublich wichtig. Dieses Kapitel erläutert Ihnen (unter anderem) die Konzepte zum Erstellen, Verwalten, Durchsuchen und Ausgaben von Listen. Nachdem Sie dieses Kapitel beendet haben, können Sie mithilfe von Listen Ihre Python-Programme robuster, schneller und flexibler machen. Sie werden sich noch wundern, wie Sie je ohne Listen in der Vergangenheit ausgekommen sind. Sie müssen sich immer vor Augen halten, dass Sie Listen schon Ihr ganzes Leben lang verwendet haben. Es gibt in Python keinen großen Unterschied, außer dass Sie nun über bestimmte Tätigkeiten, die sonst bei der Verwaltung Ihrer eigenen Listen für Sie selbstverständlich sind, genau nachdenken müssen.

Informationen in einer Anwendung strukturieren

Man erstellt Listen, um Informationen zu strukturieren, einfacher zugänglich zu machen und ändern zu können. In Python verwenden Sie Listen genau aus denselben Gründen. In vielen Situationen können Sie etwas organisatorische Hilfe gut gebrauchen, um Daten aufzubewahren. Zum Beispiel möchten Sie vielleicht einen zentralen Ort haben, an dem Sie die Wochentage oder Monate nachschlagen können. Die Namen dieser Elemente würden in der Liste genauso erscheinen, als wenn Sie sie auf einem Stück Papier im richtigen Leben aufschreiben müssten. Die folgenden Abschnitte beschreiben Listen und ihre Funktionsweisen ausführlich.

Eine Struktur mit Listen erstellen

Die Python-Dokumentation beschreibt Listen als eine Art Sequenz. Sequenzen stellen einfach ein Mittel zur Verfügung, mit dem man mehrere Datenelemente an einem einzigen Speicherort, aber als einzelne Einheiten vorhalten kann. Denken Sie an diese großen Schließfachwände, die es in Banken gibt. Jede Wand besteht aus einigen kleinen Schließfächern, die jeweils Dokumente oder Geld enthalten können. Python unterstützt auch noch weitere Sequenzen (Kapitel 13 erklärt einige dieser Sequenzen).

Tupel

Dictionaries

Stapel

Queues

Deques

Listen sind die am einfachsten zu verstehenden Sequenzen und sind am engsten an Objekte des richtigen Lebens angelehnt. Die Arbeit mit Listen erleichtert Ihnen den Umgang mit anderen Sequenztypen, die noch größere Flexibilität und einen größeren Funktionsumfang bieten. Die Daten werden so gespeichert, als wenn Sie sie auf ein Stück Papier schreiben würden – ein Element nach dem anderen, wie Abbildung 12.1 zeigt. Die Liste hat einen Anfang, ein Mittelstück und ein Ende. Genauso wie in der Abbildung sind die Elemente auch nummeriert. (Auch wenn Sie sie im richtigen Leben nicht nummerieren würden, macht Python das für Sie.)

Wie Computer Listen sehen

Computer betrachten Listen nicht so wie Sie. Sie haben keinen kleinen Notizblock und einen Stift, um sich etwas zu merken. Ein Computer hat einen Speicher. Der Computer speichert jedes Listenelement an einem separaten Speicherort, wie in Abbildung 12.2 zu sehen. Der Speicher ist fortlaufend, sodass neue Listenelemente an die nächste freie Stelle im Speicher geschrieben werden.

Abbildung 12.1: Eine Liste ist einfach eine Sequenz mit Elementen, wie Sie sie auch auf einem Zettel notieren würden.

Abbildung 12.2: Jedes Element, das zu einer Liste hinzugefügt wird, bekommt den nächsten freien Platz im Hauptspeicher.

In vielerlei Hinsicht verwendet der Computer so etwas wie ein Schließfach, um Ihre Liste zu speichern. Die Liste als solche ist die Schließfachwand. Jedes Mal, wenn Sie ein Element hinzufügen, platziert der Computer es im nächsten Schließfach der Wand.

Genauso wie die Schließfächer in einer Schließfachwand nummeriert sind, sind auch die Speicherplätze, die für eine Liste verwendet werden, nummeriert. Die Zahlen beginnen mit 0 und nicht mit 1, wie Sie es vielleicht erwarten würden. Jedes Schließfach bekommt die nächste Nummer in der Reihe. Eine Schließfachwand mit den Jahresmonaten würde 12 Schließfächer enthalten. Die Schließfächer wären von 0 bis 11 durchnummeriert (nicht von 1 bis 12, wie man vielleicht denken könnte). Es ist sehr wichtig, dass Sie sich mit diesem Nummerierungsschema schnell vertraut machen, da selbst erfahrene Entwickler noch überlegen müssen, ob sie nun bei 0 oder 1 beginnen müssen.

Je nachdem, welche Art Informationen Sie in dem Schließfach unterbringen wollen, können die Schließfächer unterschiedlich groß sein. Python erlaubt Ihnen, einen String in einem Schließfach, einen Integer in einem anderen Schließfach und eine Fließkommazahl in einem weiteren Schließfach unterzubringen. Der Computer weiß nicht, welche Information in welchem Schließfach gespeichert ist, und es ist ihm auch egal. Das Einzige, was der Computer sieht, ist eine lange Liste mit Zahlen, die so gut wie alles bedeuten können. Python macht alles, damit Datenelemente abhängig von ihrem Typ korrekt verarbeitet werden und dass Sie bei der Anforderung von Element fünf auch tatsächlich Element fünf bekommen.

Allgemein sollte man immer Listen mit gleichen Elementen erstellen, damit die Daten einfacher zu handhaben sind. Wenn Sie eine Liste mit Integer-Werten erstellen statt mit vielen verschiedenen Datentypen, dann können Sie von bestimmten Dingen für diese Liste ausgehen und müssen nicht noch mal so viel Zeit auf das Prüfen des Datentyps verwenden. In manchen Situationen kann es aber sein, dass Sie Daten mischen müssen. Viele andere Programmiersprachen legen fest, dass eine Liste immer nur Elemente eines Datentyps haben muss, aber Python bietet Ihnen hier die Flexibilität, Daten aller Arten in einer Liste zu verwalten. Aber denken Sie daran, dass Sie den Datentyp prüfen müssen, wenn Sie mit verschiedenen Datentypen in einer Liste ordentlich arbeiten wollen. Einen String als Integer zu behandeln, würde in Ihrer Anwendung zu Problemen führen.

Listen erstellen

Wie im richtigen Leben auch, müssen Sie zunächst eine Liste erstellen, bevor Sie sie verwenden können. Wie zuvor schon erwähnt, kann man in Python in Listen unterschiedliche Datentypen verwalten. Es empfiehlt sich jedoch, wenn möglich, immer nur einen Datentyp in einer Liste zu verwenden. Die folgenden Schritte erklären Ihnen, wie Sie eine Liste erstellen können.

1. Öffnen Sie ein Python-Shell-Fenster.

Sie sehen die bekannte Python-Eingabeaufforderung.

2. Geben Sie Liste1=["Eins", 1, "Zwei", True] ein und drücken Sie [Enter].

Python erzeugt eine Liste namens Liste1 für Sie. Diese Liste enthält zwei Zeichenketten (Eins und Zwei), einen Integer-Wert (1) und einen booleschen Wert (True). Sie sehen leider aber nichts, da Python den Befehl ohne jegliche Ausgabe ausführt.

Beachten Sie, dass jeder von Ihnen eingegebene Datentyp in einer anderen Farbe erscheint. Wenn Sie das Standardfarbschema verwenden, zeigt Python Strings in Grün, Zahlen in Schwarz und boolesche Werte in Orange an. Die Farbe jedes Eintrags verrät Ihnen, ob Sie das Element korrekt eingegeben haben, was bei der Fehlervermeidung in Listen sehr hilfreich ist.

3. Geben Sie print(Liste1) ein und drücken Sie [Enter].

Der gesamte Inhalt der Liste wird angezeigt, wie in Abbildung 12.3 gezeigt. Beachten Sie, dass der String-Eintrag in einfachen Anführungsstrichen erscheint, auch wenn Sie diesen in doppelten Anführungsstrichen eingegeben haben. Strings können entweder in einfachen oder in doppelten Anführungsstrichen stehen.

4. Geben Sie dir(Liste1) ein und drücken Sie [Enter].

Python zeigt eine Liste mit Funktionen an, die Sie für Listen einsetzen können, wie in Abbildung 12.4 zu sehen. Beachten Sie, dass die Ausgabe eigentlich eine Liste ist. Sie benutzen also eine Liste, um festzustellen, was Sie mit einer anderen Liste tun können.

Abbildung 12.3: Python gibt den Inhalt von Liste1 aus.

Abbildung 12.4: Python stellt Ihnen eine Auflistung aller Aktionen, die Sie für eine Liste ausführen können, zur Verfügung.

Wenn Sie nun langsam mit etwas komplexeren Objekten arbeiten, denken Sie immer daran, dass Sie sich mit dem Befehl dir() immer anzeigen lassen können, welche Dinge Sie mit dem Objekt anstellen können. Die Funktionen, die ohne Unterstriche angezeigt werden, sind die Hauptfunktionen, die Sie mit einer Liste ausführen können. Diese Funktionen sind:

- append
- clear
- copy
- count
- extend
- index
- insert
- pop
- remove
- reverse
- sort

5. Schließen Sie das Python-Shell-Fenster wieder.

Auf Listen zugreifen

Nachdem Sie eine Liste erstellt haben, wollen Sie natürlich auch auf die darin enthaltenen Informationen zugreifen. Im vorherigen Abschnitt haben Sie gesehen, wie Sie die Funktionen print() und dir() einsetzen können, um mit einer Liste zu arbeiten, aber es gibt auch noch andere Möglichkeiten, um diese Aufgabe zu erfüllen, wie die folgenden Schritte zeigen.

1. Öffnen Sie ein Python-Shell-Fenster.

Sie sehen die vertraute Python-Eingabeaufforderung.

2. Geben Sie Liste1=["Eins", 1, "Zwei", True] ein und drücken Sie [Enter].

Python erzeugt eine Liste namens Liste1 für Sie.

3. Geben Sie Liste1[1] ein und drücken Sie [Enter].

Der Wert 1 wird ausgegeben, wie in Abbildung 12.5 zu sehen. Die Verwendung einer Zahl in eckigen Klammern nennt man Index. Python verwendet nur nullbasierte Indexe, daher bekommen Sie das zweite Element zurückgegeben, wenn Sie das Element mit Index 1 anfordern.

Abbildung 12.5: Sie müssen immer den korrekten Index eingeben.

4. Geben Sie Liste1[1:3] ein und drücken Sie [Enter].

Es wird ein Wertebereich mit zwei Elementen angezeigt, wie in Abbildung 12.6 gezeigt. Gibt man einen Bereich an, ist das Ende des Bereichs immer um eins größer als die Anzahl der zurückgegebenen Elemente. In diesem Fall bedeutet das, dass Sie die Elemente 1 und 2 ausgegeben bekommen und nicht etwa die Elemente 1 bis 3, wie man vermuten könnte.

Abbildung 12.6: Wertebereiche geben mehrere Werte zurück.

5. Geben Sie Liste1[1:] ein und drücken Sie [Enter].

Sie sehen nun alle Elemente, beginnend mit Element 1, bis ans Ende der Liste, wie in Abbildung 12.7 dargestellt. Ein Bereich kann einen leeren Endindex haben, was einfach bedeutet, dass die Liste bis zum Ende ausgegeben werden soll.

Abbildung 12.7: Lässt man den Endindex eines Wertebereichs leer, wird der Listenrest ausgegeben.

6. Geben Sie Liste1[:3] ein und drücken Sie [Enter].

Python zeigt die Elemente von 0 bis 2 aus. Lässt man den Startindex eines Bereichs leer, bedeutet das, dass Sie mit Element 0 beginnen, wie in Abbildung 12.8 zu sehen.

Abbildung 12.8: Lässt man den Startindex leer, werden alle Elemente ab Element 0 ausgegeben.

7. Schließen Sie das Python-Shell-Fenster.

Auch wenn es sehr verwirrend erscheinen mag, kann man in Python auch negative Indexe verwenden. Statt von links vorzugehen, arbeitet sich Python von rechts aus rückwärts durch die Liste. Wenn Sie beispielsweise die Liste Liste1=["Eins",1,"Zwei",True] verwenden und Liste1[-2] eingeben, bekommen Sie als Ausgabe ´Zwei´. Gibt man Liste1[-3] ein, bekommt man 1 als Ausgabe. Das am weitesten rechts stehende Element ist hier Element -1.

Listen durchlaufen

Damit Sie das Verarbeiten von Elementen automatisieren können, müssen Sie diese irgendwie durchlaufen können. Die einfachste Methode, diese Aufgabe zu lösen, ist, die Liste mit einer for-Schleife zu durchlaufen. Dieses Beispiel finden Sie in der Datei ListeDurchlaufen.py.

1. Öffnen Sie ein Python-Editierfenster.

Es wird ein Editor angezeigt, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

Liste1 = [0, 1, 2, 3, 4, 5]

for Element in Liste1:

print(Element)

Am Anfang des Beispiels wird eine Liste mit Zahlen erzeugt. Dann wird eine for-Schleife verwendet, um jedes Element abzufragen und anschließend am Bildschirm anzuzeigen.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Es öffnet sich ein Python-Shell-Fenster. Die Ausgabe zeigt die einzelnen Werte der Liste an, eine in jeder Zeile, wie in Abbildung 12.9 dargestellt.

Abbildung 12.9: Mit einer Schleife können Sie sehr einfach auf eine Kopie jedes Elements zugreifen und sie bearbeiten.

Listen bearbeiten

Sie können den Inhalt einer Liste nach Bedarf ändern. Mit dem Bearbeiten einer Liste ist gemeint, dass Sie einen bestimmten Eintrag ändern, einen neuen Eintrag hinzufügen oder einen existierenden Eintrag entfernen können. Damit Sie diese Aufgaben ausführen können, müssen Sie manchmal zunächst einen Eintrag einlesen. Dieses Konzept des Bearbeitens findet sich in dem Akronym CRUD wieder, das für Create (Erzeugen), Read (Lesen), Update (Aktualisieren) und Delete (Löschen) steht.

Im Folgenden finden Sie die Listenfunktionen, die CRUD umsetzen:

append(): Fügt einen neuen Eintrag am Ende der Liste hinzu.

clear(): Entfernt alle Einträge aus der Liste.

copy(): Erstellt eine Kopie der aktuellen Liste und speichert sie in einer neuen Liste.

extend(): Fügt Elemente aus einer existierenden Liste in die aktuelle Liste ein.

insert(): Fügt einen neuen Eintrag an der angegebenen Position in die Liste ein.

pop(): Entfernt einen Eintrag am Ende der Liste.

remove(): Entfernt ein Element an der angegebenen Position aus der Liste.

Die folgenden Schritte zeigen Ihnen, wie Sie Listen bearbeiten können. Dies ist ein Beispiel zum Selbstausprobieren. Im Laufe des Buches werden Ihnen dieselben Funktionen noch im Anwendungscode begegnen. Der Zweck dieser Übung ist es, Ihnen ein Gefühl dafür zu vermitteln, wie Listen funktionieren.

1. Öffnen Sie ein Python-Shell-Fenster.

Die bekannte Python-Eingabeaufforderung wird angezeigt.

2. Geben Sie Liste1 = [] ein und drücken Sie [Enter].

Python erzeugt eine Liste namens Liste1 für Sie.

Beachten Sie, dass die eckigen Klammern leer sind. Liste1 enthält keine Elemente. Sie können leere Listen erzeugen, die Sie später mit Informationen füllen können. So beginnen tatsächlich viele Listen, da Sie meist nicht wissen, welche Informationen die Liste enthalten soll, bevor der Benutzer mit der Liste arbeitet.

3. Geben Sie len(Liste1) ein und drücken Sie [Enter].

Die Funktion len() gibt 0 aus, wie in Abbildung 12.10 zu sehen. Bei der Programmierung einer Anwendung können Sie prüfen, ob eine Liste leer ist, indem Sie die Funktion len() verwenden. Mit einer leeren Liste können Sie Funktionen wie remove nicht ausführen, da es ja nichts zu entfernen gibt.

Abbildung 12.10: Sie können in Ihrer Anwendung bei Bedarf prüfen, ob eine Liste leer ist.

4. Geben Sie Liste1.append(1) ein und drücken Sie [Enter].

5. Geben Sie len(Liste1) ein und drücken Sie [Enter].

Die Funktion len() gibt nun eine Länge von 1 aus.

6. Geben Sie Liste1[0] ein und drücken Sie [Enter].

Es wird der Wert, der in Element 0 gespeichert ist, angezeigt, wie in Abbildung 12.11 zu sehen.

Abbildung 12.11: Das Anhängen eines Elements speichert den Wert am Ende der Liste und verändert so die Länge der Liste.

7. Geben Sie Liste1.insert(0,2) ein und drücken Sie [Enter].

Die Funktion insert() hat zwei Parameter. Der erste Parameter ist der Index, an dem ein Element eingefügt werden soll, in diesem Fall 0. Der zweite Parameter ist das Objekt, das Sie dort einfügen wollen, im Beispiel also 2.

8. Geben Sie Liste1 ein und drücken Sie [Enter].

Python hat Liste1 ein weiteres Element hinzugefügt. Mit der Funktion insert() können Sie das neue Element vor dem ersten Element einfügen, wie in Abbildung 12.12 gezeigt.

Abbildung 12.12: Mit der Funktion insert() können Sie ein Element an einer beliebigen Stelle einfügen.

9. Geben Sie Liste2 = Liste1.copy() ein und drücken Sie [Enter].

Die neue Liste, Liste2, ist eine exakte Kopie von Liste1. Das Kopieren einer Liste wird oft dann gebraucht, wenn man eine temporäre Version einer existierenden Liste erstellen möchte, damit der Benutzer temporäre Änderungen dort statt an der ursprünglichen Liste machen kann. Ist der Benutzer fertig, kann die Anwendung entweder die temporäre Liste löschen oder die ursprüngliche Liste durch die neue Liste ersetzen.

10. Geben Sie Liste1.extend(Liste2) ein und drücken Sie [Enter].

Python kopiert alle Element aus Liste2 an das Ende von Liste1. Das Erweitern einer Liste wird häufig zur Konsolidierung zweier Listen verwendet.

11. Geben Sie Liste1 ein und drücken Sie [Enter].

Sie können nun feststellen, dass das Kopieren und die Erweiterung der Liste funktioniert haben. Liste1 enthält jetzt die Werte 2, 1, 2 und 1, wie in Abbildung 12.13 zu sehen.

Abbildung 12.13: Mit den Funktionen copy() und extend() können Sie schnell viele Daten kopieren und einfügen.

12. Geben Sie Liste1.pop() ein und drücken Sie [Enter].

Python zeigt den Wert 1 an, wie in Abbildung 12.14 zu sehen. Die 1 war am Ende der Liste gespeichert und pop() entfernt immer die Werte vom Ende der Liste.

13. Geben Sie Liste1.remove(1) ein und drücken Sie [Enter].

Dieses Mal entfernt Python das Element auf Position 1. Im Gegensatz zur Funktion pop() gibt remove() nicht den Wert des entfernten Elements aus.

14. Geben Sie Liste1.clear() ein und drücken Sie [Enter].

Mit der Funktion clear() werden alle Elemente aus der Liste gelöscht und diese sollte nun leer sein.

Abbildung 12.14: Mit pop() können Sie Elemente am Ende der Liste entfernen.

Operatoren mit Listen verwenden

Listen können auch Operatoren benutzen, um bestimmte Aufgaben auszuführen. Wenn Sie beispielsweise eine Liste erstellen wollen, die vier Mal das Wort »Hallo« enthält, könnten Sie MeineListe = ["Hallo"] * 4 verwenden, um diese zu füllen. Mit einer Liste können Sie Wiederholungen beliebig einsetzen. Der Multiplikationsoperator (*) sagt Python, wie oft es ein bestimmtes Element wiederholen soll. Jedes wiederholte Element ist ein separater Eintrag, sodass MeineListe [´Hallo´, ´Hallo´, ´Hallo´, ´Hallo´] enthält.

Sie können auch Konkatenation verwenden, um eine Liste zu füllen. Zum Beispiel erstellt ["Hallo"] + ["Welt"] + ["!"] * 4 sechs Elemente in MeineListe. Das erste Element ist Hallo, gefolgt von Welt und vier Elementen mit einem Ausrufungszeichen (!) darin.

Der Membership-Operator (in) funktioniert auch mit Listen. Dieses Kapitel benutzt eine sehr einfache und leicht zu verstehende Methode, um Listen zu durchsuchen (das ist auch die empfohlene Methode). Sie können aber auch den Membership-Operator verwenden, um die Sache abzukürzen und einfacher zu machen, indem man "Hallo" in MeineListe verwendet. Geht man davon aus, dass Ihre Liste ["Hallo", "Welt", "!", "!", "!", "!"] enthält, ist die Ausgabe dieses Befehls True.

15. Geben Sie len(Liste1) ein und drücken Sie [Enter].

Sie sehen, dass die Ausgabe 0 ist. Liste1 ist wirklich leer. Nun haben Sie alle Methoden zur Bearbeitung einer Liste in Python ausprobiert. Arbeiten Sie ruhig noch mit Abwandlungen dieser Beispiele, bis Sie sich beim Ändern einer Liste sicher fühlen.

16. Schließen Sie das Python-Shell-Fenster.

Listen durchsuchen

Das Bearbeiten einer Liste stellt sich etwas schwierig dar, wenn Sie nicht wissen, was sie enthält. Es ist daher entscheidend für das einfachere Verwalten von Listen, dass Sie eine Liste durchsuchen können. Die folgenden Schritte erstellen ein Programm, an dem die Suche nach bestimmten Werten in einer Liste gezeigt wird. Dieses Beispiel finden Sie in der Datei ListeDurchsuchen.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

Farben = ["Rot", "Orange", "Gelb", "Grün", "Blau"]

Farbauswahl = ""

while str.upper(Farbauswahl) != "ENDE":

Farbauswahl = input("Bitte geben Sie eine Farbe ein: ")

if(Farben.count(Farbauswahl) >= 1):

print("Die Farbe ist in der Liste vorhanden!")

elif(str.upper(Farbauswahl) != "ENDE"):

print("Die Farbe kommt in der Liste nicht vor.")

Am Anfang des Beispiels wird zunächst eine Liste namens Farben erstellt, die Farbnamen enthält. Es wird außerdem eine Variable Farbauswahl erzeugt, um die Farbe, die der Benutzer finden will, zu speichern. Dann beginnt eine Schleife, in der der Benutzer gebeten wird, eine Farbe einzugeben, die in Farbauswahl gespeichert wird. Solange diese Variable nicht das Wort ENDE enthält, bleibt das Programm in der Abfrageschleife.

Immer, wenn der Benutzer eine Farbe eingibt, soll die Liste zählen, wie oft die Farbe vorkommt. Ist die Anzahl größer oder gleich eins, enthält die Liste die Farbe und eine entsprechende Nachricht wird auf dem Bildschirm ausgegeben.

Beachten Sie, dass das Beispiel die elif-Klausel verwendet, um zu prüfen, ob Farbauswahl das Wort ENDE enthält. Die elif-Klausel sorgt dafür, dass die Anwendung keine Meldung ausgibt, wenn der Benutzer das Programm beenden will. Sie sollten ähnliche Methoden bei der Programmierung Ihrer Anwendung benutzen, damit Benutzer nicht irritiert werden oder sogar Daten verloren gehen (wenn die Anwendung eine Aufgabe ausführt, die der Benutzer nicht wollte).

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Eine Python-Shell öffnet sich. Die Anwendung bittet Sie, eine Farbe einzugeben.

4. Geben Sie Blau ein und drücken Sie [Enter].

Es wird eine Nachricht angezeigt, die Ihnen mitteilt, dass die Farbe in der Liste existiert, wie in Abbildung 12.15 zu sehen.

Abbildung 12.15: Existiert eine Farbe in der Liste, wird eine Erfolgsmeldung ausgegeben.

5. Geben Sie Lila ein und drücken Sie [Enter].

Sie sehen eine Meldung, dass die Farbe in der Liste nicht existiert, wie in Abbildung 12.16 gezeigt.

Abbildung 12.16: Gibt man eine Farbe ein, die in der Liste nicht existiert, wird eine Fehlermeldung ausgegeben.

6. Geben Sie Ende ein und drücken Sie [Enter].

Die Anwendung wird beendet. Beachten Sie, dass das Programm weder eine Erfolgs- noch eine Fehlermeldung ausgibt.

Listen sortieren

Ein Computer kann immer Informationen in einer Liste finden, egal wie diese sortiert ist. Trotzdem sind längere Listen einfacher zu durchsuchen, wenn sie eine bestimmte Sortierung haben. Der Hauptgrund, warum man eine Liste sortiert, ist aber, dass Menschen einfacher die Informationen in der Liste erfassen können.

Das nächste Beispiel beginnt mit einer unsortierten Liste. Dann wird die Liste sortiert und ausgegeben. Die folgenden Schritte zeigen, wie man diesen Prozess ausführt. Das Beispiel finden Sie in der Datei unter ListeSortieren.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

Farben = ["Rot", "Orange", "Gelb", "Grün", "Blau"]

for Element in Farben:

print(Element, end=" ")

print()

Farben.sort()

for Element in Farben:

print(Element, end=" ")

print()

Zu Beginn des Beispiels wird wieder ein Array mit Farben erstellt. Die Farben sind zunächst nicht sortiert. Das Beispiel gibt die Farben in der Reihenfolge aus, wie sie erscheinen. Beachten Sie den Parameter end=" "für die Funktion print(), der sicherstellt, dass alle Farbeinträge nur in einer Zeile ausgegeben werden (so sind sie einfacher zu vergleichen).

Das Sortieren der Liste besteht einfach nur aus dem Aufruf der Funktion sort(). Nachdem die Funktion sort() im Beispiel aufgerufen wurde, wird die Liste noch mal mit print() ausgegeben, damit Sie das Ergebnis sehen können.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Ein Python-Shell-Fenster öffnet sich. Die Anwendung gibt sowohl die unsortierte als auch die sortierte Liste aus, wie in Abbildung 12.17 zu sehen.

Abbildung 12.17: Mit der Funktion sort() ist das Sortieren einer Liste ganz einfach.

Manchmal müssen Sie die Elemente auch in umgekehrter Reihenfolge sortieren. Um diese Aufgabe zu erledigen, müssen Sie die Funktion reverse() verwenden. Die Funktion muss in einer separaten Zeile stehen. Das vorhergehende Beispiel würde dann so aussehen, wenn Sie die Farben in umgekehrter Reihenfolge sortieren wollten:

Farben = ["Rot", "Orange", "Gelb", "Grün", "Blau"]

for Element in Farben:

print(Element, end=" ")

print()

Farben.sort()

Farben.reverse()

for Element in Farben:

print(Element, end=" ")

print()

Mit dem Counter-Objekt arbeiten

Manchmal möchten Sie vielleicht gerne für eine Datenquelle herausfinden, wie oft bestimmte Dinge vorkommen (zum Beispiel ein bestimmtes Element in der Liste). Haben Sie eine kurze Liste, können Sie die Elemente einfach selbst zählen. Haben Sie aber eine sehr lange Liste, ist es fast unmöglich, eine genaue Anzahl zu bekommen. Stellen Sie sich zum Beispiel vor, dass Sie eine sehr lange Geschichte, wie Krieg und Frieden, in einer Liste hätten und die Häufigkeit jedes Wortes bestimmen müssten. Ohne einen Computer wäre diese Arbeit unmöglich oder würde zumindest sehr sehr lange dauern.

Mit dem Counter-Objekt können Sie schnell Elemente zählen. Außerdem ist es unglaublich einfach zu benutzen. Dieses Buch zeigt an verschiedenen Stellen, wie das Counter-Objekt verwendet werden kann, aber dieses Kapitel demonstriert speziell die Verwendung mit Listen. Das Beispiel in diesem Abschnitt erzeugt eine Liste mit sich wiederholenden Elementen und zählt dann, wie oft diese Elemente tatsächlich vorkommen. Das Beispiel finden Sie in der Datei CounterMitListeVerwenden.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

from collections import Counter

MeineListe = [1, 2, 3, 4, 1, 2, 3, 1, 2, 1, 5]

ListenZaehler = Counter(MeineListe)

print(ListenZaehler)

for Element in ListenZaehler.items():

print("Element: ", Element[0],

" Vorkommen: ", Element[1])

print("Der Wert 1 kommt {0} Mal vor."

.format(ListenZaehler.get(1)))

Damit Sie das Counter-Objekt verwenden können, müssen Sie es aus der Bibliothek collections importieren. Wenn Sie in Ihrer Anwendung noch weitere Collection-Klassen verwenden, können Sie natürlich das gesamte Modul collections stattdessen mit import collections importieren.

Das Beispiel erzeugt zunächst eine Liste, MeineListe, mit sich wiederholenden Zahlen. Man sieht schnell, dass manche Zahlen mehr als einmal vorkommen. Das Beispiel übergibt die Liste an ein neues Counter-Objekt, ListenZaehler. Sie können Counter-Objekte auf verschiedene Arten erzeugen, aber dies ist die bequemste Methode, wenn Sie mit Listen arbeiten.

Das Counter-Objekt und die Liste sind eigentlich überhaupt nicht miteinander verbunden. Ändert sich der Listeninhalt, müssen Sie das Counter-Objekt wieder neu erzeugen, da es die Änderungen nicht automatisch mitbekommt. Eine andere Möglichkeit ist es, die clear()-Methode zuerst aufzurufen, und dann die Funktion update() aufzurufen, um das Counter-Objekt mit den neuen Daten zu füttern.

Die Anwendung gibt ListenZaehler auf verschiedene Arten aus. Die erste Ausgabe zeigt das Counter-Objekt, wie es ohne irgendwelche Veränderungen aussieht. Die zweite Ausgabe zeigt jedes einzelne eindeutige Element aus MeineListe mit dem jeweiligen Vorkommen. Damit Sie beides bekommen, das Element und die Anzahl seines Vorkommens, müssen Sie die Funktion items() wie angegeben verwenden. Schließlich zeigt das Beispiel, wie man nur die einzelnen Vorkommen in der Liste mit der Funktion get() bekommt.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Ein Python-Shell-Fenster öffnet sich und Sie sehen, welche Ergebnisse mit dem Counter-Objekt erzeugt wurden, wie in Abbildung 12.18 zu sehen.

Beachten Sie, dass die Informationen im Counter-Objekt eigentlich als Schlüssel-Wert-Paare gespeichert werden. Kapitel 13 geht auf dieses Thema ausführlich ein. Alles, was Sie für den Moment darüber wissen müssen, ist, dass das in MeineListe gefundene Element in ListenZaehler ein Schlüssel wird, der den eindeutigen Elementnamen angibt. Der Wert enthält das Vorkommen des Elements innerhalb MeineListe.

Abbildung 12.18: Das Counter-Objekt ist praktisch, wenn man Statistiken über sehr lange Listen braucht.

13

Verschiedene Sorten von Daten
sammeln

In diesem Kapitel

Eine Collection definieren

Tuple verwenden

Dictionaries verwenden

Stapel mithilfe von Listen erstellen

Das Modul queue verwenden

Das Modul deque verwenden

Leute sammeln alle möglichen Sachen. Die CDs, die sich neben Ihrer Stereoanlage stapeln, die Teller eines Services, Biergläser und sogar die Stifte aus den Hotels, in denen Sie waren, sind Sammlungen. Die Sammlungen, die Ihnen beim Schreiben eines Programms begegnen, gleichen den Sammlungen im richtigen Leben. Eine Sammlung oder Collection ist einfach eine Gruppe gleicher Elemente an einem Ort, die normalerweise auf eine leicht verständliche Art und Weise strukturiert ist.

Dieses Kapitel behandelt verschiedene Arten von Collections. Die Hauptidee hinter jeder Collection ist die Bereitstellung einer Umgebung, in der die Sammlung ordentlich verwaltet wird und für Sie alles einfach und zu jeder Zeit auffindbar ist. Regale sind perfekt zur Aufbewahrung von Büchern, DVDs und anderer flacher Dinge. Aber Ihre Stiftsammlung werden Sie wahrscheinlich lieber in einem Stifthalter oder sogar einem Setzkasten unterbringen wollen. Die Art der Aufbewahrung ändert nichts daran, dass beide Behälter Sammlungen beherbergen. Das Gleiche gilt für Collections im Computer. Sicher gibt es Unterschiede zwischen einem Stapel und einer Warteschlange, aber der Hauptgedanke ist die geordnete Verwaltung der Daten und der einfache Zugriff im Bedarfsfall.

So funktionieren Collections

In Kapitel 11 haben Sie Sequenzen kennengelernt. Eine Sequenz ist eine Aufreihung von Werten, die in einem Container zusammengefasst sind. Die einfachste Sequenz ist eine Zeichenkette, die eine Aneinanderreihung von Zeichen darstellt. In Kapitel 12 wurden als Nächstes Listen beschrieben, die Aneinanderreihungen von Objekten darstellen. Aber auch wenn sowohl Listen als auch Zeichenketten Sequenzen sind, bestehen zwischen ihnen doch erhebliche Unterschiede. Wenn Sie beispielsweise mit einem String arbeiten, können Sie alle Buchstaben in Kleinbuchstaben umwandeln – etwas, das Sie mit Listen nicht tun können. Auf der anderen Seite können Sie an Listen neue Elemente anhängen, was Strings nicht unterstützen. Collections sind lediglich ein weiterer Sequenztyp, auch wenn diese Sequenzen weit komplexer als Zeichenketten oder Listen sind.

Egal, welche Sorte Sequenz Sie verwenden, alle bieten zwei grundlegende Funktionen an: index() und count(). Die Funktion index() gibt immer die Position eines bestimmten Elements in der Sequenz zurück. Zum Beispiel können Sie damit die Position eines Zeichens in einem String oder die Position eines Objekts in einer Liste bestimmen. Die Funktion count() gibt an, wie oft ein bestimmtes Element in der Sequenz vorkommt. Auch hier kommt es auf die Sequenz an, welchen Typ dieses Element hat.

Sie können Collections verwenden, um mit Python Strukturen ähnlich einer Datenbank zu erzeugen. Jeder Collection-Typ dient einem anderen Zweck und man kann die verschiedenen Typen auf vielfältige Weise einsetzen. Denken Sie in diesem Kontext daran, dass eine Collection einfach eine weitere Sequenzart darstellt. Wie bei jeder anderen Sequenz auch, gibt es bei Collections die grundlegenden Funktionen index() und count().

Python wurde so entworfen, dass es einfach erweiterbar ist. Es bringt aber auch ein Basisrepertoire an Collections mit, die Sie in den meisten Anwendungen einsetzen können. Dieses Kapitel beschreibt die gebräuchlichsten Collections.

Tupel: Ein Tupel ist eine Collection, mit der man komplexe, listenähnliche Sequenzen erstellen kann. Ein Vorteil von Tupeln besteht darin, dass Sie sie verschachteln können. Damit wird es Ihnen ermöglicht, Datensätze von Angestellten oder x-y-Koordinaten zu verwalten.

Dictionary: Ins Deutsche übersetzt heißt das so viel wie Nachschlagewerk. Wie bei richtigen Nachschlagewerken auch, erzeugen Sie mit einem Dictionary Schlüssel-Wert-Paare (wie bei einem Wort und der dazugehörigen Definition in einem Lexikon). Mit einem Dictionary finden Sie in der Collection unglaublich schnell etwas und das Sortieren der Daten ist wesentlich einfacher.

Stapel: Die meisten Programmiersprachen unterstützen Stapel direkt. Python macht das jedoch leider nicht, es gibt aber einen Trick, wie man trotzdem einen Stapel erstellen kann. Ein Stapel ist einfach eine First in/First out-Sequenz (FIFO-Sequenz). Stellen Sie sich einen Stapel Pfannkuchen vor: Neue Pfannkuchen werden oben auf den Stapel gelegt, und wenn Sie einen Pfannkuchen herunternehmen, nehmen Sie diesen von oben wieder herunter.

queue: Im Deutschen Warteschlange genannt. Eine Warteschlange ist eine Last In/First Out-Sequenz (LIFO-Sequenz). Man verwendet sie, um Elemente in der eintreffenden Reihenfolge nacheinander abzuarbeiten. Stellen Sie sich eine Warteschlange vor einem Bankschalter vor. Sie stellen sich in die Schlange, warten, bis Sie dran sind, und werden eventuell von dem Bankangestellten bedient.

deque: Eine Warteschlange mit zwei Enden (Deque), bei der an jedem Ende, aber nicht mittendrin, Elemente hinzugefügt und entfernt werden können. Sie können Deques als Warteschlange oder Stapel oder als irgendeine andere Collection verwenden, zu der Sie Elemente geordnet hinzufügen und entfernen können (im Gegensatz zu Listen, Tupeln oder Dictionaries, die den wahlfreien Zugriff und die Verwaltung der Elemente erlauben).

Mit Tupeln arbeiten

Wie schon erwähnt, ist ein Tupel eine Sammlung, die man verwenden kann, um komplexe Listen zu erzeugen, in denen man ein Tupel in ein anderes verschachteln kann. Mithilfe dieser Verschachtelung können Sie mit Tupeln Hierarchien erstellen. Eine Hierarchie kann einfach die Ordnerstruktur auf Ihrer Festplatte oder ein Organigramm Ihrer Firma sein. Der Grundgedanke ist die Erstellung komplexer Datenstrukturen mit Tupeln.

Tupel können nicht geändert werden. Sie können ein Tupel des gleichen Namens in etwas abgeänderter Form erzeugen, aber Sie können kein existierendes Tupel ändern. Listen hingegen können geändert werden. Ein Tupel scheint also auf den ersten Blick Nachteile mit sich zu bringen, aber die Unveränderlichkeit hat auch jede Menge Vorteile, wie höhere Sicherheit und Geschwindigkeit. Hinzu kommt, dass unveränderliche Objekte mit mehreren Prozessoren einfacher zu verarbeiten sind.

Die größten Unterschiede zwischen einem Tupel und einer Liste bestehen also in der Unveränderbarkeit und der Verschachtelung von Tupeln. Die folgenden Schritte zeigen Ihnen, wie Sie in Python mit Tupeln arbeiten.

1. Öffnen Sie ein Python-Shell-Fenster.

Die bekannte Python-Eingabeaufforderung erscheint.

2. Geben Sie MeinTupel =("Rot", "Blau", "Grün") ein und drücken Sie [Enter].

Python erzeugt ein Tupel, das drei Strings enthält.

3. Geben Sie MeinTupel ein und drücken Sie [Enter].

Der Inhalt von MeinTupel, also drei Strings, wird wie in Abbildung 13.1 zu sehen ausgegeben. Beachten Sie, dass die Einträge in einfachen Anführungszeichen stehen, auch wenn Sie doppelte Anführungszeichen zur Definition des Tupels verwendet haben. Beachten Sie außerdem, dass ein Tupel nicht wie Listen eckige Klammern, sondern runde Klammern verwendet.

Abbildung 13.1: Tupel muss man mit runden statt eckigen Klammern angeben.

4. Geben Sie dir(MeinTupel) ein und drücken Sie [Enter].

Python zeigt eine Liste von Funktionen an, die Sie mit Tupeln verwenden können, wie in Abbildung 13.2 gezeigt. Beachten Sie, dass die Funktionsliste im Vergleich zu der Funktionsliste von Listen aus Kapitel 12 wesentlich kürzer ist. Die Funktionen index() und count() sind ebenfalls vorhanden.

Abbildung 13.2: Für Tupel scheint es weniger Funktionen zu geben.

Der Eindruck kann jedoch täuschen. Sie können beispielsweise neue Elemente mit der Funktion __add__() hinzufügen. Wenn Sie mit Python-Objekten arbeiten, schauen Sie sich erst einmal alle Einträge an, bevor Sie aufgrund der Funktionalität eine Entscheidung treffen.

5. Geben Sie MeinTupel=MeinTupel.__add__(("Lila",)) ein und drücken Sie [Enter].

Dieser Code fügt ein neues Tupel zu MeinTupel hinzu und speichert das Ergebnis in einer neuen Instanz von MeinTupel. Die alte Instanz wird nach dem Aufruf zerstört.

Die Funktion __add__() akzeptiert nur Tupel als Parameter. Das bedeutet, dass Sie das, was hinzugefügt werden soll, in runde Klammern schreiben müssen. Außerdem müssen Sie ein Komma hinter dem Element einfügen, wenn Sie ein Tupel mit nur einem Eintrag erzeugen, wie im Beispiel gezeigt. Das ist eine seltsame Regelung in Python, die Sie sich merken müssen, sonst bekommen Sie die folgende Fehlermeldung:

TypeError: can only concatenate tuple (not "str") to tuple

6. Geben Sie MeinTupel ein und drücken Sie [Enter].

Das neue Element in MeinTupel erscheint am Ende der Liste, wie in Abbildung 13.3 zu sehen. Beachten Sie, dass es auf der gleichen Ebene wie die anderen Einträge erscheint.

7. Geben Sie MeinTupel = MeinTupel.__add__(("Gelb",("Orange","Schwarz"))) ein und drücken Sie [Enter].

Dieser Schritt fügt drei Einträge hinzu: Gelb, Orange und Schwarz. Orange und Schwarz werden jedoch als Tupel innerhalb des Haupttupels hinzugefügt, wodurch eine Hierarchie entsteht. Diese zwei Einträge werden dann als ein Eintrag innerhalb des Haupttupels behandelt.

Abbildung 13.3: Die neue Kopie von MeinTupel enthält einen zusätzlichen Eintrag.

Sie können die Funktion __add__() durch den Verkettungsoperator ersetzen. Wenn Sie beispielsweise Magenta am Anfang des Tupels einfügen wollen, geben Sie einfach MeinTupel = ("Magenta",) + MeinTupel ein.

8. Geben Sie MeinTupel[4] ein und drücken Sie [Enter].

Python zeigt nur ein Element des Tupels an, nämlich Gelb. Tupel verwenden Indexe, um auf die einzelnen Elemente zuzugreifen, so wie es auch bei Listen schon der Fall war. Sie können bei Bedarf auch einen Bereich angeben. Alles, was Sie bei einem Listenindex tun können, können Sie auch mit Tupelindexen machen.

9. Geben Sie MeinTupel[5] ein und drücken Sie [Enter].

Sie sehen ein Tupel, das Orange und Schwarz enthält. Vielleicht möchten Sie die beiden Farben aber nicht in Tupelform verwenden.

Tupel enthalten sehr oft Hierarchien. Sie können erkennen, ob ein Index ein Tupel und keinen Wert zurückliefert, indem Sie den Typ überprüfen. Im Beispiel können Sie feststellen, dass das sechste Element (mit Index 5) ein Tupel enthält, indem Sie type(MeinTupel[5]) == tuple eingeben. In diesem Fall sollte die Ausgabe True lauten.

10. Geben Sie MeinTupel[5][0] ein und drücken Sie [Enter].

Nun gibt Python Orange aus. Abbildung 13.4 zeigt die Ergebnisse der letzten drei Befehle, woran die mehrstufige Verwendung des Indexes verdeutlicht wird. Die Indexe werden immer in der Reihenfolge der Hierarchieebenen angegeben.

Abbildung 13.4: Verwenden Sie Indexe, um Zugriff auf einzelne Tupeleinträge zu bekommen.

Mit der Verwendung von Indexen und der Funktion __add__() (oder dem Verkettungsoperator +) können Sie flexible Anwendungen basierend auf Tupeln erstellen. Sie können zum Beispiel ein Element aus einem Tupel entfernen, indem Sie dem Tupel einen Wertebereich zuweisen. Wenn Sie beispielsweise das Tupel mit Orange und Schwarz wieder entfernen wollen, können Sie MeinTupel = MeinTupel[0:5] eingeben.

Mit Dictionaries arbeiten

Ein Python-Dictionary funktioniert genauso wie ein Nachschlagewerk oder Wörterbuch im realen Leben – Sie erstellen Schlüssel-Wert-Paare. Man kann diese mit den Wörtern und entsprechenden Definitionen in einem Lexikon vergleichen. Dictionaries sind genauso wie Listen bearbeitbar, sodass Sie sie bei Bedarf ändern können. Der Hauptgrund für die Verwendung eines Dictionarys ist die schnelle Auffindbarkeit von Informationen. Der Schlüssel ist immer kurz und eindeutig, sodass der Computer nicht lange zu suchen braucht.

Die folgenden Abschnitte zeigen, wie man ein Dictionary erstellt und verwendet. Wenn Sie wissen, wie Sie mit Dictionaries arbeiten können, können Sie damit fehlende Funktionalität in Python kompensieren. Die meisten Programmiersprachen enthalten den Befehl switch, der quasi ein Auswahlmenü darstellt, aus dem eine Option ausgewählt werden kann. Python stellt dieses Konzept nicht zur Verfügung, sodass Sie normalerweise auf mehrere if...elif-Befehle zurückgreifen müssen, um eine solche Anforderung umzusetzen. (if...elif-Befehle funktionieren natürlich auch, aber diese Lösung ist nicht so übersichtlich wie die Verwendung eines switch-Befehls.)

Erstellung und Verwendung eines Dictionarys

Die Erzeugung und Verwendung eines Dictionarys funktioniert ähnlich wie bei einer Liste, außer, dass Sie nun für jeden Eintrag ein Schlüssel-Wert-Paar definieren müssen. Die folgenden Regeln müssen für die Erstellung eines Schlüssels beachtet werden:

Der Schlüssel muss eindeutig sein. Legen Sie einen Eintrag mit einem Schlüssel an, den es schon gibt, wird immer die Information aus dem zweiten Eintrag zurückgegeben, da dieser den ersten einfach überschreibt.

Der Schlüssel darf nicht änderbar sein. Sie können Strings, Zahlen oder Tupel als Schlüssel verwenden. Listen dürfen allerdings nicht als Schlüssel verwendet werden.

Es bestehen keine Einschränkungen für die Werte, die im Dictionary verwaltet werden. Ein Wert kann jedes beliebige Objekt in Python sein. Sie können beispielsweise ein Dictionary verwenden, um auf Angestelltendatensätze oder andere komplexere Daten zuzugreifen. Die folgenden Schritte helfen Ihnen dabei, Dictionaries effektiv einzusetzen.

1. Öffnen Sie ein Python-Shell-Fenster.

Die bekannte Python-Eingabeaufforderung erscheint.

2. Geben Sie Farben ={"Jakob":"Blau", "Sandra":"Rot", "Sara":"Gelb"} ein und drücken Sie [Enter].

Python erstellt ein Dictionary, das drei Einträge mit den Lieblingsfarben der angegebenen Leute enthält. Beachten Sie, wie jeweils ein Schlüssel-Wert-Paar erzeugt wird. Zuerst kommt der Schlüssel gefolgt von einem Doppelpunkt und anschließend wird der Wert angegeben. Die Einträge werden durch ein Komma getrennt.

3. Geben Sie Farben ein und drücken Sie [Enter].

Die Schlüssel-Wert-Paare werden angezeigt, wie in Abbildung 13.5 zu sehen. Beachten Sie jedoch, dass die Einträge noch nicht nach dem Schlüssel sortiert sind. Wenn Sie sie nach dem Schlüssel sortieren wollen, müssen Sie die Funktion sorted() verwenden, zum Beispiel so: sorted(Farben).

Abbildung 13.5: Ein Dictionary speichert die Einträge in unsortierter Reihenfolge.

4. Geben Sie Farben["Sara"] ein und drücken Sie [Enter].

Die unter "Sara" abgespeicherte Farbe wird ausgegeben, wie in Abbildung 13.6 gezeigt. Die Verwendung eines Strings als Schlüssel statt einer Zahl macht den Code lesbarer und macht ihn in gewissem Maße selbsterklärend. Da Dictionaries den Code lesbarer machen, ersparen sie Ihnen auf lange Sicht Zeit (darum sind sie auch so beliebt). Zwar sind Dictionaries sehr komfortabel, brauchen dadurch aber mehr Zeit zur Erstellung und verbrauchen mehr Ressourcen, was Sie bei ihrem Einsatz abwägen müssen.

Abbildung 13.6: Mit einem Dictionary können Sie sehr einfach auf Einträge zugreifen und es ist selbstbeschreibend.

5. Geben Sie Farben.keys() ein und drücken Sie [Enter].

Das Dictionary gibt die enthaltene Schlüsselliste aus, wie in Abbildung 13.7 zu sehen. Sie können mit diesen Schlüsseln den Zugriff auf das Dictionary automatisieren.

Abbildung 13.7: Sie können sich eine Liste der Schlüssel ausgeben lassen.

6. Geben Sie den folgenden Code ein und drücken Sie am Ende jeder Zeile [Enter] und drücken Sie nach der letzten Zeile zweimal [Enter].

for Element in Farben.keys():

print("{0} mag gerne die Farbe {1}."

.format(Element, Farben[Element]))

Der Beispielcode gibt eine Auflistung der Namen und der zugehörigen Lieblingsfarben aus, wie in Abbildung 13.8 zu sehen. Dictionaries können das Erstellen von praktischen Ausgaben sehr vereinfachen. Ein selbsterklärender Schlüssel ermöglicht seine einfache Verwendung in der Ausgabe.

Abbildung 13.8: Verwenden Sie selbstbeschreibende Schlüssel, um damit praktische Ausgaben zu erzeugen.

7. Geben Sie Farben["Sara"] = "Lila" ein und drücken Sie [Enter].

Der Inhalt des Dictionarys wird aktualisiert, sodass Sara nun Lila statt Gelb mag.

8. Geben Sie Farben.update({"Daniel":"Orange"}) ein und drücken Sie [Enter].

Es wird ein neuer Eintrag zum Dictionary hinzugefügt.

9. Bewegen Sie die Einfügemarke zum Ende der dritten Zeile des von Ihnen in Schritt 6 eingegebenen Codes und drücken Sie [Enter].

Der Editor erzeugt für Sie eine Kopie des Codes. Dies ist eine zeitsparende Methode, die Sie in der Python-Shell verwenden können, wenn Sie mit Quellcode experimentieren, der viel Schreibarbeit benötigt. Einmal müssen Sie den Code natürlich eingeben, aber es gibt keinen vernünftigen Grund, dies ein zweites Mal zu tun.

10. Drücken Sie zweimal [Enter].

Die aktualisierte Ausgabe aus Abbildung 13.9 erscheint. Beachten Sie, dass Daniel korrekt einsortiert wurde. Außerdem wurde Saras Eintrag für die Farbe in Lila geändert.

11. Geben Sie del Farben["Jakob"] ein und drücken Sie [Enter].

Python entfernt Jakobs Eintrag aus dem Dictionary.

12. Wiederholen Sie die Schritte 9 bis 10.

Sie sehen, dass Jakobs Eintrag tatsächlich gelöscht wurde.

13. Geben Sie len(Farben) ein und drücken Sie [Enter].

Der ausgegebene Wert 3 zeigt ebenfalls, dass das Dictionary nun nur drei statt vier Einträge enthält.

Abbildung 13.9: Dictionaries können sehr einfach geändert werden.

14. Geben Sie Farben.clear() ein und drücken Sie [Enter].

15. Geben Sie len(Farben) ein und drücken Sie [Enter].

Python teilt Ihnen mit, dass Farben 0 Einträge hat, was bedeutet, dass das Dictionary nun leer ist.

16. Schließen Sie das Python-Shell-Fenster.

Die »switch«-Anweisung durch ein Dictionary ersetzen

Die meisten Programmiersprachen bieten eine switch-Anweisung an. Eine switch-Anweisung stellt eine elegante Möglichkeit dar, eine Auswahl im Code zu implementieren. Der Benutzer hat zahlreiche Optionen, aber darf nur eine davon auswählen. Das Programm führt dann basierend auf der Auswahl einen bestimmten Ausführungszweig aus. Im Folgenden finden Sie Beispielcode (der aber unter Python nicht laufen wird), der zeigt, wie in anderen Sprachen eine switch-Anweisung aussieht:

switch(n)

{

case 0:

print("Sie haben Blau ausgewählt.");

break;

case 1:

print("Sie haben Gelb ausgewählt.");

break;

case 2:

print("Sie haben Grün ausgewählt.");

break;

}

Die Anwendung zeigt dann normalerweise eine menüähnliche Benutzerschnittstelle an, fragt den Benutzer nach der ausgewählten Zahl und führt dann über die switch-Anweisung den entsprechenden Pfad im Code aus. Diese Vorgehensweise ist sehr einfach und sauberer, als eine Reihe if-Anweisungen für dieselbe Aufgabe zu verwenden.

Leider gibt es in Python keine switch-Anweisung. Sie können daher nur auf if...elif-Anweisungen für diese Aufgabe zurückgreifen. Wenn Sie aber ein Dictionary verwenden, können Sie eine switch-Anweisung simulieren. Mit den folgenden Schritten wird ein Beispiel erstellt, das die dazu benötigte Methode demonstriert. Dieses Beispiel finden Sie in der Datei PythonSwitch.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

def BlauAusgeben():

print("Sie haben Blau ausgewählt!\r\n")

def RotAusgeben():

print("Sie haben Rot ausgewählt!\r\n")

def OrangeAusgeben():

print("Sie haben Orange ausgewählt!\r\n")

def GelbAusgeben():

print("Sie haben Gelb ausgewählt!\r\n")

Bevor irgendetwas ausgeführt wird, müssen Sie die entsprechenden Aufgaben definieren. Jede dieser Funktionen definiert eine Aufgabe, die mit einer Farbauswahl am Bildschirm korrespondiert. Es wird immer nur eine davon ausgeführt.

3. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

FarbAuswahl = {

0: BlauAusgeben,

1: RotAusgeben,

2: OrangeAusgeben,

3: GelbAusgeben,

}

Dieser Code repräsentiert das Dictionary. Jeder Schlüssel ist Teil der switch-Anweisung. Die Werte geben an, was getan werden soll. Mit anderen Worten: Dies ist die switch-Struktur. Die zuvor erstellten Funktionen sind der Ausführungsteil der switch-Anweisung – der Teil, der zwischen der case-Anweisung und der break-Klausel steht.

4. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

Auswahl = 0

while (Auswahl != 4):

print("0. Blau")

print("1. Rot")

print("2. Orange")

print("3. Gelb")

print("4. Beenden")

Auswahl = int(input("Wählen Sie eine Farbe aus: "))

if(Auswahl >= 0) and (Auswahl < 4):

FarbAuswahl[Auswahl]()

Dies ist die Benutzerschnittstelle des Beispiels. Zunächst wird eine Variable für die Eingabe, Auswahl, definiert. Solange der Benutzer nicht 4 eingibt, wird die while-Schleife durchlaufen.

In jedem Schleifendurchlauf zeigt die Anwendung eine Liste mit Optionen an und wartet dann auf eine Benutzereingabe. Gibt der Benutzer etwas ein, führt die Anwendung darauf eine Bereichsprüfung durch. Jeder Wert zwischen 0 und 3 führt eine der zuvor mit dem Dictionary definierten Funktionen wie bei einer switch-Anweisung aus.

5. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Ein Python-Shell-Fenster öffnet sich. Die Anwendung zeigt ein Menü wie das in Abbildung 13.10 an.

Abbildung 13.10: Die Anwendung zeigt zu Beginn das Auswahlmenü an.

6. Geben Sie 0 ein und drücken Sie [Enter].

Die Anwendung teilt Ihnen mit, dass Sie Blau ausgewählt haben, und zeigt dann das Menü, wie in Abbildung 13.11 zu sehen, wieder an.

Abbildung 13.11: Die Anwendung zeigt das Menü wieder an, nachdem sie Ihre Auswahl ausgegeben hat.

7. Geben Sie 4 ein und drücken Sie [Enter].

Die Anwendung ist beendet.

Stapel mithilfe von Listen erstellen

Ein Stapel (oder auch Stapelspeicher) ist eine praktische Datenstruktur, da Sie sie verwenden können, um den Zustand Ihrer Ausführungsumgebung zu speichern (das ist der Zustand der Variablen und anderer Attribute der Anwendungsumgebung zu einem bestimmten Zeitpunkt) oder um eine Ausführungsreihenfolge festzulegen. Leider stellt Python den Stapel nicht als Collection zur Verfügung. Es verfügt aber über Listen und Sie können mit einer Liste einen vollwertigen Stapel implementieren. Die folgenden Schritte erstellen ein Beispiel, in dem eine Liste als Stapel verwendet wird. Dieses Beispiel finden Sie in der Datei ListeStapel.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

MeinStapel = []

StapelGroesse = 3

def StapelAnzeigen():

print("Der Stapel enthält momentan: ")

for Element in MeinStapel:

print(Element)

def Push(Wert):

if len(MeinStapel) < StapelGroesse:

MeinStapel.append(Wert)

else:

print("Der Stapel ist voll!")

def Pop():

if len(MeinStapel) > 0:

MeinStapel.pop()

else:

print("Der Stapel ist leer!")

Push(1)

Push(2)

Push(3)

StapelAnzeigen()

input("Drücken Sie eine beliebige Taste, wenn Sie bereit sind...")

Push(4)

StapelAnzeigen()

input("Drücken Sie eine beliebige Taste, wenn Sie bereit sind...")

Pop()

StapelAnzeigen()

input("Drücken Sie eine beliebige Taste, wenn Sie bereit sind...")

Pop()

Pop()

Pop()

StapelAnzeigen()

In diesem Beispiel erzeugt die Anwendung eine Liste und eine Variable, um die maximale Stapelgröße festzulegen. Stapel haben normalerweise eine festgelegte Größe. Dies ist zugegeben ein sehr kleiner Stapel, der aber für die Zwecke des Beispiels völlig ausreichend ist.

Bei Stapeln legt man einen Wert oben auf den Stapel und nimmt Werte auch von oben wieder herunter. Die Funktionen Push() (Hinzufügen) und Pop() (Entfernen) erledigen diese beiden Aufgaben. Der Code definiert außerdem die Funktion StapelAnzeigen(), um den Inhalt des Stapels bequem und jederzeit ausgeben lassen zu können.

Der Rest des Codes testet den Stapel (prüft also seine Funktionalität), indem Werte hinzugefügt und anschließend wieder entfernt werden. Es gibt vier Testabschnitte, die die Funktionalität des Stapels prüfen.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Es öffnet sich ein Python-Shell-Fenster. Die Anwendung füllt den Stapel mit Informationen und zeigt den Inhalt dann auf dem Bildschirm an, wie in Abbildung 13.12 zu sehen. Im Beispiel liegt 3 ganz oben auf dem Stapel, da es zuletzt hinzugefügt wurde.

Abbildung 13.12: Neue Einträge werden oben auf dem Stapel gespeichert.

4. Drücken Sie [Enter].

Die Anwendung versucht, ein weiteres Element zum Stapel hinzuzufügen. Der Stapel ist aber voll, sodass dies fehlschlägt, wie in Abbildung 13.13 zu sehen.

5. Drücken Sie [Enter].

Die Anwendung entfernt einen Wert von der Oberseite des Stapels. Denken Sie daran, dass 3 ganz oben auf dem Stapel lag und daher dieser Wert bei der nächsten Ausgabe in Abbildung 13.14 fehlt.

6. Drücken Sie [Enter].

Die Anwendung versucht, mehr Elemente vom Stapel zu entfernen, als dieser tatsächlich enthält, was zu einer Fehlermeldung führt, wie in Abbildung 13.15 dargestellt. Jede Implementierung eines Stapels muss sowohl Überläufe (zu viele Einträge) und Unterläufe (zu wenige Elemente) erkennen können.

Abbildung 13.13: Ist der Stapel voll, kann man darauf keinen neuen Eintrag speichern.

Abbildung 13.14: Die Funktion pop() entfernt einen Eintrag von der Oberseite des Stapels.

Abbildung 13.15: Ihre Anwendung sollte Über- und Unterläufe erkennen können.

Mit Warteschlangen arbeiten

Eine Warteschlange (oder Queue) funktioniert anders als ein Stapel. Denken Sie an eine beliebige Schlange, in der Sie schon mal anstanden: Sie stellen sich ans Ende der Schlange und wenn Sie am Anfang der Schlange angekommen sind, machen Sie das, wofür Sie sich angestellt haben. Eine Warteschlange wird oft zur Aufgabenplanung (auch Scheduling genannt) und zur Verwaltung des Programmflusses verwendet – genauso wie im richtigen Leben. Die folgenden Schritte zeigen Ihnen, wie Sie eine Anwendung basierend auf einer Warteschlange programmieren können. Dieses Beispiel finden Sie in der Datei SchlangeDaten.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

import queue

MeineSchlange = queue.Queue(3)

print(MeineSchlange.empty())

input("Drücken Sie eine beliebige Taste, wenn Sie bereit sind...")

MeineSchlange.put(1)

MeineSchlange.put(2)

print(MeineSchlange.full())

input("Drücken Sie eine beliebige Taste, wenn Sie bereit sind...")

MeineSchlange.put(3)

print(MeineSchlange.full())

input("Drücken Sie eine beliebige Taste, wenn Sie bereit sind...")

print(MeineSchlange.get())

print(MeineSchlange.empty())

print(MeineSchlange.full())

input("Drücken Sie eine beliebige Taste, wenn Sie bereit sind...")

print(MeineSchlange.get())

print(MeineSchlange.get())

Um eine Warteschlange zu erzeugen, müssen Sie das Modul queue importieren. Dieses Modul enthält verschiedene Warteschlangentypen, aber dieses Beispiel verwendet nur die normale FIFO-Warteschlange.

Ist eine Warteschlange leer, gibt die Funktion empty() den Wert True zurück. Ähnlich ist es bei der Funktion full() – ist die Warteschlange voll, gibt full() den Wert True zurück. Mit den Funktionen empty() und full() können Sie feststellen, ob Sie mit der Warteschlange zusätzlich etwas anstellen müssen oder ob Sie weitere Informationen hinzufügen können. Diese zwei Funktionen helfen Ihnen dabei, die Warteschlange zu verwalten. Sie können eine Warteschlange nicht, wie bei anderen Collection-Arten, mit einer for-Schleife durchlaufen und müssen stattdessen empty() und full() prüfen.

Bei Warteschlangen können Sie mit den Funktionen put(), die neue Daten zur Warteschlange hinzufügt, und get(), die Daten aus der Schlange abruft, Daten verwalten. Versucht man, bei Warteschlangen mehr Elemente hinzuzufügen, als hineinpassen, wartet sie, bis wieder Platz verfügbar ist. Das ist bei Anwendungen, die nicht mit Multithreading arbeiten, problematisch, da es zum Einfrieren des Programms führen kann.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Ein Python-Shell-Fenster öffnet sich. Die Anwendung prüft den aktuellen Zustand der Warteschlange. In diesem Beispiel wird zunächst der Wert True ausgegeben, da die Warteschlange leer ist.

4. Drücken Sie [Enter].

Die Anwendung fügt der Warteschlange zwei neue Werte hinzu. Die Warteschlange ist nun nicht mehr leer, wie in Abbildung 13.16 zu sehen.

Abbildung 13.16: Speichert die Anwendung in der Warteschlange neue Einträge, gibt diese nicht mehr an, dass sie leer ist.

5. Drücken Sie [Enter].

Die Anwendung fügt der Warteschlange einen weiteren Wert hinzu, sodass sie nun voll ist, da ihre Größe auf 3 begrenzt ist. full() gibt nun den Wert True zurück, da die Warteschlange voll ist.

6. Drücken Sie [Enter].

Um Platz zu schaffen, entfernt die Anwendung einen der Einträge. Immer wenn eine Anwendung einen Eintrag erhält, wird er von der Funktion get() zurückgegeben. Da 1 als erster Wert zur Warteschlange hinzugefügt wurde, sollte die Funktion print() den Wert 1 ausgeben, wie in Abbildung 13.17 zu sehen. Außerdem sollten die Funktionen full() und empty() nun beide den Wert False zurückgeben.

Abbildung 13.17: Die Eigenschaften einer Warteschlange muss man sehr häufig prüfen.

7. Drücken Sie [Enter].

Die Anwendung entfernt die verbleibenden zwei Einträge. Die Anwendung gibt 2 und 3 aus.

Mit Deques arbeiten

Eine Deque (Kurzform von Double-ended Queue) ist einfach eine Warteschlange, bei der Sie an beiden Enden Elemente hinzufügen und entfernen können. In vielen Programmiersprachen beginnen Warteschlangen oder Stapel als Deque. Spezieller Code limitiert dann die Funktionalität der Deques, um eine bestimmte Aufgabe zu erfüllen.

Wenn Sie mit einer Deque arbeiten, müssen Sie sich diese als eine Art horizontale Linie vorstellen. Dedizierte Funktionen arbeiten mit der rechten und linken Seite der Deque, sodass Sie an beiden Seiten Elemente hinzufügen und entfernen können. Die folgenden Schritte demonstrieren die Verwendung einer Deque anhand eines Beispiels. Dieses Beispiel finden Sie in der Datei DequeDaten.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

import collections

MeineDeque = collections.deque("abcdef", 10)

print("Anfangszustand: ")

for Element in MeineDeque:

print(Element,end=" ")

print("\r\n\r\nAnhängen und erweitern rechts")

MeineDeque.append("h")

MeineDeque.extend("ij")

for Element in MeineDeque:

print(Element,end=" ")

print("\r\nMeineDeque enthält {0} Elemente."

.format(len(MeineDeque)))

print("\r\nRechts entfernen")

print("Entferne {0}".format(MeineDeque.pop()))

for Element in MeineDeque:

print(Element, end=" ")

print("\r\n\r\nAnhängen und erweitern links")

MeineDeque.appendleft("a")

MeineDeque.extendleft("bc")

for Element in MeineDeque:

print(Element,end=" ")

print("\r\nMeineDeque enthält {0} Elemente."

.format(len(MeineDeque)))

print("\r\nLinks entfernen")

print("Entferne {0}".format(MeineDeque.popleft()))

for Element in MeineDeque:

print(Element, end=" ")

print("\r\n\r\nEntfernen")

MeineDeque.remove("a")

for Element in MeineDeque:

print(Element,end=" ")

Die Implementierung von Deque finden Sie im Modul collections, also müssen Sie dieses in Ihrem Code importieren. Wenn Sie eine Deque erzeugen, können Sie wahlweise auch eine Anfangsliste mit iterierbaren Elementen (Elementen, auf die Sie in einer Schleifenkonstruktion zugreifen und die Sie verarbeiten können) und eine maximale Größe, wie gezeigt, angeben.

Eine Deque unterscheidet beim Hinzufügen zwischen einzelnen Elementen und einer Gruppe von Elementen. Sie verwenden append() oder appendleft(), wenn Sie nur ein Element hinzufügen. Mit den Funktionen extend() und extendleft() können Sie mehrere Elemente hinzufügen. Sie verwenden die Funktionen pop() oder popleft(), um jeweils ein Element zu entfernen. Der Aufruf der Funktionen pop() und popleft() gibt das entfernte Element zurück, sodass es am Bildschirm ausgegeben werden kann. Die Funktion remove() ist etwas Besonderes, da sie immer links beginnt und immer die erste Instanz der angegebenen Daten entfernt.

Anders als andere Collections kann eine Deque vollständig durchlaufen werden. Das bedeutet, dass Sie mit einer for-Schleife bei Bedarf eine Liste aller Elemente erhalten.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Ein Python-Shell-Fenster wird geöffnet. Das Beispiel gibt die Informationen aus Abbildung 13.18 aus.

Abbildung 13.18: Eine Deque hat zwei Enden und die entsprechenden Funktionen, diese zu verwalten.

Schauen Sie sich die ausgegebene Liste genau an. Beachten Sie, wie sich die Größe der Deque im Laufe des Programms verändert. Nachdem die Anwendung das j entfernt hat, enthält die Deque noch acht Elemente. Hängt die Anwendung links etwas an und erweitert die Deque links, fügt sie noch drei weitere Elemente hinzu. Trotzdem enthält die Deque nur zehn Elemente. Erreicht man die maximale Größe der Deque, fallen zusätzliche Daten einfach am anderen Ende heraus (daher fehlt das i am Ende der Deque).

14

Klassen erstellen und verwenden

In diesem Kapitel

Werden die Eigenschaften einer Klasse definiert

Werden die Klassenkomponenten erklärt

Erstellen Sie eine eigene Klasse

Arbeiten Sie mit der Klasse in Ihrer Anwendung

Arbeiten Sie mit Unterklassen

Sie haben schon in den vorhergehenden Kapiteln mit einigen Klassen gearbeitet. Viele der Beispiele sind einfach zu erstellen und zu verwenden, da sie auf Python-Klassen basieren. Auch wenn Klassen kurz in den vorhergehenden Kapiteln erwähnt wurden, werden sie in diesen Kapiteln weitgehend ignoriert, da ihre Erläuterung dort noch nicht wichtig war.

Klassen machen die Arbeit mit Python-Code komfortabler, da sie Ihre Anwendungen einfacher zu lesen, zu verstehen und zu verwenden machen. Sie verwenden Klassen, um Behälter für Ihren Code und Ihre Daten zu erzeugen, sodass sie zu einer Einheit zusammengefasst werden. Außenstehende betrachten Ihre Klasse als Blackbox – Daten wandern hinein und Ergebnisse kommen heraus.

Irgendwann müssen Sie in Ihren Anwendungen Klassen einsetzen, um den Gefahren zu entgehen, die durch Spaghetti-Code verursacht werden, den man häufig in anderen Anwendungen findet. Wie der Name schon andeutet, sind in Spaghetti-Code Codezeilen von verschiedenen Aufgaben so miteinander verwoben und verstreut, dass man nicht feststellen kann, wo eine Spaghetti beginnt und wo eine andere endet. Die Wartung von Spaghetti-Code ist nahezu unmöglich und manche Firmen haben einige Anwendungen ganz an den Nagel gehängt, da sie niemand mehr verstanden hat.

Außer der Erkenntnis, dass Klassen eine gute Methode zur Strukturierung von Code und Vermeidung von Spaghetti-Code darstellen, vermittelt Ihnen dieses Kapitel das Handwerkszeug zur Erzeugung und Verwendung Ihrer ersten eigenen Klasse. Sie werden Einblicke in die Funktionsweise von Python-Klassen bekommen, sodass man mit Ihren Anwendungen komfortabel arbeiten kann. Dieses Kapitel stellt aber nur eine Einführung dar und Sie werden nicht so tief in das Thema Klassen einsteigen, dass Ihnen der Kopf schwirrt. Dieses Kapitel zeigt Ihnen, wie Sie Klassen einfach und gut wartbar entwickeln können.

Klassen als Strukturierungshilfe

Eine Klasse ist im Grunde eine Methode zur Bündelung von Code. Sie soll die Wiederverwendung von Code erleichtern, Anwendungen verlässlicher machen und das Risiko von Sicherheitslücken minimieren. Ordentlich entworfene Klassen sind Blackboxes, die Eingaben entgegennehmen und Ergebnisse aufgrund dieser Eingaben produzieren. Kurz gefasst sollen Klassen für niemanden Überraschungen bereithalten und sollten nach außen sichtbare (quantifizierbare) Verhaltensweisen haben. Wie die Klasse ihre Arbeit erledigt, ist unwichtig und es ist gute Programmierpraxis, die Vorgehensweisen im Inneren der Klasse vor den Benutzern zu verbergen.

Bevor Sie zur eigentlichen Klassentheorie kommen, sollten Sie zunächst ein paar wichtige Begriffe im Zusammenhang mit Klassen kennenlernen. Die folgende Liste erklärt Begriffe, die Sie benötigen, um die Inhalte weiter hinten in diesem Kapitel zu verstehen. Diese Begriffe sind spezifisch für Python. (Andere Sprachen verwenden eventuell andere Begriffe für dieselben Methoden oder definieren Begriffe, die in Python anders verwendet werden.)

Klasse: Definiert eine Blaupause zur Erzeugung eines Objekts. Stellen Sie sich einen Bauingenieur vor, der eine bestimmte Art von Gebäude errichten möchte. Der Bauingenieur verwendet eine Blaupause, damit das Gebäude den gestellten Anforderungen entspricht. Genauso verwendet Python Klassen als Blaupause, um neue Objekte zu erzeugen.

Klassenvariable: Ein Speicherort, den alle Methoden einer Klasseninstanz verwenden können. Eine Klassenvariable wird in der Klasse selbst, aber außerhalb einer Methode definiert. Klassenvariablen werden nicht oft verwendet, da sie ein potenzielles Sicherheitsrisiko darstellen – jede Methode der Klasse hat auf dieselbe Information Zugriff und kann sie verändern. Außerdem sind Klassenvariablen global für die Klasse verfügbar und nicht einer bestimmten Klasseninstanz zugeordnet, also können sie zu einer möglichen Degeneration der Klasse führen.

Daten-Member: Definiert entweder eine Klassenvariable oder eine Instanzvariable, um zu einer Klasse zugehörige Daten und deren Objekte zu speichern.

Funktionsüberladung: Definiert mehr als eine Version einer Funktion, in denen man unterschiedliche Verhaltensweisen festlegen kann. Die grundlegende Aufgabe der Funktion bleibt gleich, aber die Parameter und die potenzielle Ausgabe unterscheiden sich. Funktionsüberladung soll mehr Flexibilität ermöglichen, sodass eine Funktion in einer Anwendung auf vielfältige Weise eingesetzt werden kann.

Vererbung: Verwendet eine Elternklasse, von der Kindklassen abgeleitet werden können, die die Verhaltensweisen der Elternklasse übernehmen. Normalerweise erweitern die Kindklassen die Funktionalität der Elternklasse mit spezifischerem Verhalten.

Instanz: Definiert ein Objekt, das anhand einer Klassenspezifikation erzeugt wird. Python kann so viele Instanzen einer Klasse wie benötigt erzeugen, um die Aufgaben einer Anwendung zu erfüllen. Jede Instanz ist einzigartig.

Instanzvariable: Stellt einen Speicherort zur Verfügung, der von einer einzelnen Methode einer Klasseninstanz verwendet wird. Die Variable wird innerhalb einer Methode definiert. Instanzvariablen werden als sicherer angesehen, da nur eine Methode einer Klasse darauf zugreifen kann. Die Daten werden zwischen den Methoden über Parameter ausgetauscht, wodurch eine genaue Kontrolle der eingehenden Daten und eine bessere Datenverwaltung ermöglicht wird.

Instanziierung: Der Vorgang zum Erzeugen einer Instanz für eine Klasse. Das erzeugte Objekt ist eine einzigartige Klasseninstanz.

Methode: Begriff für Funktionen, die Teil einer Klasse sind. Auch wenn Funktionen und Methoden im Grunde dasselbe Element definieren, sind Methoden etwas spezifischer, da nur Klassen Methoden definieren können.

Objekt: Definiert eine einzigartige Instanz einer Klasse. Das Objekt enthält alle Methoden und Eigenschaften der Klasse, von der es instanziiert wurde. Allerdings unterscheiden sich die Objekte in den Daten, die in den Eigenschaften abgelegt sind. Die Speicherorte für die Daten der Objekte unterscheiden sich, auch wenn die Daten gleich sind.

Operatorüberladung: Erzeugt mehrere Versionen einer Funktion, die mit einem Operator, wie +, -, / oder *, verknüpft ist, wodurch unterschiedliche Verhaltensweisen definiert werden können. Die grundlegende Aufgabe des Operators ist gleich, aber die Art, wie der Operator mit den Daten umgeht, ist unterschiedlich. Operatorüberladung wird verwendet, um eine höhere Flexibilität zu erreichen, sodass ein Operator auf verschiedene Weisen in einer Anwendung eingesetzt werden kann.

Komponenten einer Klasse

Eine Klasse hat einen bestimmten Aufbau. Jeder Teil der Klasse erfüllt eine bestimmte Aufgabe, die der Klasse nützliche Eigenschaften verleiht. Zunächst beginnt die Klasse mit einem generellen Container, der die gesamte Klasse zusammenhält. Dies ist der erste Teil der Klasse, der im nächsten Abschnitt erklärt wird. Die weiteren Abschnitte beschreiben die anderen Teile einer Klasse und zeigen, wie diese Teile zu ihrem großen Ganzen beitragen.

Eine Klassendefinition schreiben

Eine Klasse muss nicht besonders kompliziert sein. Im Prinzip können Sie einfach das Klassengerüst mit einem Klassenmitglied erzeugen und dies eine Klasse nennen. Klar, macht diese Klasse dann nicht viel, aber man kann sie zumindest instanziieren (Python sagen, dass es ein Objekt mit der Klasse als Vorlage erzeugen soll) und damit, wie mit jeder anderen Klasse auch, arbeiten. Die folgenden Schritte verdeutlichen Ihnen die Grundlagen einer Klasse, indem die einfachste mögliche Klasse programmiert wird.

1. Öffnen Sie ein Python-Shell-Fenster.

Die bekannte Python-Eingabeaufforderung erscheint.

2. Geben Sie den folgenden Code ein und drücken Sie am Ende jeder Zeile einmal [Enter] und am Ende der letzten Zeile zweimal [Enter]:

class MeineKlasse:

MeineVar = 0

Die erste Zeile definiert den Klassencontainer, der aus dem Schlüsselwort class und dem Klassennamen, MeineKlasse, besteht. Jede von Ihnen geschriebene Klasse muss so beginnen. Sie müssen immer class gefolgt vom Klassennamen verwenden.

Die zweite Zeile ist der Klassenrumpf. Alle Elemente, die zur Klasse gehören, werden als Klassenrumpf bezeichnet. Im Beispiel besteht er aus der Klassenvariablen MeineVar, die den Wert 0 zugewiesen bekommt. Jede Instanz der Klasse wird dieselbe Variable enthalten und mit dem gleichen Wert beginnen.

3. Geben Sie MeineInstanz = MeineKlasse() ein und drücken Sie [Enter].

Sie haben gerade eine Instanz der Klasse MeineKlasse namens MeineInstanz erzeugt. Natürlich möchten Sie sich nun auch davon überzeugen, dass Sie tatsächlich eine solche Instanz angelegt haben. Das wird in Schritt 4 gemacht.

4. Geben Sie MeineInstanz.MeineVar ein und drücken Sie [Enter].

Die Ausgabe des Wertes 0, wie in Abbildung 14.1 zu sehen, zeigt, dass MeineInstanz tatsächlich eine Klassenvariable mit Namen MeineVar hat.

Abbildung 14.1: Die Instanz enthält die benötigte Variable.

5. Geben Sie MeineInstanz.__class__ ein und drücken Sie [Enter].

Python gibt die Klasse aus, die zur Erzeugung dieser Instanz verwendet wurde, wie in Abbildung 14.2 gezeigt. Die Ausgabe sagt Ihnen, dass diese Klasse Teil des Moduls __main__ist, da Sie es direkt in die Shell eingegeben haben.

6. Lassen Sie dieses Fenster mitsamt der Klasse für den nächsten Abschnitt geöffnet.

Abbildung 14.2: Der Klassenname stimmt auch. Also wissen Sie nun, dass die Instanz mit MeineKlasse erzeugt wurde.

Die integrierten Klassenattribute

Wenn Sie eine Klasse erstellen, könnten Sie einfach denken, dass alles, was Sie dann bekommen, diese Klasse ist. Python fügt Ihrer Klasse aber noch weitere Funktionalität hinzu. Im vorhergehenden Abschnitt haben Sie beispielsweise __class__ eingegeben und [Enter] gedrückt. Das Attribut __class__ ist integriert; Sie haben es nicht erstellt. Es ist gut zu wissen, dass Python diese Funktionalität anbietet, sodass Sie sie selbst nicht hinzufügen müssen. Diese Funktion wird so oft gebraucht, dass sie jede Klasse haben sollte, und daher stellt Python sie zur Verfügung. Die folgenden Schritte zeigen Ihnen, wie Sie die integrierten Klassenattribute verwenden können.

1. Verwenden Sie das Shell-Fenster, das Sie im letzten Abschnitt geöffnet haben.

Wenn Sie den Schritten aus dem letzten Abschnitt Eine Klassendefinition schreiben nicht gefolgt sind, holen Sie dies bitte jetzt nach.

2. Geben Sie dir(MeineInstanz) ein und drücken Sie [Enter].

Eine Liste mit Attributen erscheint, wie in Abbildung 14.3 zu sehen. Diese Attribute stellen Ihrer Klasse eine spezifische Funktionalität zur Verfügung. Jede Klasse, die Sie erzeugen, hat diese Attribute ebenfalls, sodass Sie sich immer darauf verlassen können, dass diese Funktionalität den von Ihnen erstellten Klassen zur Verfügung steht.

Abbildung 14.3: Verwenden Sie die Funktion dir(), um herauszufinden, welche integrierten Attribute es gibt. Geben Sie help(´__class__´) ein und drücken Sie [Enter].

Python zeigt Informationen über das Attribut __class__, wie in Abbildung 14.4 dargestellt, an. Mit dieser Methode können Sie sich über jedes Attribut, das Python Ihrer Klasse hinzufügt, näher informieren.

Abbildung 14.4: Python stellt Ihnen zu jedem Attribut, das es Ihrer Klasse hinzufügt, einen Hilfeeintrag zur Verfügung.

3. Schließen Sie das Python-Shell-Fenster.

Mit Methoden arbeiten

Methoden sind einfach eine Bezeichnung für Funktionen, die innerhalb einer Klasse definiert sind. Sie können mit Methoden ganz genauso arbeiten wie mit Funktionen, mit dem Unterschied, dass Methoden immer zu einer Klasse gehören. Sie können zwei verschiedene Arten von Methoden erstellen: Methoden, die direkt an die Klasse gebunden sind, und Methoden, die mit einer Instanz einer Klasse verknüpft sind. Dieser Unterschied ist sehr wichtig. Die folgenden Abschnitte beschreiben näher, wie Sie mit diesen beiden Methodentypen arbeiten können.

Klassenmethoden erstellen

Eine Klassenmethode können Sie direkt über die Klasse aufrufen, ohne eine Instanz der Klasse erstellen zu müssen. Manchmal müssen Sie Methoden definieren, die direkt über die Klasse aufgerufen werden, wie zum Beispiel die Funktionen, die die Klasse str zur Verfügung stellt, um Strings zu bearbeiten. Beispielsweise verwendet MehrereAusnahmen4.py in Kapitel 9 die Funktion str.upper(). Die folgenden Schritte erklären, wie man eine Klassenmethode definiert und verwendet.

1. Öffnen Sie ein Python-Shell-Fenster.

Sie sehen die schon bekannte Python-Eingabeaufforderung.

2. Geben Sie den folgenden Code ein (drücken Sie am Ende jeder Zeile einmal und am Ende der letzten Zeile zweimal [Enter]).

class MeineKlasse:

def HalloSagen():

print("Hallöchen!")

Die Beispielklasse enthält ein einziges Attribut, HalloSagen(). Diese Methode nimmt keine Parameter entgegen und gibt keine Werte zurück. Sie gibt einfach eine Nachricht aus. Zu Demonstrationszwecken ist diese Methode aber völlig ausreichend.

3. Geben Sie MeineKlasse.HalloSagen() ein und drücken Sie [Enter].

Das Beispiel gibt den zu erwartenden String aus, wie in Abbildung 14.5 zu sehen. Beachten Sie, dass keine Instanz der Klasse erzeugt werden musste – die Methode kann direkt verwendet werden.

Abbildung 14.5: Die Klassenmethode gibt eine einfache Nachricht aus.

4. Schließen Sie das Python-Shell-Fenster.

Eine Klassenmethode kann immer nur global definierte Daten der Klasse verwenden. Ihr sind keine Daten bekannt, die mit einer Instanz verknüpft sind. Sie können allerdings Daten als Parameter an die Methode übergeben und die Methode kann bei Bedarf eine Rückgabe machen, aber sie kann eben nicht auf die Daten einer Instanz zugreifen. Daher müssen Sie bei der Definition von Klassenmethoden besondere Vorsicht walten lassen und daran denken, dass diese in sich geschlossen sein muss.

Instanzmethoden definieren

Eine Instanzmethode gehört immer zu einer individuellen Instanz einer Klasse. Sie verwenden Instanzmethoden, um die Daten, die die Instanz speichert, zu manipulieren. Daher können Sie Instanzmethoden erst dann verwenden, wenn Sie eine Instanz einer Klasse erzeugt haben.

Alle Instanzmethoden nehmen mindestens einen Parameter entgegen, nämlich self. Der Parameter self zeigt auf diese ganz bestimmte Instanz und wird von der Anwendung dazu benutzt, Daten der Instanz zu ändern. Ohne den Parameter self wüsste die Methode nicht, welche Instanzdaten sie verwenden sollte. self ist aber nicht als zugreifbarer Parameter gedacht – der Wert von self wird von Python festgelegt und Sie können ihn beim Aufruf der Methode nicht verändern.

Die folgenden Schritte zeigen, wie man Instanzmethoden in Python definiert und verwendet.

1. Öffnen Sie ein Python-Shell-Fenster.

Sie sehen die schon bekannte Python-Eingabeaufforderung.

2. Geben Sie den folgenden Code ein (drücken Sie am Ende jeder Zeile einmal und am Ende der letzten Zeile zweimal [Enter]).

class MeineKlasse:

def HalloSagen(self):

print("Hallöchen!")

Diese Beispielklasse enthält nur ein definiertes Attribut, HalloSagen(). Die Methode nimmt keine besonderen Parameter entgegen und gibt auch nichts zurück. Sie gibt einfach eine Nachricht auf dem Bildschirm aus. Zu Demonstrationszwecken ist diese Methode aber völlig ausreichend.

3. Geben Sie MeineInstanz = MeineKlasse() ein und drücken Sie [Enter].

Python erzeugt eine Instanz von MeineKlasse namens MeineInstanz.

4. Geben Sie MeineInstanz.HalloSagen() ein und drücken Sie [Enter].

Sie sehen die Meldung aus Abbildung 14.6.

Abbildung 14.6: Die Instanzmethode wird als Teil des Objekts aufgerufen und gibt eine einfache Nachricht aus.

5. Schließen Sie das Python-Shell-Fenster.

Mit Konstruktoren arbeiten

Ein Konstruktor ist ein spezieller Methodentyp, den Python aufruft, wenn es ein Objekt mithilfe der Definitionen in Ihrer Klasse erzeugt. Python verwendet Konstruktoren, um Aufgaben zu erledigen, wie das Initialisieren (die anfängliche Zuweisung von Werten) beliebiger Instanzvariablen, die vom Objekt zu Beginn der Anwendung gebraucht werden. Konstruktoren können auch prüfen, ob dem Objekt ausreichend Ressourcen zur Verfügung stehen oder andere vorbereitende Maßnahmen durchführen.

Der Name eines Konstruktors lautet immer gleich, __init__(). Der Konstruktor kann Parameter entgegennehmen, wenn diese zur Initialisierung des Objekts benötigt werden. Wenn Sie eine Klasse ohne Konstruktor definieren, erzeugt Python automatisch einen Standardkonstruktor für Sie, der nichts weiter tut. Jede Klasse muss einen Konstruktor haben, auch wenn es nur der Standardkonstruktor ist. Die folgenden Schritte zeigen, wie man einen Konstruktor definiert.

1. Öffnen Sie ein Python-Shell-Fenster. Sie sehen die schon bekannte Python-Eingabeaufforderung.

2. Geben Sie den folgenden Code ein (drücken Sie am Ende jeder Zeile einmal und am Ende der letzten Zeile zweimal [Enter]).

class MeineKlasse:

Gruss = ""

def __init__(self, Name="Du"):

self.Gruss = Name + "!"

def HalloSagen(self):

print("Hallo {0}".format(self.Gruss))

Dies ist gleichzeitig ein erstes Beispiel für die Funktionsüberladung. Es gibt zwei Versionen der Methode __init__(). Die erste benötigt keine besondere Eingabe, da sie den Standardwert »Du« für Name verwendet. Die zweite Version verlangt einen Namen als Eingabe. Sie setzt Gruss mit dem Wert des Parameters gleich und fügt ein Ausrufezeichen hinzu. Die Methode HalloSagen() entspricht den gleichnamigen Methoden der vorhergehenden Beispiele in diesem Kapitel.

Python unterstützt keine richtige Funktionsüberladung. Manche Leute, die sich strikt an die strengen Prinzipien der Objekt-orientierten Programmierung halten, betrachten das Setzen von Standardwerten nicht als Funktionsüberladung. Aber das Setzen von Standardwerten kommt zu demselben Ergebnis und stellt die einzige Möglichkeit dar, die Python anbietet. Bei der richtigen Funktionsüberladung finden Sie verschiedene Versionen derselben Funktion, die die Eingabe jeweils unterschiedlich verarbeiten könnten.

3. Geben Sie MeineInstanz = MeineKlasse() ein und drücken Sie [Enter].

Python erzeugt eine Instanz der Klasse MeineKlasse namens MeineInstanz.

4. Geben Sie MeineInstanz.HalloSagen() ein und drücken Sie [Enter].

Sie sehen die Meldung aus Abbildung 14.7. Beachten Sie, dass diese Nachricht die generische Standardgrußformel anzeigt.

Abbildung 14.7: Die erste Version des Konstruktors stellt einen Standardwert für den Namen zur Verfügung.

5. Geben Sie MeineInstanz = MeineKlasse("Irgendjemand") ein und drücken Sie [Enter].

Python erzeugt eine Instanz der Klasse MeineKlasse namens MeineInstanz.

6. Geben Sie MeineInstanz.HalloSagen() ein und drücken Sie [Enter].

Sie sehen die Meldung aus Abbildung 14.8. Beachten Sie, dass nun eine angepasste Grußformel ausgegeben wird.

Abbildung 14.8: Übergibt man dem Konstruktor einen Namen, wird die Ausgabe entsprechend angepasst.

7. Schließen Sie das Python-Shell-Fenster.

Mit Variablen arbeiten

Wie schon zuvor in diesem Buch erwähnt, sind Variablen Aufbewahrungsboxen, die Daten enthalten. Bei der Arbeit mit Klassen müssen Sie sich überlegen, wie die Daten gespeichert und verwaltet werden sollen. Eine Klasse kann sowohl Klassen- als auch Instanzvariablen enthalten. Die Klassenvariablen werden als Teil der Klasse selbst definiert, während Instanzvariablen immer zu einer spezifischen Instanz gehören und in Methoden definiert werden. Die folgenden Abschnitte zeigen Ihnen, wie beide Variablentypen verwendet werden.

Klassenvariablen definieren

Klassenvariablen bieten einen globalen Zugriff auf Daten, die Ihre Klasse irgendwie manipuliert. In den meisten Fällen initialisieren Sie globale Variablen mit dem Konstruktor, um sicherzustellen, dass sie vernünftige und bekannte Daten enthalten. Die folgenden Schritte zeigen, wie Klassenvariablen funktionieren.

1. Öffnen Sie ein Python-Shell-Fenster.

Sie sehen die schon bekannte Python-Eingabeaufforderung.

2. Geben Sie den folgenden Code ein (drücken Sie am Ende jeder Zeile einmal und am Ende der letzten Zeile zweimal [Enter]).

class MeineKlasse:

Gruss = ""

def HalloSagen(self):

print("Hallo {0}".format(self.Gruss))

Dies ist eine Version des Codes, der schon im Abschnitt Mit Konstruktoren arbeiten vorkam, aber diese Version enthält keinen Konstruktor. Normalerweise definieren Sie einen Konstruktor, damit die Klassenvariable ordentlich initialisiert wird. Diese Schritte sollen Ihnen aber aufzeigen, was bei Klassenvariablen schiefgehen kann.

3. Geben Sie MeineKlasse.Gruss = "Zelda" ein und drücken Sie [Enter].

Diese Anweisung setzt den Wert von Gruss mit etwas anderem als dem Wert gleich, den Sie verwendet haben, als Sie die Klasse erzeugten. Jeder könnte diese Änderung machen. Die große Frage ist nun, ob die Änderung angewendet wird.

4. Geben Sie MeineKlasse.Gruss ein und drücken Sie [Enter].

Sie sehen, dass der Wert von Gruss sich geändert hat, wie in Abbildung 14.9 dargestellt.

Abbildung 14.9: Sie können den Wert von Gruss ändern.

5. Geben Sie MeineInstanz = MeineKlasse() ein und drücken Sie [Enter].

Python erzeugt eine Instanz der Klasse MeineKlasse namens MeineInstanz.

6. Geben Sie MeineInstanz.HalloSagen() ein und drücken Sie [Enter].

Sie sehen die Meldung aus Abbildung 14.10. Die Änderung, die Sie an Gruss vorgenommen haben, hat sich in die Instanz der Klasse übertragen. In diesem Beispiel stellt die Verwendung einer Klassenvariablen kein wirkliches Problem dar, aber Sie können sich vorstellen, was in einer richtigen Anwendung passieren könnte, wenn jemand Ärger machen wollte.

Abbildung 14.10: Die Änderung von Gruss überträgt sich in die Instanz.

Dies ist nur ein einfaches Beispiel, was man mit Klassenvariablen falsch machen kann. Die zwei Schlussfolgerungen, die Sie aus diesem Beispiel ziehen sollten:

- Vermeiden Sie die Verwendung von Klassenvariablen, wenn möglich, da sie potenziell unsicher sind.

- Initialisieren Sie Klassenvariablen immer mit einem ordentlichen, bekannten Wert im Code des Konstruktors.

7. Schließen Sie das Python-Shell-Fenster.

Instanzvariablen definieren

Instanzvariablen werden immer als Teil einer Methode definiert. Die Eingabeparameter einer Methode werden auch als Instanzvariablen angesehen, da sie nur dann existieren, wenn auch die Methode existiert. Die Verwendung von Instanzvariablen ist normalerweise sicherer als die Benutzung von Klassenvariablen, da man sie einfacher kontrollieren und sicherstellen kann, dass der Aufrufer eine korrekte Eingabe macht. Die folgenden Schritte erläutern, wie man Instanzvariablen verwendet.

1. Öffnen Sie ein Python-Shell-Fenster. Sie sehen die schon bekannte Python-Eingabeaufforderung.

2. Geben Sie den folgenden Code ein (drücken Sie am Ende jeder Zeile einmal und am Ende der letzten Zeile zweimal [Enter]).

class MeineKlasse:

def Summieren(self, Wert1 = 0, Wert2 = 0):

Summe = Wert1 + Wert2

print("Die Summe aus {0} und {1} ist {2}."

.format(Wert1, Wert2, Summe))

In diesem Beispiel gibt es drei Instanzvariablen. Die Eingabeparameter, Wert1 und Wert2, haben den Standardwert 0, sodass Summieren() immer funktioniert, auch wenn der Benutzer keine Werte eingibt. Natürlich könnte der Benutzer auch etwas anderes als Zahlen eingeben, also sollten Sie die entsprechenden Prüfungen in Ihren Code aufnehmen. Die dritte Instanzvariable ist Summe, die Wert1 + Wert2 entspricht. Der Code addiert einfach die beiden Werte miteinander und zeigt das Ergebnis an.

3. Geben Sie MeineInstanz = MeineKlasse() ein und drücken Sie [Enter].

Python erzeugt eine Instanz der Klasse MeineKlasse namens MeineInstanz.

4. Geben Sie MeineInstanz.Summieren(1,4) ein und drücken Sie [Enter].

Die Nachricht aus Abbildung 14.11 wird angezeigt. Sie sehen das Ergebnis der Addition von 1 und 4.

Abbildung 14.11: Als Ausgabe bekommt man einfach die Summe zweier Zahlen.

5. Schließen Sie das Python-Shell-Fenster.

Methoden mit variablen Parameterlisten verwenden

Manchmal braucht man Methoden, die eine variable Anzahl von Parametern entgegennehmen. Mit dieser Situation kann Python hervorragend umgehen. Im Folgenden finden Sie die zwei Arten von variablen Parametern, die Sie definieren können:

*args: Stellt eine Liste mit unbenannten Parametern zur Verfügung.

**kwargs: Stellt eine Liste mit benannten Parametern zur Verfügung.

Die eigentlichen Namen der Parameter spielen keine Rolle, aber Python-Entwickler verwenden *args und **kwargs als Konvention, sodass andere Python-Entwickler wissen, dass es eine variable Liste mit Parametern ist. Beachten Sie, dass der erste Variablenparameter nur ein Sternchen (*) hat, und das bedeutet, dass die Parameter unbenannt sind. Die zweite Variable hat zwei Sternchen, die Parameter sind also benannt. Die folgenden Schritte zeigen Ihnen, wie man beide Methoden verwendet, um eine Anwendung zu schreiben. Dieses Beispiel finden Sie in der Datei VariableParams.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile einmal [Enter]:

class MeineKlasse:

def SchreibeListe1(*args):

for Zaehler, Element in enumerate(args):

print("{0}. {1}".format(Zaehler, Element))

def SchreibeListe2(**kwargs):

for Name, Wert in kwargs.items():

print("{0} mag {1}".format(Name,Wert))

MeineKlasse.SchreibeListe1("Rot", "Blau", "Grün")

MeineKlasse.SchreibeListe2(Daniel="Rot", Sara="Blau",

Jakob="Grün")

Aus Demonstrationsgründen für das Beispiel werden die Parameter als Teil einer Klassenmethode implementiert. Sie können sie aber genauso einfach in einer Instanzmethode verwenden.

Schauen Sie sich SchreibeListe1() genau an. Sie sehen dort eine weitere Methode, wie man mit einer for-Schleife eine Liste durchläuft. In diesem Beispiel gibt die Funktion enumerate() sowohl einen Zähler (den Schleifenzähler) als auch den String aus, der der Funktion übergeben wurde.

Die Funktion SchreibeListe2() nimmt ein Dictionary als Eingabe entgegen. Genauso wie bei SchreibeListe1() kann die Liste beliebig lang sein. Um auf die einzelnen Werte des Dictionarys zuzugreifen, müssen Sie seine Elemente mit items() verarbeiten.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Sie sehen die Ausgabe aus Abbildung 14.12. Die beiden Listen können eine beliebige Länge haben. Experimentieren Sie mit dem Code ruhig etwas herum, damit Sie verstehen, was er tut. Probieren Sie beispielsweise mal, Zahlen und Strings in der ersten Liste miteinander zu vermischen, und schauen Sie, was passiert. Versuchen Sie auch mal, boolesche Werte hinzuzufügen. Der Punkt ist, dass diese Technik Ihre Methode unglaublich flexibel macht, wenn Sie nur eine Liste mit Werten als Eingabe haben möchten.

Abbildung 14.12: Der Code kann eine beliebige Anzahl an Listeneinträgen verarbeiten.

Operatoren überladen

In manchen Situationen möchten Sie vielleicht eine spezielle Berechnung als Ergebnis eines Standardoperators, wie addiere (+), bekommen. Tatsächlich stellt Python manchmal kein Standardverhalten für Operatoren zur Verfügung, da es keinen Standard zu implementieren hat. Egal was der Grund ist – die Überladung von Operatoren ermöglicht Ihnen die Zuweisung neuer Funktionalität zu existierenden Operatoren, sodass diese das tun, was Sie wollen, und nicht das, was Python beabsichtigt hatte. Die folgenden Schritte erläutern, wie man einen Operator überlädt und in einer Anwendung verwendet. Dieses Beispiel finden Sie in der Datei UeberladeOperator.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile einmal [Enter]:

class MeineKlasse:

def __init__(self,*args):

self.Eingabe = args

def __add__(self, Andere):

Ausgabe = MeineKlasse()

Ausgabe.Eingabe = self.Eingabe + Andere.Eingabe

return Ausgabe

def __str__(self):

Ausgabe = ""

for Element in self.Eingabe:

Ausgabe += Element

Ausgabe += " "

return Ausgabe

Wert1 = MeineKlasse("Rot", "Grün", "Blau")

Wert2 = MeineKlasse("Gelb", "Lila", "Cyan")

Wert3 = Wert1 + Wert2

print("{0} + {1} = {2}"

.format(Wert1,Wert2,Wert3))

Das Beispiel zeigt einige unterschiedliche Techniken. Der Konstruktor, __init__(), zeigt eine Methode zur Erzeugung einer Instanzvariablen, die mit dem Objekt self verknüpft ist. Sie können diese Methode verwenden, um so viele Variablen, wie für die Instanz benötigt, zu definieren.

Wenn Sie Ihre eigenen Klassen definieren, gibt es in den meisten Fällen so lange keinen +-Operator, bis Sie ihn definieren. Es sei denn, Ihre Klasse erbt von einer Klasse, die schon einen +-Operator definiert hat. (Genaueres finden Sie dazu auch im Abschnitt Eine Klasse erweitern, um neue Klassen zu schaffen weiter hinten in diesem Kapitel.) Um zwei Elemente der Klasse MeineKlasse miteinander zu addieren, müssen Sie die Methode __add__() definieren, die den +-Operator implementiert.

Der Code für die Methode __add__() sieht vielleicht etwas langweilig aus, aber Sie sollten ihn Zeile für Zeile anschauen. Der Code erzeugt zuerst ein Objekt der Klasse MeineKlasse, nämlich Ausgabe. Zu diesem Zeitpunkt wird zu Ausgabe noch nichts hinzugefügt – es ist ein leeres Objekt. Die zwei Objekte, self.Eingabe und Andere.Ausgabe, die Sie miteinander addieren wollen, sind Tupel. (Schauen Sie sich den Abschnitt Mit Tupeln arbeiten in Kapitel 13 an, wenn Sie mehr zum Thema Tupel erfahren wollen.) Der Code speichert die Summe dieser zwei Objekte in Ausgabe.Eingabe. Die Methode __add__() gibt dann das neu erzeugte Objekt an den Aufrufer zurück.

Natürlich möchten Sie sicher gerne wissen, warum Sie nicht einfach die beiden Eingaben wie Zahlen miteinander addieren können. Die Antwort ist: Sie bekämen dann ein Tupel anstelle eines Objekts vom Typ MeineKlasse als Ausgabe. Der Typ der Ausgabe hätte sich geändert und das würde auch die Weiterverwendung des Ergebnisses beeinträchtigen (man hätte keinen in sich abgeschlossenen Operator, der verschachtelt verwendet werden kann).

Damit Sie MeineKlasse ordentlich ausgeben können, müssen Sie auch eine Methode __str__() definieren. Diese Methode wandelt ein Objekt der Klasse MeineKlasse in einen String um. Im Beispiel ist die Ausgabe ein mit Leerzeichen begrenzter String (bei dem jedes Element im String von den anderen Elementen durch ein Leerzeichen getrennt wird), der jeden Wert aus self.Eingabe enthält. Die Klasse kann natürlich jeden beliebigen String ausgeben, der das Objekt repräsentieren soll.

Der Hauptausführungsstrang erzeugt zwei Testobjekte, Wert1 und Wert2. Er addiert diese und schreibt das Ergebnis in Wert3. Das Ergebnis wird auf dem Bildschirm ausgegeben.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Abbildung 14.13 zeigt das Ergebnis der Addition der beiden Objekte, die Konvertierung in Strings und die Ausgabe des Ergebnisses. Das ist schon eine Menge Code für eine derart einfache Ausgabeanweisung, aber das Ergebnis zeigt definitiv, dass Sie Klassen erstellen können, die in sich abgeschlossen und voll funktionsfähig sind.

Abbildung 14.13: Wenn man zwei Objekte der Klasse MeineKlasse miteinander addiert, bekommt man als Ergebnis ein Objekt desselben Typs.

Eine Klasse erstellen

Der bisherige Inhalt dieses Kapitels sollte Sie darauf vorbereiten, nun selbst eine interessante Klasse zu schreiben. Im nächsten Beispiel werden Sie eine Klasse schreiben, die Sie in einem externen Modul speichern und auf die Sie mit einer Anwendung zugreifen werden. Listing 14.1 zeigt den Code, den Sie zur Definition dieser Klasse brauchen. Das Beispiel finden Sie in der Datei MeineKlasse.py.

class MeineKlasse:

def __init__(self, Name="Stefan", Alter=36):

self.Name = Name

self.Alter = Alter

def GetName(self):

return self.Name

def SetName(self, Name):

self.Name = Name

def GetAlter(self):

return self.Alter

def SetAlter(self, Alter):

self.Alter = Alter

def __str__(self):

return "{0} ist {1} alt.".format(self.Name,

self.Alter)

Listing 14.1: Eine externe Klasse definieren

In diesem Beispiel wird zunächst ein Objekt mit zwei Instanzvariablen erzeugt: Name und Alter. Sollte der Benutzer diese beiden Werte nicht eingeben, bekommen Sie die Standardwerte Stefan und 36.

Das Beispiel zeigt Ihnen ein neues Feature für eine Klasse. Die meisten Entwickler nennen dieses Feature Zugriffsmethode oder Akzessor. Im Wesentlichen stellt es den Zugriff zu einem Wert einer Instanz zur Verfügung. Es gibt zwei Arten von Zugriffsfunktionen: Getter und Setter. Sowohl GetName() als auch GetAlter() sind Getter. Sie bieten Lesezugriff auf die entsprechenden Werte.

Die Methode SetName() und SetAlter() sind Setter, die Schreibzugriff auf die Werte zur Verfügung stellen. Mit einer Kombination dieser Methoden können Sie Eingaben immer auf ihren korrekten Typ und Wertebereich prüfen und sicherstellen, dass der Aufrufer die nötigen Rechte hat, um die Information anzusehen.

Wie bei fast jeder anderen Klasse, die Sie erstellen, müssen Sie die Methode __str__() definieren, wenn Sie möchten, dass der Benutzer das Objekt ordentlich ausgeben kann. Im Beispiel bietet die Klasse eine formatierte Ausgabe an, die beide Instanzvariablen auflistet.

Die Klasse in einer Anwendung verwenden

Bei der Arbeit mit Python werden Sie die meiste Zeit externe Klassen verwenden. Es kommt nicht oft vor, dass eine Klasse innerhalb der Hauptdatei der Anwendung definiert wird, da die Anwendung ansonsten zu groß und überhaupt nicht wartbar wäre. Außerdem könnte man den Code der Klasse dann nicht in einer anderen Anwendung wiederverwenden. Die folgenden Schritte zeigen Ihnen, wie Sie die Klasse MeineKlasse, die Sie im vorherigen Abschnitt definiert haben, verwenden können. Das Beispiel finden Sie in der Datei MeineKlasseTest.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile einmal [Enter]:

import MeineKlasse

StefansDaten = MeineKlasse.MeineKlasse()

SarasDaten = MeineKlasse.MeineKlasse("Sara", 33)

print(StefansDaten.GetAlter())

StefansDaten.SetAlter(37)

print(SarasDaten.GetName())

SarasDaten.SetName("Sarah")

print(StefansDaten)

print(SarasDaten)

Das Beispiel beginnt mit dem Import des Moduls MeineKlasse. Der Modulname ist der Name der Datei, in der der externe Code gespeichert wurde, nicht der Name der Klasse. Ein Modul kann mehrere Klassen enthalten, daher sollten Sie sich unter einem Modul immer die eigentliche Datei vorstellen, die eine oder mehrere Klassen zur Verwendung in Ihrer Anwendung enthält.

Nachdem das Modul importiert wurde, erzeugt die Anwendung zwei Objekte des Typs MeineKlasse. Beachten Sie, dass Sie zunächst den Modulnamen gefolgt von dem Klassennamen angeben müssen. Das erste Objekt, StefansDaten, verwendet die Standardeinstellungen. Das zweite Objekt, SarasDaten, benutzt die übergebenen Werte. Stefan wurde ein Jahr älter. Nachdem die Anwendung festgestellt hat, dass das Alter aktualisiert werden muss, wird Stefans Alter geändert.

Irgendwie wurde Sarahs Name falsch geschrieben. Nachdem die Anwendung also festgestellt hat, dass der Name falsch ist, passt sie SarasDaten entsprechend an. Im letzten Schritt werden beide Datensätze in ihrer Gänze ausgegeben.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Die Anwendung zeigt eine Reihe von Nachrichten an, während MeineKlasse von ihr ausgetestet wird, wie in Abbildung 14.14 zu sehen. Jetzt kennen Sie alle wichtigen Grundlagen, um hervorragende Klassen zu schreiben.

Abbildung 14.14: Die Ausgabe zeigt, dass die Klasse voll funktionsfähig ist.

Eine Klasse erweitern, um neue Klassen zu schaffen

Sie können sich sicher vorstellen, dass es sehr zeitaufwendig ist, eine voll funktionsfähige, produktionsreife Klasse (eine, die in einer echten Anwendung auf einem System läuft, auf das tatsächlich Benutzer zugreifen) zu erstellen, da richtige Klassen sehr viele Aufgaben erfüllen. Zum Glück unterstützt Python ein Feature, das sich Vererbung nennt. Mit Vererbung können Sie bei der Definition einer Kindklasse die Funktionalität, die Sie von einer Elternklasse haben möchten, übernehmen. Sie können sehr schnell und mit sehr wenig Aufwand Ihrerseits neue Klassen definieren, indem Sie die Funktionalität der Elternklasse, die Sie nicht haben wollen, überschreiben und neue Funktionen hinzufügen. Da der Code der Elternklasse außerdem schon getestet wurde, müssen Sie auch nicht mehr Zeit als nötig damit verbringen, sicherzustellen, dass Ihre neue Klasse wie erwartet funktioniert. Die folgenden Abschnitte zeigen Ihnen, wie Sie Klassen, die voneinander erben, definieren und verwenden können.

Eine Kindklasse schreiben

Elternklassen sind normalerweise Obermengen von etwas. Zum Beispiel können Sie eine Elternklasse Auto schreiben und dann Kindklassen verschiedener Autotypen davon erben lassen. In diesem Beispiel definieren Sie eine Elternklasse Tier und verwenden sie, um eine Kindklasse Huhn zu erstellen. Haben Sie einmal die Elternklasse Tier, können Sie dann natürlich sehr einfach weitere Kindklassen, wie die Klasse Gorilla, definieren. In diesem Beispiel erstellen Sie allerdings nur eine Elternklasse und eine Kindklasse, wie in Listing 14.2 gezeigt. Dieses Beispiel finden Sie in der Datei Tiere.py.

class Tier:

def __init__(self, Name="", Alter=0, Art=""):

self.Name = Name

self.Alter = Alter

self.Art = Art

def GetName(self):

return self.Name

def SetName(self,Name):

self.Name = Name

def GetAlter(self):

return self.Alter

def SetAlter(self,Alter):

self.Alter = Alter

def GetArt(self):

return self.Art

def SetArt(self,Art):

self.Art = Art

def __str__(self):

return "{0} ist ein {1} und {2} Jahre alt.".format (self.Name,

self.Art,

self.Alter)

class Huhn(Tier):

def __init__(self, Name="", Alter = 0):

self.Name = Name

self.Alter = Alter

self.Art = "Huhn"

def SetArt(self,Art):

print("Entschuldigung, {0} wird immer ein {1} bleiben."

.format(self.Name,self.Art))

def GeraeuschMachen(self):

print("{0} sagt gack, gack, gack!"

.format(self.Name))

Listing 14.2: Eine Eltern- und eine Kindklasse schreiben

Die Klasse Tier hat drei Eigenschaften: Name, Alter und Art. Eine richtige Anwendung würde wahrscheinlich noch mehr Eigenschaften verwalten, aber diese Eigenschaften reichen für diese Anwendung völlig aus. Der Code enthält auch die notwendigen Zugriffsmethoden für jede Eigenschaft. Die Methode __str__() vervollständigt die Funktionalität, indem sie eine einfache Nachricht mit den Eigenschaften des Tieres ausgibt.

Die Klasse Huhn erbt von der Klasse Tier. Beachten Sie, wie die Klasse Tier hinter dem Klassennamen Huhn in Klammern angegeben wurde. Dieser Zusatz sagt Python, dass Huhn ein Tier ist, etwas, dass die Eigenschaften von Tier erbt.

Beachten Sie, dass der Konstruktor von Huhn nur Name und Alter als Parameter annimmt. Der Benutzer muss keinen Wert für Art angeben, da Sie ja schon wissen, dass es ein Huhn ist. Dieser neue Konstruktor überschreibt den Konstruktor der Klasse Tier. Die drei Attribute gibt es immer noch, aber Art wird direkt im Huhn-Konstruktor gesetzt.

Jemand könnte nun Schabernack treiben und ein Huhn als Gorilla definieren. Damit das nicht passiert, überschreibt die Klasse Huhn den Setter SetArt(). Wenn nun jemand versucht, die Art des Huhns zu ändern, bekommt der Benutzer eine Meldung angezeigt. Normalerweise würden Sie solche Probleme mit Ausnahmen abhandeln, aber dieses Beispiel benutzt eine Meldung, um die Programmiertechnik klarer zu machen.

Schließlich erhält die Klasse Huhn ein neues Feature, GeraeuschMachen(). Immer, wenn jemand das Geräusch hören möchte, das ein Huhn macht, kann er GeraeuschMachen() aufrufen, um es zumindest auf dem Bildschirm ausgeben zu lassen.

Die Klasse in einer Anwendung testen

Das Testen der Klasse Huhn testet die Klasse Tier in gewissem Maße auch. Manche Funktionalität ist anders, aber manche Klassen sind nicht unbedingt zum Benutzen gedacht. Die Klasse Tier ist nur eine Elternklasse für spezifischere Tierarten, wie das Huhn. Die folgenden Schritte testen die Klasse Huhn, damit Sie verstehen, wie Vererbung funktioniert. Das Beispiel finden Sie in der Datei HuhnTest.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile einmal [Enter]:

import Tiere

MeinHuhn = Tiere.Huhn("Hildegard", 2)

print(MeinHuhn)

MeinHuhn.SetAlter(MeinHuhn.GetAlter() + 1)

print(MeinHuhn)

MeinHuhn.SetArt("Gorilla")

print(MeinHuhn)

MeinHuhn.GeraeuschMachen()

Zunächst wird das Modul Tiere importiert. Denken Sie daran, dass Sie immer den Dateinamen angeben müssen, nicht die Klasse. An der Datei Tiere.py kann man das gut nachvollziehen, da sie zwei Klassen enthält: Tier und Huhn.

Das Beispiel erzeugt ein Huhn, MeinHuhn, mit Namen Hildegard, das zwei Jahre alt ist. Danach benutzt das Beispiel MeinHuhn auf verschiedenste Arten. Zum Beispiel hat Hildegard Geburtstag, also erhöht der Code ihr Alter um 1. Beachten Sie, wie der Code eine Kombination aus Setter, SetAlter(), mit einem Getter, GetAlter(), kombiniert, um die Aufgabe auszuführen. Der Code zeigt nach jeder Änderung das resultierende Objekt für Sie an. Am Ende äußert sich Hildegard noch mit ein paar Worten.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Sie sehen, dass alle Schritte mit MeinHuhn funktionieren wie in Abbildung 14.15. Wie Sie merken, kann Vererbung das Erstellen neuer Klassen wesentlich vereinfachen, wenn es genug gibt, was Sie in eine Elternklasse auslagern können und von den Kindklassen gut wiederverwendet werden kann.

Abbildung 14.15: Hildegard hat Geburtstag und sagt ein paar Worte.

Teil IV

Fortgeschrittene Programmieraufgaben

In diesem Teil . . .

Erzeugen Sie eine Datei.

Lesen Sie eine Datei.

Ändern Sie eine Datei.

Löschen Sie eine Datei.

Versenden Sie eine E-Mail.

15

Daten in Dateien speichern

In diesem Kapitel

Lernen Sie, wie man Daten mit Anwendungen permanent speichert

Entscheiden Sie, wie mit dem permanent gespeicherten
Inhalt verfahren werden soll

Schreiben Sie zum ersten Mal in eine Datei

Holen Sie sich Daten von der Festplatte

Ändern Sie nach Belieben Dateiinhalte

Löschen Sie eine Datei von der Festplatte

Bisher könnte es Ihnen so vorkommen, als wenn Anwendungsentwicklung nur etwas mit der Anzeige von Informationen am Bildschirm zu tun hätte. Aber eigentlich braucht man für Anwendungen auch die Möglichkeit, mit Daten arbeiten zu können. Daten sind der Schwerpunkt jeder Anwendung, da es die Daten sind, die die Benutzer interessieren. Machen Sie sich auf eine herbe Enttäuschung gefasst, wenn Sie eine Anwendung das erste Mal Ihren Benutzern vorstellen und diese nur daran interessiert sind, ob sie dadurch schneller nach einer Präsentation nach Hause kommen. Im Grunde sind die besten Anwendungen unsicht-bar – sie präsentieren Daten aber bestmöglich angelehnt an die Benutzerbedürfnisse.

Setzt man den Schwerpunkt einer Anwendung auf die Daten, ist ihre permanente Speicherung ein ebenfalls wichtiger Punkt. Für die meisten Entwickler spielt sich die Datenspeicherung um ein nicht flüchtiges Speichermedium, wie eine Festplatte, ein Solid State Drive (SSD), Universal-Serial-Bus(USB)-Speichermedium oder irgendeine andere Technik ab. (Sogar Cloud-basierte Lösungen funktionieren gut, aber sie werden in diesem Buch nicht verwendet, da sie andere Programmiertechniken erfordern und über den Rahmen dieses Buches hinausgehen.) Die Daten im Hauptspeicher sind nur temporär, da sie dort nur so lange verbleiben, wie das System läuft. Ein permanentes Speichermedium merkt sich die Daten auch über das Ausschalten des Systems hinaus, sodass sie beim nächsten Gebrauch wieder zur Verfügung stehen.

Neben der permanenten Speicherung beschäftigt sich dieses Kapitel auch mit den vier Grundoperationen, die Sie mit Dateien ausführen können: Erzeugen, Lesen, Aktualisieren und Löschen (Create, Read, Update and Delete, CRUD). Das Akronym CRUD wird in Datenbankkreisen sehr häufig verwendet, passt aber auch auf jede Anwendung. Unabhängig davon, wie Ihre Anwendung die Daten dauerhaft speichert, muss sie diese vier Aufgaben ausführen können, damit sie für den Benutzer eine vollständige Lösung darstellt. Natürlich müssen CRUD-Operationen sicher, verlässlich und kontrolliert ausgeführt werden. Dieses Kapitel erläutert auch die Regeln, wie ein Zugriff stattfinden muss, um Datenintegrität (ein Maß dafür, wie oft Datenfehler vorkommen, wenn CRUD-Operationen ausgeführt werden) sicherzustellen.

Wie die permanente Datenspeicherung funktioniert

Sie brauchen nicht jedes kleine Detail über permanente Datenspeicherung zu wissen, um sie zu benutzen. Es ist zum Beispiel unwichtig, was sich in einem Laufwerk dreht (wenn man annimmt, dass sich etwas dreht). Die meisten Systeme halten sich bei der permanenten Datenspeicherung aber an gewisse Grundprinzipien. Diese Prinzipien haben sich über eine gewisse Zeit entwickelt, beginnend bei den Mainframe-Systemen in der frühen Computergeschichte.

Daten werden in Dateien gespeichert. Sie wissen sicher schon etwas über Dateien, da jede nützliche Anwendung da draußen Dateien verwendet. Öffnen Sie beispielsweise ein Dokument in Ihrem Textverarbeitungsprogramm, öffnen Sie eigentlich eine Datendatei, die die Wörter, die Sie oder jemand anders eingegeben haben, enthält.

Dateien haben normalerweise eine Dateierweiterung, die den Dateityp angibt. Die Erweiterung ist im Allgemeinen für jede Anwendung standardisiert und wird vom Dateinamen durch einen Punkt getrennt, wie MeineDaten.txt. In diesem Fall ist .txt die Dateierweiterung und wahrscheinlich haben Sie auf Ihrem Computer eine Anwendung, mit der Sie solche Dateien öffnen können. Da die Dateierweiterung .txt sehr verbreitet ist, gibt es sogar eine sehr große Auswahl an Anwendungen, die das können.

Intern strukturieren Dateien die Daten auf bestimmte Art und Weise, um die Daten einfach aus der Datei lesen und in sie hineinschreiben zu können. Jede von Ihnen geschriebene Anwendung muss die Dateistruktur kennen, um mit den Daten in der Datei arbeiten zu können. Die Beispiele dieses Kapitels verwenden eine sehr einfache Dateistruktur, damit der Code für den Zugriff darauf einfach bleibt, aber Dateistrukturen können auch sehr komplex werden.

Dateien wären nahezu unauffindbar, wenn Sie sie alle am selben Ort auf der Festplatte speichern würden. Daher kann man Dateien in Verzeichnissen verwalten. Neuere Computersysteme verwenden auch den Begriff Ordner für diese Strukturierungshilfe im permanenten Speicher. Egal, wie Sie es nennen, die permanente Datenspeicherung verwendet Verzeichnisse, um Daten zu strukturieren und die einzelnen Dateien schneller auffindbar zu machen. Damit Sie eine bestimmte Datei finden, öffnen und damit arbeiten können, müssen Sie wissen, in welchem Verzeichnis sie liegt.

Verzeichnisse sind hierarchisch angelegt und beginnen auf der obersten Ebene der Festplatte. Sie finden zum Beispiel den Quellcode des gesamten Buches im Verzeichnis MPplfD. Dieses Verzeichnis enthält jedoch keine Quellcodedateien. Damit Sie die richtige Datei finden, müssen Sie in MPplfD zuerst eines der Kapitelverzeichnisse öffnen. Um die Beispieldateien für dieses Kapitel zu finden, müssen Sie im Verzeichnis MPplfD\Kapitel15 nachschauen.

Beachten Sie, dass ich einen Backslash (\) verwendet habe, um die Verzeichnisebenen voneinander zu trennen. Manche Systeme verwenden den Schrägstrich (/), andere wiederum den Backslash. Das Buch verwendet, wo benötigt, Backslashes und nimmt an, dass Sie Änderungen Ihrem System entsprechend vornehmen.

Ein letztes Konzept, das Python-Entwickler kennen sollten (zumindest für dieses Buch), ist der Pfad, der eine Hierarchie aus Verzeichnissen darstellt. Der Begriff Pfad wird in diesem Buch ab und zu gebraucht, da Python auf Basis eines von Ihnen angegebenen Pfades in der Lage sein muss, jede beliebige Ressource zu finden. Zum Beispiel ist C:\MPplfD\Kapitel15 der vollständige Pfad zum Quellcode dieses Kapitels auf einem Windows-System. Ein Pfad, den Python komplett von der Wurzel bis zur Datei verfolgen muss, wird absoluter Pfad genannt. Ein unvollständiger Pfad, der als Startpunkt ein aktuelles Verzeichnis und als Endpunkt die Datei hat, wird relativer Pfad genannt.

Daten für die permanente Speicherung erstellen

Eine Datei kann strukturierte oder unstrukturierte Daten enthalten. Ein Beispiel für strukturierte Daten ist eine Datenbank, in der jeder Datensatz eigene Informationen enthält. Eine Datenbank für Angestellte hätte Spalten für den Namen, die Adresse, eine Angestelltennummer und so weiter. Jeder Datensatz würde einen individuellen Angestellten repräsentieren und jeder Angestelltendatensatz würde die Felder für den Namen, die Adresse und die Angestelltennummer enthalten. Ein Beispiel für unstrukturierte Daten ist eine Textverarbeitungsdatei, die jeden beliebigen Text in beliebiger Ordnung enthalten kann. Es gibt keine vorgeschriebene Reihenfolge für den Inhalt eines Absatzes und die Sätze können eine beliebige Anzahl an Wörtern enthalten. Sowohl für unstrukturierte als auch für strukturierte Daten muss die Anwendung aber wissen, wie sie für die Datei CRUD-Operationen ausführt. Das heißt, der Inhalt muss so aufbereitet sein, dass die Anwendung die Datei sowohl schreiben als auch lesen kann.

Auch bei Textverarbeitungsdateien muss der Text jedoch gewissen Regeln folgen. Nehmen wir für einen Moment an, dass die Dateien einfach nur aus Text bestehen. Auch da muss jeder Absatz irgendein Trennzeichen haben, das der Anwendung mitteilt, dass hier ein neuer Absatz beginnt. Die Anwendung liest dann den Absatz, bis sie das Trennzeichen findet, und fängt dann einen neuen Absatz an. Je mehr Funktionalität die Textverarbeitung anbietet, desto strukturierter wird auch die Ausgabe. Bietet das Textverarbeitungsprogramm beispielsweise eine Methode zur Formatierung von Text an, muss die Formatierung auch als Teil der Ausgabedatei erscheinen.

Die Verweise, die den Inhalt für die permanente Speicherung verwendbar machen, sind manchmal nicht offensichtlich. Alles, was Sie sehen, wenn Sie mit der Datei arbeiten, sind die Daten selbst. Die Formatierung bleibt aus vielen Gründen, wie den folgenden, verborgen:

Der Verweis ist ein Steuerzeichen, wie ein Zeilenumbruch oder ein Zeilenvorschub, der normalerweise auf Systemebene nicht sichtbar ist.

Die Anwendung verwendet spezielle Zeichenkombinationen, wie Kommas oder doppelte Anführungsstriche, um Dateneinträge zu separieren. Diese speziellen Zeichenkombinationen werden von der Anwendung beim Lesen der Datei verarbeitet.

Ein Teil des Leseprozesses wandelt die Zeichen in eine andere Form um, zum Beispiel, wenn ein Textverarbeitungsprogramm formatierten Inhalt aus einer Datei ausliest. Die Formatierung erscheint auf dem Bildschirm, aber im Hintergrund enthält die Datei Sonderzeichen, um die Formatierung anzugeben.

Die Datei liegt eigentlich in einem anderen Format vor, wie der eXtensible Markup Language (XML) (nähere Informationen zu XML finden Sie unter http://www.w3schools.com/xml/default.asp). Das Format wird interpretiert, übersetzt und so am Bildschirm angezeigt, dass der Benutzer es verstehen kann.

Es gibt natürlich noch andere Regeln für die Formatierung von Daten. Zum Beispiel verwendet Microsoft eine .zip-Datei, um seine Textverarbeitungsdateien (.docx) zu speichern. Die Verwendung eines komprimierten Dateikatalogs, wie .zip, ermöglicht die Speicherung vieler Informationen auf kleinstem Raum. Es ist gut, sich anzuschauen, wie andere Leute Daten speichern, damit Sie sich effizientere und sichere Methoden für Ihre eigene Anwendung abgucken können.

Da Sie nun eine bessere Vorstellung davon haben, was Teil der Vorbereitungen für die permanente Speicherung von Daten sein könnte, wird es Zeit, sich ein Beispiel anzuschauen. In diesem Beispiel ist die Formatierungsstrategie sehr einfach. Das Einzige, was dieses Beispiel tut, ist, eine Eingabe entgegenzunehmen, für die Speicherung zu formatieren und die formatierte Form auf dem Bildschirm auszugeben. Den Quellcode dieses Beispiels finden Sie in den Dateien FormatierteDaten.py und FormatierteDatenTest.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

class DatenFormatieren:

def __init__(self, Name="", Alter=0, Verheiratet=False):

self.Name = Name

self. Alter = Alter

self.Verheiratet = Verheiratet

def __str__(self):

AusgabeStr = "´{0}´; {1}; {2}".format(

self.Name,

self.Alter,

self.Verheiratet)

return AusgabeStr

Dies ist eine verkürzte Klasse. Normalerweise würden Sie noch Zugriffsfunktionen (Getter- und Setter-Methoden) und Fehlerbehandlungscode definieren. (Zur Erinnerung: Getter-Methoden stellen den Lesezugriff und Setter-Methoden den Schreibzugriff auf Klassendaten zur Verfügung.) Zu Demonstrationszwecken reicht die Klasse aber so völlig aus.

Das hauptsächlich Interessante an dieser Klasse ist die Funktion __str__(). Beachten Sie, dass sie die Ausgabe ganz speziell formatiert. Der Wert des Strings self.Name ist mit einfachen Anführungsstrichen umgeben. Die Werte werden zusätzlich jeweils durch ein Semikolon getrennt. Dies entspricht einem standardisierten Ausgabeformat, das sich Comma-Separated Value (CSV) nennt und auf vielen Systemen verwendet wird, da es einfach zu verstehen ist und normalen Text verwendet, sodass man recht einfach damit arbeiten kann.

Eigentlich bedeutet Comma-Separated Value, dass die Werte eines Datensatzes jeweils mit einem Komma getrennt werden. Es können aber auch andere Trennzeichen verwendet werden, wie im Beispiel das Semikolon. Je nach Ländereinstellungen, System und Programm, mit dem man die Datei öffnet, kann ein anderes Trennzeichen gültig sein.

3. Speichern Sie den Code in der Datei FormatierteDaten.py.

4. Öffnen Sie ein weiteres Python-Editierfenster.

5. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

from FormatierteDaten import DatenFormatieren

NeueDaten = [DatenFormatieren("Stefan", 37, False),

DatenFormatieren("Sara", 33, True),

DatenFormatieren("Daniel", 37, True)]

for Eintrag in NeueDaten:

print(Eintrag)

Der Code importiert zunächst nur die Klasse DatenFormatieren aus der Datei FormatierteDaten. Hier ist das eigentlich nicht so wichtig, da die Datei nur eine einzige Klasse enthält. Sie sollten diese Importmethode jedoch im Hinterkopf behalten, wenn Sie aus einem Modul nur eine Klasse benötigen.

Meistens werden Sie mit mehreren Datensätzen arbeiten, wenn Sie Daten auf Festplatte speichern. Sie haben vielleicht mehrere Absätze in einer Textverarbeitungsdatei oder eben mehrere Datensätze, wie in diesem Beispiel. Das Beispiel erzeugt eine Liste mit Datensätzen und speichert sie in NeueDaten. Im Beispiel repräsentiert NeueDaten ein ganzes Dokument. Die Repräsentation wird in einer echten Anwendung sicherlich anders aussehen, aber das Konzept bleibt dasselbe.

Jede Anwendung, die Daten speichert, durchläuft irgendeine Ausgabeschleife. Im Beispiel gibt die Schleife einfach die Daten auf dem Bildschirm aus. In den nächsten Abschnitten werden Sie die Daten aber in eine Datei ausgeben.

6. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Sie sehen die Ausgabe aus Abbildung 15.1. Dies ist ein Beispiel dafür, wie die Daten in der Datei aussehen würden. Im Beispiel wird jeder Datensatz durch eine Kombination aus Zeilenumbruch und Zeilenvorschub getrennt. Das bedeutet Stefan, Sara und Daniel sind alles einzelne Datensätze in der Datei. Die Felder (Datenelemente) werden durch Semikolons voneinander getrennt. Textfelder erscheinen in Anführungsstrichen, sodass man sie nicht mit anderen Datentypen verwechseln kann.

Abbildung 15.1: Das Beispiel zeigt, wie die Daten im CSV-Format aussehen.

Eine Datei erstellen

Alle Daten, die der Benutzer erzeugt und mit denen er mehr als eine Sitzung lang arbeiten möchte, müssen irgendwie auch in einem nicht-flüchtigen Medium gespeichert werden. Das Erstellen einer Datei und das anschließende Speichern von Daten darin ist ein wichtiger Bestandteil der Arbeit mit Python. Mit den folgenden Schritten können Sie Code programmieren, der Daten auf die Festplatte schreibt. Den Code für dieses Beispiel finden Sie in den Dateien FormatierteDaten.py und CSVErstellen.py.

1. Öffnen Sie die zuvor gespeicherte Datei FormatierteDaten.py.

Am Bildschirm erscheint der Code, den Sie zuvor im Abschnitt Daten für die permanente Speicherung erstellen dieses Kapitels geschrieben haben. Dieses Beispiel ändert den ursprünglichen Code so, dass die Klasse nun eine Datei auf Festplatte speichern kann.

2. Geben Sie die folgende import-Anweisung am Anfang der Datei ein:

import csv

Das Modul csv enhält alles, was man braucht, um mit CSV-Dateien zu arbeiten.

Python unterstützt von sich aus schon sehr viele Dateitypen und es gibt Bibliotheken, die noch weitere zur Verfügung stellen. Wenn Sie unter Python mit einem bestimmten Dateityp arbeiten wollen und Python die Bibliothek nicht schon mitbringt, gibt es normalerweise immer eine Bibliothek eines Drittanbieters. Leider gibt es keine umfassende Liste aller unterstützten Dateitypen, sodass Sie im Internet suchen müssen, ob und wie Python den Dateityp unterstützt, den Sie gerade benötigen. Die Dokumentation kategorisiert die unterstützten Dateien und bietet keine vollständige Liste an. Sie finden zum Beispiel alle Archivformate unter https://docs.python.org/3/library/archiving.html und verschiedene andere Dateiformate unter https://docs.python.org/3/library/fileformats.html.

3. Geben Sie den folgenden Code unter dem schon existierenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

def DatenSpeichern(Dateiname = "", DatenListe = []):

with open(Dateiname,

"w", newline=´\n´) as csvdatei:

DataWriter = csv.writer(

csvdatei,

delimiter=´\n´,

quotechar=" ",

quoting=csv.QUOTE_NONNUMERIC)

DataWriter.writerow(DatenListe)

csvdatei.close()

print("Daten gespeichert!")

Stellen Sie auf jeden Fall sicher, dass DatenSpeichern() korrekt eingerückt ist. Wenn Sie DatenSpeichern() in die Datei einfügen, aber nicht unter der Klasse DatenFormatieren einrücken, wird Python die Funktion als separate Funktion und nicht als Teil von DatenFormatieren behandeln. Die einfachste Methode, um DatenSpeichern() korrekt einzurücken, ist, dieselbe Einrückung zu benutzen, die schon bei den Funktionen __init__() und __str__() verwendet wurde.

Beachten Sie, dass die Methode zwei Eingabeparameter hat: einen Dateinamen, unter dem die Daten gespeichert werden, und eine Liste mit Elementen, die gespeichert werden sollen. DatenSpeichern ist eher eine Klassenmethode als eine Instanzmethode. Sie werden etwas später sehen, warum die Verwendung einer Klassenmethode hier vorteilhaft ist. Der Parameter DatenListe hat als Standardwert eine leere Liste. Sollte der Aufrufer für diesen Parameter nichts übergeben, würde die Methode keine Ausnahme erzeugen. Stattdessen würde eine leere Ausgabedatei erstellt. Natürlich könnten Sie, wenn gewünscht, auch Code schreiben, der eine leere Liste als Fehler behandelt und dementsprechend reagiert.

Die with-Anweisung sagt Python, dass es eine Reihe von Aufgaben mit einer bestimmten Ressource ausführen soll – hier eine offene csvdatei namens Testdatei.csv. Die Funktion open() nimmt, je nachdem, wie Sie sie benutzen, eine bestimmte Anzahl an Parametern entgegen. In diesem Beispiel öffnen Sie die Datei im Schreibmodus (gekennzeichnet durch das w, das für write, also Schreiben, steht). Das Attribut newline teilt Python mit, dass es das Steuerzeichen \n (Zeilenvorschub) als Zeichen für eine neue Zeile behandeln soll.

Um etwas als Ausgabe zu schreiben, brauchen Sie ein Writer-Objekt. Das Objekt Data Writer ist so konfiguriert, dass es csvdatei als Ausgabedatei verwendet, \n als Trennzeichen für die Datensätze, um sie mit einem Leerzeichen auszuzeichnen und nur nicht-numerische Werte speziell auszuzeichnen (also zum Beispiel in Anführungsstriche zu setzen). Diese Konfiguration wird später noch sehr interessant werden. Für den Moment können Sie aber einfach davon ausgehen, dass das alles ist, was Sie für eine brauchbare Ausgabe benötigen.

Das Schreiben der Daten ist weniger Aufwand, als Sie vielleicht denken. Ein einzelner Aufruf von DataWriter.writerow() mit DatenListe als Eingabe ist alles, was Sie brauchen. Schließen Sie die Datei immer mit close(), wenn Sie sie nicht mehr brauchen. Diese Aktion stellt sicher, dass die Daten auf der Festplatte gespeichert werden. Der Code endet mit der Ausgabe, dass die Daten erfolgreich gespeichert wurden.

4. Speichern Sie den Code in der Datei FormatierteDaten.py.

5. Öffnen Sie ein neues Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

6. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

from FormatierteDaten import DatenFormatieren

NeueDaten = [DatenFormatieren("Stefan", 37, False),

DatenFormatieren("Sara", 33, True),

DatenFormatieren("Daniel", 37, True)]

DatenFormatieren.DatenSpeichern("Testdatei.csv", NeueDaten)

Dieses Beispiel sollte so ähnlich aussehen wie das, das Sie im Abschnitt Daten für die permanente Speicherung erstellen weiter vorne im Kapitel geschrieben haben. Sie erstellen NeueDaten immer noch als Liste. Statt aber die Informationen auf dem Bildschirm auszugeben, speichern Sie sie mit einem Aufruf von DatenFormatieren.DatenSpeichern() in einer Datei. Dies wäre nun eine Situation, in der das Verwenden einer Instanzmethode eher hinderlich wäre. Um eine Instanzmethode verwenden zu können, müssten Sie zunächst eine Instanz von DatenFormatieren erzeugen, die ansonsten keinen weiteren Zweck hätte.

7. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Die Anwendung wird ausgeführt und Sie bekommen eine Meldung, dass die Daten gespeichert wurden. Natürlich sagt Ihnen das erstmal überhaupt nichts über die Daten selbst. Im Ordner, in dem sich auch der Quellcode befindet, finden Sie nun eine Datei Testdatei.csv. Die meisten Systeme haben eine Standardanwendung, mit der Sie solche Dateien öffnen können. In Windows können Sie sie zum Beispiel mit Excel oder WordPad öffnen. Abbildung 15.2 zeigt die Ausgabedatei in Excel und Abbildung 15.3, wie die Datei in WordPad aussieht. In beiden Fällen sieht die Ausgabe der aus Abbildung 15.1 überraschend ähnlich.

Abbildung 15.2: Die Ausgabe der Anwendung in Excel

Abbildung 15.3: Die Ausgabe der Anwendung in WordPad

Dateiinhalte lesen

Ab diesem Zeitpunkt sind die Daten nun auf der Festplatte gespeichert. Klar sind sie dort gut und sicher untergebracht, aber dort sind sie erst einmal nicht besonders nützlich, wenn Ihre Anwendung nicht darauf zugreifen kann. Damit Sie auf die Daten zugreifen können, müssen Sie sie in den Hauptspeicher laden und dann etwas damit machen. Die folgenden Schritte zeigen Ihnen, wie Sie Daten von der Festplatte lesen und in den Hautspeicher laden, damit Sie sie auf dem Bildschirm ausgeben können. Den Quellcode für dieses Beispiel finden Sie in den Dateien FormatierteDaten.py und CSVLesen.py.

1. Öffnen Sie die zuvor gespeicherte Datei FormatierteDaten.py.

Sie sehen den Code, den Sie ursprünglich in dem Abschnitt Eine Datei erstellen weiter vorne in diesem Kapitel geschrieben haben. Dieses Beispiel ändert den ursprünglichen Code so ab, dass die Klasse auch Daten von der Festplatte lesen kann.

2. Geben Sie den folgenden Code unter dem schon existierenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

def DatenLesen(Dateiname = ""):

with open(Dateiname,

"r", newline=´\n´) as csvdatei:

DataReader = csv.reader(

csvdatei,

delimiter="\n",

quotechar=" ",

quoting=csv.QUOTE_NONNUMERIC)

Ausgabe = []

for Element in DataReader:

Ausgabe.append(Element[0])

csvdatei.close()

print("Daten gelesen!")

return Ausgabe

Wie auch beim Beispiel zuvor sollten Sie hier nochmals prüfen, ob Sie DatenLesen() richtig eingerückt haben. Wenn Sie DatenLesen zur Datei hinzufügen, aber die Methode nicht unter der Klasse DatenFormatieren eingerückt haben, nimmt Python an, dass es sich dabei um eine separate Funktion und nicht um einen Teil der Klasse handelt. Nehmen Sie sich bei der Einrückung einfach ein Beispiel an den Funktionen __init__() und __str__().

Das Öffnen einer Datei unterscheidet sich beim Lesen nicht sonderlich davon, wie Sie die Datei beim Schreiben öffnen würden. Der größte Unterschied besteht darin, dass Sie ein r (für read, also Lesen) statt des w (für write) im Konstruktor csv.reader() angeben müssen. Die anderen Parameter sind genau gleich und funktionieren auch gleich.

Wichtig ist, dass Sie begreifen, dass Sie bei csv-Dateien eigentlich mit Textdateien arbeiten. Klar stehen da Trennzeichen drin, aber es ist immer noch Text. Wenn der Text in den Hauptspeicher geladen wird, müssen Sie die Datenstruktur in Python wiederherstellen. In diesem Beispiel ist Ausgabe am Anfang eine leere Liste.

Die Datei enthält derzeit drei Datensätze, die durch das Steuerzeichen \n getrennt sind. Python liest jeden Datensatz mit einer for-Schleife ein. Beachten Sie die merkwürdige Verwendung von Element[0]. Wenn Python den Datensatz liest, betrachtet es zunächst die Einträge, die nicht ganz am Ende der Datei stehen, als jeweils zwei Listeneinträge. Der erste Eintrag enthält die Daten; der zweite ist leer. Sie wollen nur den ersten Eintrag. Diese Einträge werden an Ausgabe angehängt, sodass Sie am Ende eine vollständige Liste der Datensätze aus der Datei haben.

Auch in diesem Beispiel sollten Sie am Ende die Datei mit close() schließen. Die Methode gibt am Ende eine Meldung aus, dass die Daten gelesen wurden. Sie gibt dann Ausgabe (eine Liste mit Datensätzen) an den Aufrufer zurück.

3. Speichern Sie den Code als FormatierteDaten.py.

4. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

5. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

from FormatierteDaten import DatenFormatieren

NeueDaten = DatenFormatieren.DatenLesen("Testdatei.csv")

for Eintrag in NeueDaten:

print(Eintrag)

Der Code der Datei CSVLesen.py importiert zunächst die Klasse DatenFormatieren. Er erzeugt dann mit dem Aufruf von DatenFormatieren.DatenLesen() das Objekt NeueDaten, eine Liste. Beachten Sie, dass auch hier die Verwendung einer Klassenmethode Sinn macht, da es den Code kürzer und einfacher macht. Die Anwendung verwendet dann eine for-Schleife, um den Inhalt von NeueDaten auszugeben.

6. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Sie sehen die Ausgabe aus Abbildung 15.4. Beachten Sie, dass diese Ausgabe so ähnlich wie die Ausgabe in Abbildung 15.1 aussieht, obwohl die Daten in eine Datei gespeichert und von dort wieder ausgelesen wurden. So sollen Anwendungen funktionieren, die Daten schreiben und lesen. Die Daten sollen beim Auslesen aus der Datei genauso aussehen, wie Sie sie hineingeschrieben haben. Andernfalls ist die Anwendung fehlerhaft, da sie die Daten verändert hat.

Abbildung 15.4: Die Daten, nachdem sie durch die Anwendung verarbeitet wurden

Dateiinhalte aktualisieren

Manche Entwickler denken, dass das Bearbeiten einer Datei etwas sehr Kompliziertes ist. Es kann kompliziert sein, wenn man es als eine einzige Aufgabe betrachtet. Aber eigentlich besteht das Aktualisieren aus drei Tätigkeiten:

1. Dateiinhalt in den Hauptspeicher laden

2. Bearbeiten der temporären Daten im Speicher

3. Das Ergebnis dauerhaft (auf die Festplatte) speichern

In den meisten Anwendungen kann man den zweiten Schritt des Bearbeitens der Daten noch weiter aufspalten. Eine Anwendung kann manche oder alle der folgenden Aufgaben als Teil des Bearbeitungsprozesses zur Verfügung stellen:

Ausgabe der Daten auf dem Bildschirm

Datenliste um weitere Daten ergänzen

Daten aus der Datenliste löschen

Änderungen an existierenden Daten vornehmen, was eigentlich durch Hinzufügen eines neuen Datensatzes mit den geänderten Daten und Löschen des alten Datensatzes umgesetzt werden kann

Bisher haben Sie in diesem Kapitel alle diese Aktivitäten bis auf eine ausgeführt. Sie haben schon Dateiinhalt gelesen und geschrieben. In der Änderungsliste haben Sie schon Daten zu einer Liste hinzugefügt und Daten am Bildschirm angezeigt. Die einzige interessante Tätigkeit, die Sie noch nicht gemacht haben, ist das Löschen von Daten aus einer Liste. Die Änderung von Daten wird oft als ein zweiteiliger Prozess ausgeführt, in dem zunächst ein neuer Datensatz basierend auf den alten Daten angelegt wird und dann der alte Datensatz gelöscht wird, nachdem der neue Datensatz in der Liste steht.

Glauben Sie bitte nicht, dass Sie jede Aktivität in diesem Abschnitt für jede Anwendung ausführen müssen. Ein Monitoring-Werkzeug müsste zum Beispiel keine Daten auf dem Bildschirm ausgeben. Tatsächlich wäre das wahrscheinlich schlecht (oder zumindest umständlich). Ein Datenlogger erzeugt nur neue Einträge – er löscht oder verändert Einträge nicht. Eine E-Mail-Anwendung lässt normalerweise das Hinzufügen neuer Einträge und das Löschen alter Einträge, aber nicht das Ändern von Einträgen zu. Ein Textverarbeitungsprogramm implementiert wiederum die gesamte erwähnte Funktionalität. Was und wie Sie es implementieren, hängt ganz von der von Ihnen geschriebenen Anwendung ab.

Die Trennung von Benutzerschnittstelle und den Dingen, die hinter der Benutzerschnittstelle vor sich gehen, ist sehr wichtig. Das folgende Beispiel legt der Einfachheit halber den Schwerpunkt auf die Dinge hinter der Benutzerschnittstelle, um Änderungen an der Datei aus dem Abschnitt Eine Datei erstellen vorzunehmen. Die folgenden Schritte zeigen, wie eine Datei gelesen, geändert und geschrieben wird, um sie zu aktualisieren. Die Aktualisierungen umfassen einen Zusatz, eine Löschung und eine Änderung. Damit Sie die Anwendung mehr als einmal ausführen können, werden die Änderungen in einer anderen Datei gespeichert. Den Quellcode für dieses Beispiel finden Sie in den Dateien FormatierteDaten.py und CSV Aktualisieren.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

from FormatierteDaten import DatenFormatieren
import os.path

if not os.path.isfile("Testdatei.csv"):

print("Bitte führen Sie das Beispiel in CSVErstellen.py aus!")

quit()

NeueDaten = DatenFormatieren.DatenLesen("Testdatei.csv")

for Eintrag in NeueDaten:

print(Eintrag)

print("\r\nHinzufügen eines Eintrags für Frank.")

NeuerDatensatz = "´Frank´; 42; False"

NeueDaten.append(NeuerDatensatz)

for Eintrag in NeueDaten:

print(Eintrag)

print("\r\nEntferne Daniels Eintrag.")

Position = NeueDaten.index("´Daniel´; 37; True")

Datensatz = NeueDaten[Position]

NeueDaten.remove(Datensatz)

for Eintrag in NeueDaten:

print(Eintrag)

print("\r\nÄndere Saras Eintrag.")

Position = NeueDaten.index("´Sara´; 33; True")

Datensatz = NeueDaten[Position]

Split = Datensatz.split(";")

NeuerDatensatz = DatenFormatieren(Split[0].replace("´", ""),

int(Split[1]),

bool(Split[2]))

NeuerDatensatz.Verheiratet = False

NeuerDatensatz.Alter = 34

NeueDaten.append(NeuerDatensatz.__str__())

NeueDaten.remove(Datensatz)

for Eintrag in NeueDaten:

print(Eintrag)

DatenFormatieren.DatenSpeichern("GeänderteDatei.csv", NeueDaten)

In diesem Beispiel passiert eine Menge. Es prüft zunächst, dass die Datei Testdatei.csv tatsächlich zur Bearbeitung existiert. Sie sollten diese Prüfung immer ausführen, wenn Sie darauf angewiesen sind, dass eine Datei vorhanden ist. In diesem Beispiel erzeugen Sie keine neue Datei, sondern verändern eine existierende Datei, also muss die Datei auch vorhanden sein. Existiert die Datei nicht, wird die Anwendung beendet.

Im nächsten Schritt werden die Daten aus der Datei in NeueDaten ausgelesen. Dieser Teil des Prozesses funktioniert genauso wie im Datenlesen-Beispiel weiter vorne in diesem Kapitel.

Sie haben in Kapitel 12 schon Code zur Arbeit mit Listenfunktionen kennengelernt. Dieses Beispiel verwendet diese Funktionen, um wichtige Aufgaben im Beispiel zu erledigen. Die Funktion append() fügt einen neuen Eintrag zu NeueDaten hinzu. Beachten Sie aber, dass die Daten als String hinzugefügt werden, nicht als Objekt vom Typ DatenFormatieren. Die Daten werden als Strings in der Datei gespeichert und das bekommen Sie als Rückgabe, wenn Sie die Daten wieder auslesen. Sie können die neuen Daten entweder als String hinzufügen oder ein Objekt vom Typ DatenFormatieren erzeugen und dann die Methode __str__() verwenden, um die Daten als String ausgeben zu lassen.

Im nächsten Schritt wird ein Datensatz aus NeueDaten entfernt. Um diese Aufgabe zu erledigen, müssen Sie zunächst den Datensatz finden. Natürlich ist das einfach, wenn man nur vier Datensätze hat (denken Sie daran, dass es nun einen neuen Datensatz für Frank gibt). Aber bei einer großen Menge Datensätze müssen Sie den Datensatz zunächst mit der Funktion index() heraussuchen. Die Funktion gibt Ihnen eine Zahl zurück, die die Position des Datensatzes in der Liste angibt, mit der Sie dann den eigentlichen Datensatz heraussuchen können. Nachdem Sie sich den eigentlichen Datensatz besorgt haben, können Sie diesen mit der Funktion remove() entfernen.

Die Änderung von Saras Datensatz sieht erst einmal ziemlich kompliziert aus, aber der Hauptteil dieses Codes befasst sich nur mit der Speicherung von Strings auf der Festplatte. Wenn Sie sich den Datensatz aus NeueDaten heraussuchen, bekommen Sie einen einfachen String mit allen drei Werten. Die Funktion split() erzeugt eine Liste, die diese drei Werte als Strings enthält, womit die Anwendung immer noch nichts anfangen kann. Außerdem ist Saras Name sowohl in doppelte als auch einfache Anführungsstriche eingeschlossen.

Die einfachste Methode, mit dem Datensatz zu arbeiten, ist, ein DatenFormatieren-Objekt zu erzeugen und jeden der Strings in das geeignete Format zu bringen. Das bedeutet, dass die zusätzlichen Anführungsstriche aus dem Namen entfernt werden müssen, der zweite Wert in einen Integer und der dritte Wert in einen booleschen Wert umgewandelt wird. Die Klasse DatenFormatieren stellt keine Zugriffsmethoden zur Verfügung, also ändert die Anwendung die Felder Verheiratet und Alter direkt. Die Verwendung von Zugriffsmethoden (Getter-Methoden für den Lesezugriff und Setter-Methoden für den Schreibzugriff) sind eine saubere Lösung.

Die Anwendung fügt dann den neuen Datensatz hinzu und entfernt den alten Datensatz aus NeueDaten. Beachten Sie, wie der Code NeueDaten.__str__() einsetzt, um aus dem Objekt DatenFormatieren des neuen Datensatzes den gewünschten String zu machen.

Schließlich müssen die Änderungen gespeichert werden. Normalerweise würden Sie die Änderungen in dieselbe Datei speichern. Dieses Beispiel speichert die Daten aber in eine andere Datei, damit Sie sich die alten und die neuen Daten anschauen können.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Die Ausgabe aus Abbildung 15.5 erscheint. Beachten Sie, dass die Anwendung die Datensätze nach jeder Änderung ausgibt, damit Sie den aktuellen Zustand von NeueDaten verfolgen können. Das ist eine sehr nützliche Methode zur Fehlersuche in einer Anwendung. Aber natürlich sollten Sie den Code zur Anzeige vor dem Produktivsetzen der Anwendung entfernen.

Abbildung 15.5: Die Anwendung zeigt sofort jede Änderung an.

4. Öffnen Sie die Datei GeänderteDatei.csv mit einer geeigneten Anwendung.

Sie sehen eine Ausgabe ähnlich der in Abbildung 15.6. Die Ausgabe wird mit WordPad angezeigt, aber die Daten ändern sich nicht, wenn Sie eine andere Anwendung verwenden. Sollte Ihr Bildschirm also nicht genauso wie in Abbildung 15.6 aussehen, sollten Sie trotzdem dieselben Daten sehen.

Abbildung 15.6: Die geänderten Daten erscheinen in der Datei GeänderteDatei.csv wie erwartet.

Eine Datei löschen

Der vorherige Abschnitt Dateiinhalte aktualisieren dieses Kapitels erklärt, wie Datensätze in einer Datei hinzugefügt, geändert und gelöscht werden. Es wird aber auch der Punkt kommen, an dem Sie eine Datei löschen müssen. Die folgenden Schritte zeigen Ihnen, wie Sie Dateien, die Sie nicht mehr brauchen, löschen können. Das Beispiel finden Sie in der Datei CSVLöschen.py.

1. Öffnen Sie ein Python-Editierfenster.

Es erscheint ein Editor, in den Sie den Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

import os

os.remove("GeänderteDatei.csv")

print("Datei gelöscht!")

Diese Aktion sieht sehr simpel aus und das ist sie auch. Sie müssen lediglich os.remove() mit dem richtigen Dateinamen und Pfad (wie es gerade gebraucht wird. Python sucht zuerst im aktuellen Verzeichnis, sodass Sie keinen Pfad angeben müssen, wenn die zu löschende Datei im aktuellen Verzeichnis ist) aufrufen, um eine Datei zu löschen. Die Einfachheit, mit der Sie diese Aufgabe erledigen können, ist fast schon beängstigend. Daher ist es gut, wenn Sie ein paar Sicherheitsvorkehrungen treffen. Wenn Sie noch andere Dinge entfernen möchten, sollten Sie die folgenden Funktionen kennen:

• os.rmdir(): Entfernt das angegebene Verzeichnis. Das Verzeichnis muss leer sein, andernfalls zeigt Python eine Fehlermeldung an.

• shutil.rmtree(): Entfernt das angegebene Verzeichnis, alle Unterverzeichnisse und alle Dateien. Diese Funktion ist sehr gefährlich, da es alles ohne Überprüfung entfernt (Python nimmt an, dass Sie wissen, was Sie tun). Daher können Ihnen leicht Daten verloren gehen, wenn Sie diese Funktion verwenden.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Die Anwendung zeigt die Nachricht Datei gelöscht! an. Wenn Sie in dem Verzeichnis, in dem ursprünglich die Datei GeänderteDatei.csv lag, nachschauen, werden Sie feststellen, dass die Datei verschwunden ist.

16

Eine E-Mail versenden

In diesem Kapitel

Definieren Sie eine Reihe von Ereignissen, um eine E-Mail
zu verschicken

Entwickeln Sie eine E-Mail-Anwendung

Testen Sie die E-Mail-Anwendung

Dieses Kapitel erklärt Ihnen, wie das Versenden einer E-Mail mit Python funktioniert. Darüber hinaus handelt dieses Kapitel allgemein davon, was passiert, wenn Sie mit der Welt außerhalb Ihres PCs kommunizieren. Auch wenn dieses Kapitel speziell das Versenden von E-Mails erläutert, enthält es auch Konzepte, die Sie für andere Aufgaben verwenden können. Arbeiten Sie beispielsweise mit einem externen Dienst, müssen Sie ein ähnliches Paket wie beim Verschicken von E-Mails erzeugen. Die Informationen in diesem Kapitel helfen Ihnen also dabei, alle möglichen Kommunikationsanforderungen zu verstehen und zu erfüllen.

Damit Sie mit E-Mails so einfach wie möglich arbeiten können, verwendet dieses Kapitel den normalen Postweg als Äquivalent zum E-Mail-Verkehr. Der Vergleich ist treffend, da die E-Mail-Technologie entlang des richtigen Postversandes entworfen wurde. Ursprünglich wurde der Begriff E-Mail für jegliche Art von elektronischer Dokumentenübertragung verwendet und manche davon erforderten, dass sowohl Sender als auch Empfänger zur gleichen Zeit online waren. Daher werden Sie im Internet auch ein paar verwirrende Einträge über den Ursprung und die Entwicklung von E-Mails finden. Dieses Kapitel betrachtet E-Mails so, wie sie heute funktionieren – als Speicher- und Weiterleitungsmethode, um verschiedene Arten von Dokumenten auszutauschen.

Die Beispiele in diesem Kapitel basieren auf der Verwendung eines Simple Mail Transfer Protocol (SMTP)-Servers. Sollten Sie damit noch nichts anfangen können, lesen Sie erst einmal den Kasten mit dem Titel Das Simple Mail Transfer Protocol im Folgenden.

Das passiert, wenn man eine E-Mail versendet

E-Mails sind so zuverlässig und alltäglich geworden, dass die meisten Leute gar nicht begreifen, was für ein Wunder das ist, dass es überhaupt funktioniert. Tatsächlich kann man dasselbe auch über die normale Post sagen. Wenn man mal darüber nachdenkt, dass die Wahrscheinlichkeit, dass ein bestimmter Brief von einem Ort verschickt wird und genau da landet, wo er am Ende sein soll, gering erscheint – sogar irrsinnig gering. Sowohl E-Mails als auch sein Pendant in der richtigen Welt haben einiges gemeinsam, das die Wahrscheinlichkeit der beabsichtigen Funktionsweise erhöht. Die folgenden Abschnitte untersuchen, was passiert, wenn Sie eine E-Mail schreiben, auf Senden klicken und der Empfänger auf der anderen Seite die E-Mail erhält. Sie werden erstaunt sein, was Sie alles darüber herausfinden werden.

Das Simple Mail Transfer Protocol

Bei der Arbeit mit E-Mails werden Sie häufiger über das Simple Mail Transfer Protocol (SMTP) stolpern. Sicher klingt der Begriff sehr technisch und das, was im Hintergrund passiert, ist auch sehr technisch, aber alles, was Sie wissen müssen, ist, dass es funktioniert. Auf der anderen Seite kann es aber auch sehr hilfreich sein, etwas mehr davon zu verstehen, als dass es eine Blackbox ist, die eine E-Mail eines Senders entgegennimmt und diese am anderen Ende an den Empfänger ausspuckt. Wenn man den Begriff in umgekehrter Reihenfolge auseinandernimmt, bekommt man folgende Bestandteile:

Protocol: Im Deutschen heißt das auch einfach Protokoll. Eine standardisierte Menge von Regeln. E-Mails müssen Regeln unterliegen, an die sich alle halten. Andernfalls wären E-Mails unzuverlässig und nicht brauchbar.

Mail Transfer: Heißt so viel wie E-Mail-Übertragung. Dokumente werden von einem Ort zum anderen gesendet, genauso wie es die Post mit richtigen Briefen tut. Im Fall von E-Mails basiert der Übertragungsprozess auf kurzen Befehlen, die Ihr E-Mail-Programm an den SMTP-Server schickt. Zum Beispiel teilt der Befehl MAIL FROM dem SMTP-Server mit, wer die E-Mail verschickt, während der Befehl RCPT TO angibt, wohin sie gesendet werden soll.

Simple: Zu Deutsch: Einfach. Drückt aus, dass diese Aufgabe mit dem kleinstmöglichen Aufwand ausgeführt wird. Weniger ist oft mehr und macht das Protokoll robuster.

Wenn Sie sich die Regeln zur Übertragung der Informationen anschauen würden, würden Sie sie mit Sicherheit als alles andere als einfach empfinden. Zum Beispiel ist RFC1123 ein Standard, der angibt, wie Internet-Hosts funktionieren sollen (für weitere Informationen siehe auch www.faqs.org/rfcs/rfc1123.html). Diese Regeln werden von mehreren Internettechnologien verwendet, was erklärt, warum viele davon ungefähr gleich funktionieren (auch wenn sie sich in den verwendeten Ressourcen und Zielen unterscheiden).

Ein ganz anderer Standard, RFC2821, beschreibt, wie genau SMTP die Regeln aus RFC1123 implementiert (weitere Informationen finden Sie unter www.faqs.org/rfcs/rfc 2821.html). Der Punkt ist, dass viele Regeln in einer Sprache verfasst sind, die nur ein wirklicher Computerfreak gut finden kann (und selbst die sind sich nicht sicher). Eine gut verständliche, deutsche Erklärung, wie E-Mails funktionieren, finden Sie unter www.tecchannel.de/kommunikation/e-mail/401772/so_funktioniert_e_mail. Der Artikel beschäftigt sich ausführlich ab Seite 2 mit SMTP und erklärt die Befehle, die SMTP zum Senden von Informationen verwendet.

E-Mails als herkömmliche Briefe betrachten

Am besten betrachtet man E-Mails genauso wie herkömmliche Briefe. Wenn Sie einen Brief schreiben, brauchen Sie zwei Stücke Papier. Das erste enthält den Inhalt des Briefes und das zweite ist ein Umschlag. Geht man davon aus, dass die Post ehrlich ist, wird der Inhalt niemals von jemand anderem als dem Empfänger angeschaut. Das Gleiche kann man bei E-Mails auch sagen. Eine E-Mail besteht aus diesen Komponenten:

Nachricht: Der Inhalt der E-Mail, der sich aus zwei Teilen zusammensetzt:

• Kopf: Der Teil des E-Mail-Inhalts, der den Betreff, die Liste der Empfänger und andere Dinge, wie die Dringlichkeit der E-Mail, enthält.

• Korpus: Der Teil des E-Mail-Inhalts, der die eigentliche Nachricht enthält. Die Nachricht kann unformatierter Text oder als HTML formatierter Text sein und ein oder mehrere Dokumente enthalten oder eine Kombination aus diesen Dingen sein.

Umschlag: Der Container für die Nachricht. Der Umschlag enthält Sender- und Empfängerinformationen, wie der Umschlag eines richtigen Briefes. Aber eine E-Mail braucht keine Briefmarke.

Wenn Sie eine E-Mail versenden wollen, können Sie mit einem E-Mail-Programm eine Nachricht erstellen. Bei der Einrichtung des E-Mail-Programms müssen Sie auch Kontoinformationen angeben. Wenn Sie auf Senden drücken,

1. packt das E-Mail-Programm Ihre Nachricht zuerst mit einem Nachrichtenkopf in einen Umschlag, der sowohl die Sender- als auch die Empfängerinformationen enthält.

2. Verwendet die E-Mail-Anwendung die Kontoinformationen, um den SMTP-Server zu kontaktieren und die Nachricht für Sie zu senden.

3. Der SMTP-Server liest nur die Informationen, die in dem Umschlag enthalten sind, und leitet Ihre Nachricht an den Empfänger weiter.

4. Die E-Mail-Anwendung des Empfängers meldet sich bei seinem lokalen Server an, holt die E-Mail ab und zeigt dem Benutzer dann nur den Teil mit der Nachricht der E-Mail an.

Der Vorgang ist etwas komplizierter als in dieser Beschreibung, aber im Grunde ist es das, was passiert. Tatsächlich ist dieser Vorgang ganz ähnlich wie bei richtigen Briefen, da die grundlegenden Schritte gleich sind. Bei richtigen Briefen ersetzen Sie an dem einen Ende und der Empfänger an dem anderen Ende das E-Mail-Programm. Der SMTP-Server wird von der Post und den dort arbeitenden Angestellten (das schließt die Briefträger mit ein) gespielt. Jemand schreibt also eine Nachricht, die Nachricht wird an einen Empfänger übermittelt und der Empfänger erhält in beiden Fällen die Nachricht.

Die Bestandteile des Umschlags

Es gibt einen Unterschied zwischen dem Aufbau des Umschlags einer E-Mail und wie er tatsächlich verarbeitet wird. Wenn Sie den Umschlag einer E-Mail betrachten, sieht dieser erst einmal genauso wie bei einem richtigen Brief aus – er enthält die Adresse des Senders und die Adresse des Empfängers. Es sieht vielleicht technisch nicht wie ein Umschlag aus, aber er enthält dieselben Bestandteile. Wenn Sie sich einen Briefumschlag vorstellen, fallen Ihnen bestimmte Eigenschaften auf, wie der Name des Absenders, die Adresse, Stadt, Land und Postleitzahl. Dasselbe gilt für den Empfänger. Diese Elemente bestimmen, wohin der Briefträger den Brief bringen soll oder wohin er ihn zurückbringen soll, wenn der Brief nicht zugestellt werden kann.

Wenn der SMTP-Server den Umschlag einer E-Mail verarbeitet, muss er sich auch die Eigenschaften der Adresse anschauen, aber hier hinkt die Analogie zwischen physischem und elektronischem Umschlag ein wenig. Eine E-Mail-Adresse enthält andere Informationen als eine Postadresse. Zusammengefasst enthält eine E-Mail-Adresse:

Host: Der Host ist vergleichbar mit der Stadt und dem Land auf einem richtigen Briefumschlag. Eine Hostadresse ist die Adresse der Netzwerkkarte, die physisch mit dem Internet verbunden ist, und bearbeitet den Netzwerkverkehr für diesen bestimmten Computer. Ein PC kann auf verschiedene Arten Internetressourcen benutzen, aber die Hostadresse ist für alle gleich.

Port: Der Port ist vergleichbar mit der Straße und Hausnummer auf einem richtigen Briefumschlag. Er gibt an, welcher Teil des Systems die Nachricht empfangen soll. Zum Beispiel nutzt ein SMTP-Server für ausgehende Nachrichten normalerweise Port 25. Ein Point-of-Presence-Server (POP3-Server), der eingehende Nachrichten bearbeitet, verwendet Port 110. Ihr Browser verwendet typischerweise Port 80, um Websites aufzurufen. Gesicherte Websites (die, die https statt http als Protokoll verwenden) benutzen stattdessen Port 443. Eine Liste mit typischen Portbelegungen finden Sie unter http://de.wikipedia.org/wiki/Liste_der_standardisierten_Ports.

Lokaler Hostname: Der lokale Hostname ist die menschenlesbare Form einer Kombination aus Host und Port. Zum Beispiel könnte die Website www.meinzuhause.de in die Adresse 55.225.163.40:80 aufgelöst werden (die ersten vier Zahlen sind die Hostadresse und die Zahl nach dem Doppelpunkt ist der Port). Python kümmert sich für Sie im Hintergrund um diese Details, sodass Sie sich normalerweise nicht darum kümmern müssen. Es ist aber gut zu wissen, dass diese Informationen verfügbar sind.

Da Sie nun wissen, wie sich die Adresse zusammensetzt, sollten wir sie uns etwas genauer anschauen. Die folgenden Abschnitte beschreiben den Umschlag einer E-Mail etwas eingehender.

Host

Eine Hostadresse identifiziert eine Verbindung zu einem Server. Genauso wie die Adresse auf einem richtigen Briefumschlag nicht die genaue geografische Position ist, so ist die Hostadresse auch nicht der eigentliche Server. Sie gibt nur den Ort des Servers an.

Die Verbindung, die auf eine Kombination aus Hostadresse und Port zugreift, nennt sich Socket (ins Deutsche übersetzt heißt das so viel wie Buchse). Wer sich diesen langweiligen Namen ausgedacht hat und warum, ist nicht wichtig. Es ist aber sehr wohl wichtig, dass Sie einen Socket verwenden können, um sich verschiedene Informationen zum besseren Verständnis, wie E-Mails funktionieren, zu besorgen. Die folgenden Schritte zeigen Ihnen Hostadressen und Hostnamen im Einsatz. Außerdem wird das gesamte Konzept eines E-Mail-Umschlags und den darin enthaltenen Adressen erklärt.

1. Öffnen Sie ein Python-Shell-Fenster.

Die schon bekannte Python-Eingabeaufforderung erscheint.

2. Geben Sie import socket ein und drücken Sie [Enter].

Bevor Sie mit Sockets arbeiten können, müssen Sie die Socket-Bibliothek importieren. Diese Bibliothek enthält viele verwirrende Attribute; verwenden Sie sie also mit Vorsicht. Diese Bibliothek enthält aber auch ein paar sehr interessante Funktionen, anhand derer Sie sehen können, wie Internetadressen funktionieren.

3. Geben Sie socket.gethostbyname("localhost") ein und drücken Sie [Enter].

Es wird eine Hostadresse ausgegeben. In diesem Fall sollten Sie als Ausgabe 127.0.0.1 sehen, da localhost der Standardhostname der lokalen Netzwerkkarte ist. Die Adresse 127.0.0.1 ist mit dem Hostnamen localhost verknüpft.

4. Geben Sie socket.gethostbyaddr("127.0.0.1") ein und drücken Sie [Enter].

Machen Sie sich auf eine Überraschung gefasst. Sie bekommen als Ausgabe ein Tupel, wie in Abbildung 16.1 zu sehen. Statt localhost als Name zu bekommen, wird der Name Ihres Computers ausgegeben. localhost wird als allgemeiner Name für den lokalen Rechner verwendet, aber wenn Sie die Adresse eingeben, dann bekommen Sie stattdessen den Rechnernamen. Louise ist der Name meines Computers. Sie sehen natürlich den Namen Ihres Computers.

Abbildung 16.1: Die localhost-Adresse gehört zu Ihrem Computer.

5. Geben Sie socket.gethostbyname("www.wiley-vch.com") ein und drücken Sie [Enter].

Sie sehen die Ausgabe aus Abbildung 16.2. Dies ist die Adresse der Wiley-VCH-Website. Diese Adressen funktionieren, egal wo Sie gerade sind und was Sie gerade machen – genauso wie die, die Sie auf einen normalen Briefumschlag schreiben. Postadressen sind Adressen, die auf der ganzen Welt eindeutig sind, und genauso ist das im Internet auch.

6. Schließen Sie die Python-Shell.

Abbildung 16.2: Adressen, die Sie zum Versenden von E-Mails verwenden, sind über das ganze Internet hinweg eindeutig.

Port

Ein Port ist ein bestimmter Einstiegspunkt für einen Server. Die Hostadresse gibt die Position des Servers an, aber der Port definiert, wo man reinkommt. Auch wenn Sie nicht jedes Mal einen Port angeben, wenn Sie eine Hostadresse verwenden, wird der Port implizit angehängt. Der Zugriff wird immer über eine Kombination aus Hostadresse und Port hergestellt. Die folgenden Schritte zeigen Ihnen, wie Ports mit der Hostadresse funktionieren, um auf einen Server zuzugreifen:

1. Öffnen Sie ein Python-Shell-Fenster.

Die schon bekannte Python-Eingabeaufforderung erscheint.

2. Geben Sie import socket ein und drücken Sie [Enter].

Denken Sie daran, dass ein Socket sowohl Hostadresse als auch Portinformationen enthält. Sie verwenden den Socket, um eine Verbindung, die beide Elemente verwendet, herzustellen.

3. Geben Sie socket.getaddrinfo("localhost",110) ein und drücken Sie [Enter].

Der erste Wert ist der Name des Hosts, zu dem Sie Informationen haben wollen. Der zweite Wert ist der Port auf diesem Host. In diesem Beispiel beschaffen Sie sich Informationen über Port 110 von localhost.

Sie sehen die Ausgabe aus Abbildung 16.3. Die Ausgabe besteht aus zwei Tupeln: eine für die Adresse des Internet Protocol Version 6 (IPv6) und eine für die Adresse des Internet Protocol Version 4 (IPv4). Jedes dieser Tupel enthält fünf Einträge, wovon vier nicht für Sie relevant sind, da Sie sie wahrscheinlich nicht brauchen werden. Der letzte Eintrag (´127.0.0.1´,110) zeigt aber die Adresse und den Port für localhost Port 110 an.

4. Geben Sie socket.getaddrinfo("wiley-vch.com",80) ein und drücken Sie [Enter].

Abbildung 16.4 zeigt die Ausgabe dieses Befehls. Beachten Sie, dass diese Website nur eine IPv4-Adresse und keine IPv6-Adresse für Port 80 hat. Die Funktion socket.getaddr info() stellt eine nützliche Methode dar, um zu bestimmen, wie Sie auf eine bestimmte Adresse zugreifen können. Die Verwendung von IPv6 bietet entscheidende Vorteile gegenüber der Verwendung von IPv4 (siehe dazu auch www.crn.de/netzwerke-storage/artikel-90749.html), aber die meisten Internetadressen bieten nur Unterstützung für IPv4.

Abbildung 16.3: Der localhost hat sowohl eine IPv6-Adresse als auch eine IPv4-Adresse.

Abbildung 16.4: Die meisten Webserver stellen nur eine IPv4-Adresse zur Verfügung.

5. Geben Sie socket.getservbyport(25) ein und drücken Sie [Enter].

Sie sehen die Ausgabe aus Abbildung 16.5. Die Methode socket.getservbyport() ermöglicht Ihnen, zu bestimmen, wie ein bestimmter Port verwendet wird. Port 25 ist auf jedem Server immer für SMTP reserviert. Wenn Sie also auf 127.0.0.1:25 zugreifen, fragen Sie nach dem SMTP-Server auf localhost. Kurz, ein Port stellt in vielen Situationen einen bestimmten Zugriff zur Verfügung.

Abbildung 16.5: Standardisierte Ports bieten bestimmte Dienste auf jedem Server an.

6. Schließen Sie die Python-Shell.

Manche Leute nehmen an, dass die Portinformation jedes Mal angegeben wird. Das ist jedoch nicht immer der Fall. Python nimmt einen Standard-Port, wenn Sie keinen angeben; aber sich auf den Standard-Port zu verlassen, ist keine gute Idee, da Sie nicht sicher sein können, auf welchen Dienst nun tatsächlich zugegriffen wird. Außerdem verwenden manche Systeme als Sicherheitsfeature Port-Zuweisungen, die nicht dem Standard entsprechen. Gewöhnen Sie sich an, immer die Portnummer anzugeben damit Sie die richtige Nummer für die gegebene Aufgabe haben.

Lokaler Hostname

Ein Hostname ist einfach die menschenlesbare Form einer Hostadresse. Menschen verstehen unter 127.0.0.1 nicht wirklich viel (und die IPv6-Adressen ergeben noch weniger Sinn). Menschen können sich unter dem Namen localhost aber sehr wohl etwas vorstellen. Es gibt einen speziellen Server und einen Dienst, um menschenlesbare Hostnamen in Hostadressen zu übersetzen, aber darüber müssen Sie sich im Rahmen dieses Buches keine Gedanken machen (oder generell bei der Programmierung). Sollte Ihre Anwendung plötzlich ohne jeden ersichtlichen Grund abstürzen, ist es doch nützlich zu wissen, dass es das gibt.

Der Abschnitt Host weiter vorne in diesem Kapitel stellt Ihnen das Konzept des Hostnamens in begrenztem Rahmen über die Verwendung der Methode socket.gethostbyaddr() vor, wo eine Adresse in einen Hostnamen übersetzt wird. Der umgekehrte Vorgang wurde mit der Methode socket.gethostbyname() ausgeführt. Die folgenden Schritte bringen Ihnen ein paar Aspekte über die Arbeit mit Hostnamen näher:

1. Öffnen Sie ein Python-Shell-Fenster.

Die schon bekannte Python-Eingabeaufforderung erscheint.

2. Geben Sie import socket ein und drücken Sie [Enter].

3. Geben Sie socket.gethostname() ein und drücken Sie [Enter].

Sie sehen den Namen des lokalen Rechners, wie in Abbildung 16.6 gezeigt. Der Name Ihres Computers wird sich wahrscheinlich von meinem unterscheiden, also wird Ihre Ausgabe auch anders als die in Abbildung 16.6 aussehen, aber das Konzept bleibt dasselbe, egal welchen Computer Sie verwenden.

Abbildung 16.6: Manchmal müssen Sie den Namen des lokalen Rechners kennen.

4. Geben Sie socket.gethostbyname(socket.gethostname()) ein und drücken Sie [Enter].

Die IP-Adresse des lokalen Computers wird, wie in Abbildung 16.7 zu sehen, ausgegeben. Auch hier wird das bei Ihnen etwas anders sein und daher die Ausgabe auch etwas anders aussehen. Diese Methode können Sie verwenden, um in Ihrer Anwendung, wenn nötig, die Adresse des Senders zu bestimmen. Da dies nicht auf irgendeinem hardcodierten Wert basiert, funktioniert diese Methode auf jedem System.

Abbildung 16.7: Vermeiden Sie, wenn möglich, die Verwendung von hardcodierten Werten für das lokale System.

5. Schließen Sie die Python-Shell.

Die Bestandteile einer Nachricht

Der »Umschlag« für eine E-Mail-Adresse ist das, was der SMTP-Server verwendet, um eine E-Mail zu senden. Der Umschlag enthält jedoch nichts – das ist der alleinige Zweck der Nachricht. Viele Entwickler verwechseln diese beiden Dinge, da die Nachricht ebenfalls Sender- und Empfängerinformationen enthält. Diese Informationen erscheinen in der Nachricht genauso, wie die Adressinformationen ja auch auf einem Geschäftsbriefbogen stehen – dies soll dem Leser helfen. Wenn Sie einen Geschäftsbrief verschicken, öffnet der Briefträger nicht den Umschlag, um sich die Adressinformationen auf dem Briefbogen anzuschauen. Nur die Informationen auf dem Umschlag sind relevant.

Da die Informationen in der E-Mail-Nachricht von den Informationen auf dem Umschlag getrennt behandelt werden, ist es erst möglich, dass schändliche Individuen E-Mail-Adressen fälschen können. Der Umschlag enthält potenziell korrekte Absenderinformationen, aber bei der Nachricht kann das anders sein. (Wenn Sie sich die E-Mail in Ihrem E-Mail-Programm anschauen, sehen Sie nur die Nachricht, nicht den Umschlag – der Umschlag wurde schon durch das E-Mail-Programm entfernt.) Aus diesem Grund können sowohl Absender- als auch Empfängerinformationen in der Nachricht, die in Ihrem E-Mail-Programm angezeigt wird, richtig sein.

Der Nachrichtenteil einer E-Mail setzt sich aus verschiedenen Komponenten zusammen, genauso wie beim Umschlag auch.

Im Folgenden finden Sie eine Zusammenfassung der drei Komponenten:

Sender: Die Senderinformation sagt Ihnen, wer die E-Mail verschickt hat. Sie enthält nur die E-Mail-Adresse des Senders.

Empfänger: Die Empfängerinformation sagt Ihnen, wer die Nachricht empfangen wird. Das ist eine Liste mit E-Mail-Adressen der Empfänger. Auch wenn Sie die E-Mail nur an eine Person verschicken wollen, müssen Sie diese eine Adresse in einer Liste angeben.

Nachricht: Enthält die Informationen, die der Empfänger sehen soll. Die Informationen können das Folgende enthalten:

• Von: Die menschenlesbare Form des Senders.

• An: Die menschenlesbare Form der Empfänger.

• CC: Sichtbare Empfänger, die auch diese Nachricht bekommen, auch wenn sie nicht die Hauptzielgruppe der Nachricht sind.

• Betreff: Der Zweck dieser E-Mail.

• Dokumente: Ein oder mehrere Dokumente, die Textnachricht, die in der E-Mail angezeigt wird, eingeschlossen.

E-Mails können ziemlich komplex und lang werden. Je nachdem, was für eine E-Mail verschickt wird, kann die Nachricht alle möglichen zusätzlichen Informationen enthalten. Die meisten E-Mails enthalten aber diese einfachen genannten Bestandteile und das sind alle Informationen, die Sie brauchen, um eine E-Mail aus Ihrer Anwendung heraus zu verschicken. Die folgenden Abschnitte beschreiben den Prozess zum Erstellen einer Nachricht und dessen Komponenten genauer.

Die Nachricht erzeugen

Man kann einen leeren Umschlag an jemanden verschicken, aber das ist nicht besonders spannend. Um Ihrer E-Mail einen Sinn zu verleihen, müssen Sie eine Nachricht definieren. Python unterstützt mehrere Methoden, um Nachrichten zu erstellen. Der einfachste und zuverlässigste Weg zur Erzeugung einer Nachricht ist die Verwendung der Multi-purpose Internet Mail Extensions (MIME)-Funktionalität, die Python anbietet (und nein, MIME ist keine stumme Person mit weißen Handschuhen, die in der Öffentlichkeit schauspielert).

Wie viele andere E-Mail-Technologien auch ist MIME standardisiert, das bedeutet, es funktioniert immer gleich, unabhängig davon, welches System Sie verwenden. Es gibt zahlreiche Formen von MIME, die alle Teil des Moduls email.mime, beschrieben unter https://docs.python.org/3/library/email.mime.html, sind. Im Folgenden finden Sie die Formen, die Sie am häufigsten brauchen werden, wenn Sie mit E-Mails programmieren:

MIMEApplication: Stellt eine Methode zum Senden und Empfangen von Anwendungseingaben und -ausgaben zur Verfügung.

MIMEAudio: Enthält eine Audiodatei.

MIMEImage: Enthält eine Bilddatei.

MIMEMultipart: Erlaubt einer Nachricht, mehrere Teile zu haben, wie Text und Bilder in einer einzigen Nachricht.

MIMEText: Enthält Textdaten, die in ASCII, HTML oder einem anderen standardisierten Format vorliegen können.

Obwohl Sie mit Python jede Art von E-Mail-Nachricht erzeugen können, ist es am einfachsten, eine mit unformatiertem Text zu erstellen. Die fehlende Formatierung im Inhalt hilft, sich auf die Technik zum Erstellen der Nachricht statt auf den Nachrichteninhalt zu konzentrieren. Die folgenden Schritte zeigen Ihnen, wie man eine Nachricht erstellt, aber die Nachricht werden Sie nicht zu Gesicht bekommen.

1. Öffnen Sie ein Python-Shell-Fenster.

Die schon bekannte Python-Eingabeaufforderung erscheint.

2. Geben Sie den folgenden Code in und drücken Sie am Ende jeder Zeile auf [Enter]:

from email.mime.text import MIMEText
nachricht = MIMEText("Hallöchen")

nachricht[´Subject´] = "Eine Testnachricht"

nachricht[´From´] = ´John Mueller <John@JohnMuellerBooks.com>´
nachricht[´To´] = ´John Mueller <John@JohnMuellerBooks.com>´

Dies ist eine einfache Nachricht mit unformatiertem Text. Bevor Sie irgendetwas machen können, müssen Sie die erforderliche Klasse MIMEText importieren. Würden Sie einen anderen Nachrichtentyp erstellen, müssten Sie eine andere Klasse oder das Modul email.mime komplett importieren.

Der Konstruktor MIMEText() erwartet den Nachrichtentext als Eingabe. Das ist der Korpus Ihrer Nachricht und könnte daher sehr lang sein. Im Beispiel ist die Nachricht relativ kurz – nur ein Gruß.

Dann weisen Sie den Standardattributen Werte zu. Dieses Beispiel verwendet drei Attribute, die Sie immer angeben: Subject (Betreff), From (Von) und To (An). Die zwei Adressfelder From und To enthalten beide einen menschenlesbaren Namen und die E-Mail-Adresse. Sie müssen aber lediglich eine E-Mail-Adresse angeben.

3. Geben Sie nachricht.as_string() ein und drücken Sie [Enter].

Die Ausgabe in Abbildung 16.8 wird angezeigt. So sieht die Nachricht eigentlich aus. Falls Sie je hinter die Kulissen der Nachrichten, die Ihr E-Mail-Programm erstellt, geschaut haben, werden Sie sicher feststellen, dass diese ähnlich aussehen.

Content-Type gibt wieder, welchen Nachrichtentyp Sie verwendet haben, in diesem Fall eine unformatierte Textnachricht. charset gibt an, welche Zeichen in der Nachricht verwendet wurden, damit der Empfänger weiß, wie er diese zu interpretieren hat. MIME- Version gibt die Version von MIME an, mit der die Nachricht erstellt wurde, sodass der Empfänger weiß, ob er den Inhalt verarbeiten kann. Schließlich bestimmt Context- Transfer-Encoding, wie die Nachricht in einen Bitstrom umgewandelt wird, bevor Sie an den Empfänger gesendet wird.

Abbildung 16.8: Python fügt Ihrer Nachricht ein paar zusätzliche Informationen hinzu.

Die Übertragung

Ein vorhergehender Abschnitt (Die Bestandteile des Umschlags) beschreibt, wie ein Umschlag verwendet wird, um die Nachricht von einem Ort zum anderen zu übertragen. Der Sendevorgang der Nachricht beinhaltet, dass man eine Übertragungsmethode definieren muss. Python erstellt für Sie den Umschlag und führt die Übertragung durch, aber Sie müssen trotzdem die Eigenschaften der Übertragung angeben. Die folgenden Schritte zeigen Ihnen die simpelste Methode, mit der Sie mit Python eine Nachricht verschicken können. Diese Schritte führen nicht zu einer erfolgreichen Übertragung, wenn Sie die Konfiguration nicht Ihren Einstellungen anpassen. Lesen Sie den Kasten Der SMTP-Server, um mehr darüber zu erfahren.

1. Verwenden Sie das Python-Shell-Fenster, das Sie im Abschnitt Die Nachricht erzeugen geöffnet haben.

Sie sollten die Nachricht sehen, die Sie zuvor erstellt haben.

2. Geben Sie den folgenden Code ein (drücken Sie am Ende jeder Zeile einmal und nach der letzten Zeile zweimal [Enter]):

import smtplib
s = smtplib.SMTP(´localhost´)

s.login(´username´, ´password´)

Das Modul smtplib enthält alles, was man braucht, um den Nachrichtenumschlag zu erzeugen und zu senden. Der erste Schritt in diesem Prozess stellt eine Verbindung zum SMTP-Server her, den Sie mit dem Namen im Konstruktor angeben. An dem Server müssen Sie sich meist mit einem Benutzerkonto anmelden. Sollte der angegebene Server nicht existieren, gibt die Anwendung an diesem Punkt einen Fehler aus, der sagt, dass der Host die Verbindung verweigert hat.

3. Geben Sie s.sendmail(´´SenderAdresse´´,[´´EmpfängerAdresse´´], nachricht.as_ string()) ein und drücken Sie [Enter].

Damit dieser Schritt funktioniert, müssen Sie SenderAdresse und EmpfängerAdresse durch richtige E-Mail-Adressen ersetzen. Lassen Sie die menschenlesbare Form diesmal weg – der Server braucht nur eine Adresse.

Dieser Schritt erzeugt den Umschlag, verpackt die Nachricht darin und sendet sie zum Empfänger. Beachten Sie, dass Sie die Sender- und Empfängerinformationen getrennt von der Nachricht angeben, die der SMTP-Server nicht liest.

4. Schließen Sie die Python-Shell.

Nachrichtensubtypen

Der Abschnitt Die Nachricht erzeugen etwas weiter vorne in diesem Kapitel beschreibt die Hauptarten von E-Mail-Nachrichten, wie Anwendung oder Text. Wenn E-Mails aber nur diese Typen zur Verfügung hätten, wäre es schwierig, jemandem sinnvolle Nachrichten zu schicken. Das Problem ist, dass der Informationstyp nicht präzise genug ist. Bevor Sie jemandem eine Nachricht schicken können und diese verarbeitet werden kann, müssen Sie wissen, was für ein Text das ist (und Raten ist da keine gute Idee). Eine Textnachricht kann unformatierter Text oder eine HTML-Seite sein. Das können Sie nicht allein am Typ erkennen, daher brauchen Sie noch Subtypen. Der Typ ist text und der Subtyp ist html, wenn Sie an jemanden eine HTML-Seite verschicken. Typ und Subtyp werden durch einen Schrägstrich getrennt, sodass Sie text/html hätten, wenn Sie sich die Nachricht anschauen würden.

Theoretisch ist die Anzahl der Subtypen unbegrenzt, solange das System einen Handler für diesen Subtyp hat. Tatsache ist, dass alle sich über die Subtypen einig sein müssen, ansonsten wird es keinen Handler dafür geben (es sei denn, Sie sprechen über eine speziell angepasste Anwendung, für die zwei Seiten sich auf einen Subtyp im Vorhinein geeinigt haben). Sie finden eine Liste mit Standardtypen und -subtypen unter http://wiki.selfhtml.org/wiki/Referenz:MIME-Typen. Schön an der Liste auf dieser Seite finde ich, dass sie Ihnen zu den Subtypen die übliche Dateierweiterung zur Verfügung stellt.

Eine E-Mail-Nachricht erstellen

Bisher haben Sie gesehen, wie man sowohl den Umschlag als auch die Nachricht erstellt. Nun wird es Zeit, dass wir diese zusammenbringen und Sie sehen, wie diese wirklich funktionieren. Die folgenden Abschnitte zeigen Ihnen, wie man zwei Nachrichten erstellt. Die erste Nachricht ist eine mit unformatiertem Text und die zweite Nachricht verwendet HTML-Formatierung. Beide Nachrichten sollten in den meisten E-Mail-Programmen funktionieren – es wird nichts Besonderes verwendet.

Eine Textnachricht versenden

Textnachrichten stellen die effizienteste und ressourcenreichste Methode zur Kommunikation dar. Textnachrichten enthalten aber auch die geringste Informationsmenge. Klar können Sie mit Emoticons Ihren Standpunkt unterstreichen, aber die fehlenden Informationen können in manchen Situationen zum Problem werden. Die folgenden Schritte beschreiben, wie Sie mit Python eine einfache Textnachricht erzeugt können. Dieses Beispiel finden Sie in der Datei TextNachricht.py.

1. Öffnen Sie ein Python-Editierfenster.

Ein Editor erscheint, in den Sie Ihren Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

from email.mime.text import MIMEText
import smtplib

nachricht = MIMEText("Hallöchen!")

nachricht[´Subject´] = ´Eine Testnachricht´
nachricht[´From´] = ´SenderAdresse´
nachricht[´To´] = ´EmpfängerAdresse´

s = smtplib.SMTP(´localhost´)

s.login(´username´, ´password´)

s.sendmail(´SenderAdresse´,

[´EmpfängerAdresse´],

nachricht.as_string())

print("Nachricht gesendet!")

Dieses Beispiel kombiniert alles, was Sie bisher in diesem Kapitel kennengelernt haben, miteinander. Aber es ist das erste Mal, dass Sie alles zusammengefügt sehen. Beachten Sie, dass Sie zuerst die Nachricht und dann den Umschlag erstellen (so würden Sie es auch bei einem richtigen Brief machen).

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Die Anwendung teilt Ihnen mit, dass die Nachricht an den Empfänger verschickt wurde.

Der SMTP-Server

Wenn Sie das Beispiel in diesem Kapitel ohne Änderungen ausgeführt haben, kratzen Sie sich wahrscheinlich jetzt am Kopf und wundern sich, was schiefgelaufen ist. Es ist sehr unwahrscheinlich, dass auf Ihrem System unter localhost ein SMTP-Server läuft. Das Beispiel verwendet localhost als Platzhalter, den Sie später mit den Informationen für Ihre eigene Konfiguration ersetzen können.

Damit Sie sehen können, ob das Beispiel tatsächlich funktioniert, brauchen Sie einen SMTP-Server und ein E-Mail-Konto. Natürlich könnten Sie auch sämtliche erforderliche Software installieren, um eine solche Umgebung auf Ihrem eigenen Rechner aufzubauen, und manche Entwickler, die sich intensiv mit E-Mail-Anwendungen auseinandersetzen, machen das auch. Die meisten Systeme enthalten ein E-Mail-Paket, das Sie installieren können, oder Sie verwenden ein frei verfügbares Pendant, wie Sendmail, ein Open-Source-Produkt, das Sie unter www.sendmail.com/sm/open_source/download herunterladen können. Der einfachste Weg, um zu prüfen, ob das Beispiel funktioniert, ist, denselben SMTP-Server zu verwenden wie Ihr E-Mail-Programm. Bei der Einrichtung Ihres E-Mail-Programms hat entweder das E-Mail-Programm den SMTP-Server automatisch anhand der E-Mail-Adresse erkannt oder Sie haben den SMTP-Server selbst eingegeben. Die Konfiguration Ihres E-Mail-Programms sollte die erforderlichen Informationen enthalten. Der genaue Ort, wo Sie diese Informationen finden, ist je nach E-Mail-Programm verschieden und daher sollten Sie sich die Dokumentation für Ihre Software anschauen, um diese Information zu finden.

Egal, welchen SMTP-Server Sie benutzen, Sie brauchen in den meisten Fällen ein Konto auf diesem Server, damit Sie dessen Dienste in Anspruch nehmen dürfen. Ersetzen Sie die Informationen in den Beispielen durch die Informationen für Ihren SMTP-Server, wie smtp.meinISP.com, zusammen mit Ihrer E-Mail-Adresse für Sender und Empfänger. Sonst wird das Beispiel nicht funktionieren.

Eine HTML-Nachricht versenden

Eine HTML-Nachricht ist im Grunde eine Textnachricht mit einer speziellen Formatierung. Die folgenden Schritte zeigen Ihnen, wie Sie eine E-Mail mit einer HTML-Nachricht verschicken können. Das Beispiel finden Sie in der Datei HTMLNachricht.py.

1. Öffnen Sie ein Python-Editierfenster.

Ein Editor erscheint, in den Sie Ihren Beispielcode eingeben können.

2. Geben Sie den folgenden Code in das Fenster ein – drücken Sie am Ende jeder Zeile [Enter]:

from email.mime.text import MIMEText
import smtplib

nachricht = MIMEText("<h1>Eine Überschrift</h1><p>Hallöchen</p>","html")

nachricht[´Subject´] = ´Eine HTML-Testnachricht´
nachricht[´From´] = ´SenderAdresse´
nachricht[´To´] = ´EmpfängerAdresse´

s = smtplib.SMTP(´localhost´)

s.login(´username´, ´password´)

s.sendmail(´SenderAdresse´,

[´EmpfängerAdresse´],

nachricht.as_string())

print("Nachricht gesendet!")

Das Beispiel folgt demselben Ablauf wie das Beispiel mit der Textnachricht im vorherigen Abschnitt. Beachten Sie jedoch, dass die Nachricht nun HTML-Tags enthält. Sie haben nur den HTML-Body, nicht eine ganze Seite erzeugt. Diese Nachricht wird eine H1-Überschrift und einen Abschnitt enthalten.

Der wichtigste Teil dieses Beispiels ist, dass der Text nach der Nachricht kommt. Der Parameter "html" ändert den Subtyp von text/plain in text/html, sodass der Empfänger weiß, dass er die Nachricht als HTML-Inhalt interpretieren muss. Wenn Sie diese Änderung nicht vornehmen, würde der Empfänger keine HTML-Ausgabe sehen.

3. Wählen Sie RUN|RUN MODULE aus dem Menü aus.

Die Anwendung teilt Ihnen mit, dass die Nachricht an den Sender verschickt wurde.

Sich die E-Mail-Ausgabe anschauen

Zu diesem Zeitpunkt sollten Sie zwischen ein und drei durch die Anwendung generierte Nachrichten (je nachdem, wie viele Beispiele Sie mitgemacht haben) in Ihrem Posteingang haben. Damit Sie sich die Nachrichten aus den vorherigen Abschnitten anschauen können, muss Ihr E-Mail-Programm die Nachrichten vom Server abrufen – so, wie jede andere E-Mail auch. Abbildung 16.9 zeigt ein Beispiel der HTML-Version der Nachricht, wenn man sie sich in einem E-Mail-Client anschaut. (Ihre Nachricht wird wahrscheinlich anders aussehen, je nach System und E-Mail-Programm.)

Wenn Ihr E-Mail-Programm die Möglichkeit bietet, sich die Nachrichteninformationen mal anzuschauen, werden Sie feststellen, dass die Nachricht tatsächlich die Informationen enthält, die Sie zuvor in diesem Kapitel schon gesehen haben. Es hat sich nichts geändert oder ist anders, da die Nachricht nach Verlassen der Anwendung nicht mehr auf ihrer Reise verändert wird.

Abbildung 16.9: Die HTML-Ausgabe enthält wie erwartet eine Überschrift und einen Abschnitt.

Der Grund, eine Anwendung zum Senden und Empfangen von E-Mails zu schreiben, ist nicht der Komfort – ein schon existierendes Programm von der Stange würde diesen Job sicher besser machen. Der Punkt ist die Flexibilität. Wie Sie an diesem kurzen Kapitel schon erkennen können, können Sie mit einer eigenen Anwendung jeden noch so kleinen Aspekt der Nachricht kontrollieren. Python versteckt viele Details vor Ihnen, damit Sie sich ganz auf die wichtigen Dinge bei der Erstellung und dem Versenden einer Nachricht mit Angabe der richtigen Parameter konzentrieren können.

Teil V

Der Top-Ten-Teil

Besuchen Sie uns auf www.facebook.de/fuerdummies!

In diesem Teil . . .

Lernen Sie coole Internetseiten kennen, mit denen Sie noch mehr über Python lernen.

Erfahren Sie, wie man mit Ihrem Python-Wissen seinen Lebensunterhalt verdienen kann.

Besorgen Sie sich Tools, die Ihre Arbeit mit Python effizienter machen.

Erweitern Sie Python mit Bibliotheken, damit es noch mehr kann.

17

Zehn tolle Quellen zum Thema
Programmierung

In diesem Kapitel

Verwenden Sie die Python-Dokumentation

Schauen Sie sich ein interaktives Python-Tutorial an

Erstellen Sie eine Internetanwendung mit Python

Erweitern Sie Python mit Bibliotheken von Drittanbietern

Besorgen Sie sich einen besseren Editor für die Entwicklung von Python-Programmen

Prüfen Sie die Syntax Ihrer Python-Anwendung

Arbeiten Sie mit XML

Werden Sie mit weniger Aufwand als sonst ein professioneller Entwickler

Überwinden Sie die Unicode-Hürde

Erstellen Sie blitzschnelle Anwendungen

Dieses Buch ist ein hervorragender Ausgangspunkt, um mit Python programmieren zu lernen, aber irgendwann sind Sie an einem Punkt angelangt, wo Sie noch weitere Quellen brauchen. Dieses Kapitel bietet Ihnen zehn tolle Quellen rund um das Thema Programmierung, mit denen Sie Ihre Entwicklungskünste verbessern können. Mit diesen Informationsquellen sparen Sie sich bei Ihrer nächsten fantastischen Python-Anwendung Zeit und Energie.

Natürlich bietet auch dieses Kapitel nur einen kleinen Ausschnitt aus den zahlreichen Quellen und Tipps, die Sie zum Thema Programmierung mit Python im Internet finden können. Im Internet gibt es neben Bergen von Python-Code auch haufenweise Literatur zu Python. Man kann sicherlich ein ganzes (oder zwei) Bücher nur über die Python-Bibliotheken schreiben. Dieses Kapitel soll Ihnen Hinweise geben, wo Sie zusätzliche Informationen finden, die Ihnen bei Ihren ganz persönlichen Anforderungen helfen. Lesen Sie dieses Kapitel nicht nur, sondern betrachten Sie es vielmehr als Startpunkt Ihrer Suche.

Mit der Python-Online-Dokumentation arbeiten

Bei der Arbeit mit Python ist es sehr wichtig zu wissen, was die Grundsprache so bietet und wie man sie erweitert, um bestimmte Aufgaben zu erledigen. Die Python-Dokumentation unter https://docs.python.org/3 (für die Version 3.4.2 zum Zeitpunkt des Buchschreibens; es gibt jetzt, während Sie das Buch lesen, vielleicht schon eine aktuellere Version) enthält sehr viel mehr als nur die Sprachreferenz, die Sie mit dem Download bekommen. Die folgenden Themen werden nämlich auch in der Dokumentation behandelt:

Neue Features der aktuellen Sprachversion

Zugriff auf ein vollwertiges Tutorial

Vollständige Bibliothekreferenz

Vollständige Sprachreferenz

Wie man Python installiert und konfiguriert

Wie man bestimmte Aufgaben mit Python erledigt

Hilfe bei der Installation von Modulen aus anderen Quellen (zur Erweiterung von Python)

Hilfe beim Verteilen von Python-Modulen, die Sie selbst erstellt haben, damit andere sie auch benutzen können

Wie man Python mit C/C++ erweitert und diese Funktionen integriert

Vollständige Referenz für C/C++-Entwickler, die ihre Anwendung mit Python erweitern wollen

FAQ-Seiten (Frequently Asked Questions, häufig gestellte Fragen)

All diese Informationen sind leicht zugänglich und verwendbar. Neben der üblichen Inhaltsverzeichnisstruktur zur Informationssuche können Sie auch auf einige Indexe zugreifen. Sind Sie beispielsweise nur daran interessiert, ein bestimmtes Modul, eine Klasse oder eine Methode zu finden, können Sie den Global Module Index verwenden.

Auf der Webseite https://docs.python.org/3 können Sie auch Probleme mit Python melden. Natürlich kann es immer wieder Probleme in Ihrer Anwendung geben, für die Python nichts kann, aber wie bei jeder anderen Sprache auch gibt es in Python selbst auch Programmierfehler. Das Auffinden und Vernichten dieser Programmierfehler macht aus Python nur eine noch bessere Sprache.

Das LearnPython.org-Tutorial

Es gibt zu Python viele Tutorials und die meisten erfüllen ihren Zweck auch hervorragend. Allen diesen Tutorials fehlt aber ein bestimmtes Feature, das Sie nur im Tutorial von LearnPython.org unter www.learnpython.org finden – Interaktivität. Statt nur etwas über eine Python-Funktion zu lesen, können Sie dort zuerst lesen und es dann sofort selbst mit dem interaktiven Feature der Seite ausprobieren.

Sie haben schon alle Inhalte der einfachen Tutorials mit diesem Buch durchgearbeitet. Aber die Tutorials mit den komplexeren Themen kennen Sie bisher noch nicht.

Diese Themen umfassen:

Generatoren: Spezielle Funktionen, die Iteratoren zurückgeben

Listenvergleiche: Eine Methode, um neue Listen basierend auf existierenden Listen zu erzeugen

Mehrere Funktionsparameter: Fortsetzung des Themas »Methoden mit variablen Parameterlisten«, das in Kapitel 14 beschrieben wurde

Reguläre Ausdrücke: Strukturen bestehend aus Platzhaltern, die zum Prüfen von bestimmten Zeichenmustern wie Telefonnummern dienen

Ausnahmebehandlung: Fortsetzung des Themas aus Kapitel 9

Mengen: Ein spezieller Listentyp, der niemals doppelte Einträge enthält

Serialisierung: Zeigt, wie man das Datenaustausch- und -speicherformat JavaScript Object Notation (JSON) verwendet

Partielle Funktionen: Eine Technik, um einfachere Funktionen aus komplexeren Funktionen abzuleiten. Haben Sie beispielsweise eine Funktion multipliziere(), die zwei Parameter entgegennimmt, dann kann eine partielle Funktion verdoppeln() so definiert werden, dass sie nur einen Parameter benötigt, der immer mit 2 multipliziert wird.

Codeintrospektion: Ermöglicht Ihnen, Zweck und die Fähigkeiten von Klassen, Funktionen und Schlüsselwörter herauszufinden

Dekorator: Technik, mit der man sehr einfach aufrufbare Objekte, wie Klassen oder Funktionen, mit zusätzlichem Verhalten verändern kann. Man übergibt dem Objekt, zum Beispiel einer Methode methode1(), den Namen methode2 einer anderen Methode, und ruft diese im Code von methode1() auf. Das macht Ihren Code sehr flexibel, da man beispielsweise methode1 je nach Situation eine andere Methode übergeben könnte.

Eine Webanwendung mit Python programmieren

Dieses Buch behandelt die wichtigsten Themen der Programmiergrundlagen und bezieht sich dabei auf Desktop-Anwendungen, da diese sehr einfach zu implementieren und zu verstehen sind. Viele Entwickler spezialisieren sich jedoch auf das Schreiben verschiedenster Webanwendungen mit Python. Die Website Web Programming in Python unter https://wiki.python.org/moin/WebProgramming zeigt Ihnen, wie Sie den Schritt von der Entwicklung von Desktop-Anwendungen hin zu der von Webanwendungen machen. Dort wird nicht nur eine Sorte Webanwendung beschrieben – es werden fast alle erklärt (ein ganzes Buch frei verfügbar). Die Tutorials dort sind in diese drei Hauptgebiete unterteilt:

Server

• Entwicklung von Server-seitigen Anwendungsframeworks

• Common-Gateway-Interface(CGI)-Skripte schreiben

• Serveranwendungen zur Verfügung stellen

• Content-Management-Systeme (CMS) entwickeln

• Datenzugriffsmethoden mit Web-Service-Lösungen entwerfen

Client

• Mit Browsern und Browser-basierten Technologien arbeiten

• Browser-basierte Clients programmieren

• Mit verschiedenen Methoden auf Daten zugreifen, Webdienste eingeschlossen

Außerdem

• Allgemeine Lösungen für Python-basierte Online-Berechnungen

• Mit Datenbankmanagementsystemen (DBMS) arbeiten

• Vorlagen für Anwendungen erstellen

• Intranetlösungen schreiben

Zusätzliche Bibliotheken beschaffen

Die Website Pythonware (www.pythonware.com) sieht erst einmal überhaupt nicht interessant aus, bis Sie mal auf einen der Links klicken. Die Seite bietet Ihnen Zugriff auf eine Vielzahl Bibliotheken von Drittanbietern, mit denen Sie mit Python zusätzliche Aufgaben erledigen können. Zwar führen Sie alle Links zu sehr nützlichen Informationen, aber den Link »Downloads (http://effbot.org/downloads)« sollten Sie sich zuerst anschauen. Diese Downloadseite bietet Ihnen Zugriff auf:

aggdraw: Eine Bibliothek zur Erstellung von Anti-Alias-Zeichnungen
celementtree: Eine Erweiterung für die Bibliothek elementtree, die die Arbeit mit XML-Daten effizienter und schneller macht
console: Eine Windows-Schnittstelle, mit der man bessere Konsolenanwendungen schreiben kann
effbot: Eine Sammlung mit praktischen Erweiterungen und Werkzeugen, einschließlich des EffNews-RSS-Newsreaders
elementsoap: Eine Bibliothek, mit der man Simple Object Access Protocol (SOAP)-Verbindungen zu Webdienstanbietern erstellen kann
elementtidy: Eine Erweiterung für die Bibliothek elementtree, mit der Sie schönere und funktionalere Darstellungen als die Standardansichten für XML-Bäume erstellen können
elementtree: Eine Bibliothek, mit der Sie effizienter als mit den Standardfunktionen in Python mit XML-Daten arbeiten können
exemaker: Ein Werkzeug, mit dem Sie aus Ihrem Python-Skript ein ausführbares Programm erstellen (also eine exe-Datei), sodass Sie das Skript wie jede andere Anwendung auf Ihrem Computer auch ausführen können
ftpparse: Eine Bibliothek für die Arbeit mit FTP-Seiten
grabscreen: Eine Bibliothek, mit der man Screenshots machen kann
imaging: Stellt die Quellcodedistribution für die Python Imaging Library (PIL) zur Verfügung, mit der Sie den Python-Interpreter um Bildverarbeitungsfunktionen erweitern. Mit dem Quellcode können Sie die PIL an Ihre Bedürfnisse anpassen.

pil: Binäre Installationsprogramme für PIL, die Ihnen die saubere Installation auf Ihrem System erleichtern. (Es gibt auch noch andere PIL-basierte Bibliotheken, wie pilfont – eine Bibliothek, um eine PIL-basierte Anwendung um Font-Funktionen zu erweitern.)

pythondoc: Ein Hilfsprogramm, um aus den Kommentaren in Ihrem Python-Code eine Dokumentation zu erzeugen. Funktioniert ähnlich wie JavaDoc.

squeeze: Ein Hilfsprogramm, das Ihre Python-Anwendung, die aus mehreren Dateien besteht, in eine Distribution mit ein oder zwei Dateien packt, die ganz normal mit dem Python-Interpreter ausgeführt werden kann
tkinter3000: Eine Bibliothek, mit der man Widgets in Python programmieren kann und die jede Menge Unterprodukte enthält. Widgets sind im Grunde Codefragmente, die Steuerelemente, wie Schaltflächen, erzeugen, damit man sie in Benutzeroberflächen verwenden kann. Zu der tkinter3000-Bibliothek gibt es viele Erweiterungen, wie wckgraph, mit der man Funktionen zur Diagrammerstellung zu einer Anwendung hinzufügen kann.

Schneller Anwendungen mit einer IDE erstellen

Mit einer integrierten Entwicklungsumgebung (Integrated Development Environment, abgekürzt IDE) können Sie Anwendungen mit einer bestimmten Sprache einfacher erstellen. Die Integrated DeveLopment Environment (IDLE), die mit Python installiert wird, funktionierte für die einfachen Beispiele im Buch sehr gut, aber wenn Sie mit Python größere Projekte angehen, stoßen Sie schnell an ihre Grenzen. Zum Beispiel bietet IDLE nicht die umfassende Debugging-Funktionalität, die viele Entwickler gerne verwenden. Außerdem möchten Sie vielleicht auch grafiklastige Anwendungen programmieren, was mit IDLE sehr schwierig ist.

Sie können mit 50 Entwicklern sprechen und bekommen 50 Meinungen, was das beste Werkzeug für irgendeine Aufgabe ist, und das gilt im Speziellen für IDEs. Jeder Entwickler hat eine Lieblingssoftware und ist nicht leicht zu überzeugen, mal eine andere auszuprobieren. Entwickler verbringen viele Stunden damit, sich in eine bestimmte IDE einzuarbeiten und diese zu erweitern, um sie an ihre Bedürfnisse anzupassen (falls die IDE das zulässt).

Schauen Sie sich zuerst einige IDEs an, bevor Sie sich für eine entscheiden, da es später schwierig ist, sie zu wechseln. (Der gewichtigste Grund, warum man nachträglich nicht die IDE wechseln möchte, ist, dass die Projekttypen inkompatibel sind und Sie das Programmierprojekt bei jedem Wechsel neu erstellen müssten. Aber es ist gibt auch noch viele weitere Gründe, die Sie im Internet nachlesen können.) Das Wiki PythonEditors unter https://wiki.python.org/moin/PythonEditors stellt eine Liste mit vielen IDEs zur Verfügung, die Sie testen können. Die Tabelle listet die Besonderheiten jedes Editors auf, sodass Sie Ihre Auswahl schon im Vorhinein eingrenzen können.

Ihre Syntax einfacher prüfen

Der IDLE-Editor hat ein begrenztes Syntax-Highlighting, das zum Auffinden von Fehlern sehr hilfreich ist. Schreiben Sie beispielsweise ein Schlüsselwort falsch, wechselt er nicht zu der Farbe, die auf Ihrem System für Schlüsselwörter verwendet wird. Da es also keine Änderung gab, wissen Sie direkt Bescheid, dass da etwas nicht stimmt, und können es sofort beheben, statt erst die Anwendung auszuführen und später herauszufinden, dass etwas schiefgelaufen ist (manchmal nach stundenlangem Debugging).

Das Programm python.vim (www.vim.org/scripts/script.php?script_id=790) bietet erweitertes Syntax-Highlighting für den Editor vim (http://www.vim.org), mit dem Sie in Ihrem Python-Skript noch schneller Fehler finden. Diese Datei wird als Skript in vim integriert, sodass sie auf jedem System schnell und einfach verwendet werden kann. Außerdem können Sie den Quellcode nach Belieben ändern, um das Skript an Ihre Bedürfnisse anzupassen.

XML sinnvoll einsetzen

Die eXtensible Markup Language (XML) wird zum Datenaustausch und zur Speicherung aller möglichen Datentypen in vielen unterschiedlichen Anwendungen eingesetzt. Sie haben wahrscheinlich einige XML-Dateien auf Ihrem System und wissen es gar nicht, da XML-Daten unter vielen Dateierweiterungen zu finden sind. Zum Beispiel basieren viele .config-Dateien, die Anwendungseinstellungen enthalten, auf XML. Es ist also nicht die Frage, ob Sie je XML begegnen werden, wenn Sie mit Python arbeiten, sondern eher, wann Sie ihm begegnen werden. XML hat viele Vorteile gegenüber anderen Arten, Daten zu speichern. Zum Beispiel ist XML plattformunabhängig. Sie können XML auf jedem System verwenden und jedes andere System kann es auch lesen, solange ihm das Dateiformat bekannt ist. Durch die Plattformunabhängigkeit wird XML so häufig in Zusammenhang mit anderen Technologien eingesetzt, zum Beispiel bei Webdiensten. Außerdem ist XML sehr leicht zu erlernen, da es einer einfachen Syntax folgt und die Daten selbstbeschreibend sind. Auch Fehler lassen sich leicht finden und beheben, da XML einfach nur Text ist.

Es ist wichtig, etwas über XML selbst zu lernen, und Sie finden dazu unter www.w3schools.com/xml/default.ASP ein einfaches Tutorial. Manche Entwickler sparen sich das und verstehen später dann die Python-spezifischen Sachen nicht, die davon ausgehen, dass man schon einfache XML-Dateien schreiben kann. Die W3School-Seite ist nett, da sie den Lernvorgang in Kapitel wie folgt aufteilt und Sie so häppchenweise mit XML zu arbeiten lernen:

Ein grundlegendes XML-Tutorial

XML-Dateien validieren

XML mit JavaScript verwenden(was erst einmal nicht so wichtig erscheint, aber JavaScript ist in vielen Webanwendungsszenarien sehr stark vertreten)

Einen Überblick über mit XML verwandte Technologien bekommen

Erweiterte XML-Techniken anwenden

Mit XML-Beispielen arbeiten, sodass man XML im Einsatz sieht und besser verstehen kann

Nachdem Sie sich mit den Grundlagen vertraut gemacht haben, brauchen Sie Informationen, wie Sie XML mit Python verwenden. Eine der besseren Seiten, wo Sie diese Informationen finden, ist die Seite Python and XML Processing unter http://pyxml.sourceforge.net/topics. Mit diesen beiden Quellen können Sie sich schnell das nötige Wissen über XML aneignen und in Nullkommanix Python-Anwendungen schreiben, die XML verwenden.

W3School-Seiten sinnvoll nutzen

Eine der meistverwendeten Quellen, um etwas über Webtechnologien zu lernen, ist W3Schools. Sie finden die Startseite unter www.w3schools.com. Über diese Seite finden Sie Informationen zu allen Webtechnologien, die Sie benötigen, um jede beliebige zeitgemäße Webanwendung zu schreiben. Die Themen beinhalten:

HTML

CSS

JavaScript

SQL
jQuery

PHP

XML

ASP.NET

Aber Sie sollten sich bewusst machen, dass das nur ein Ausgangspunkt für Python-Entwickler ist. Sie können die W3School-Seiten verwenden, um ein grundlegendes Verständnis für die jeweilige Technologie zu bekommen, und dann wieder auf Python-spezifische Ressourcen zurückgreifen, um Ihr Wissen auszubauen. Die meisten Python-Entwickler brauchen eine Kombination aus verschiedenen Lernmaterialien, um wirklich gut zu werden.

Die üblichen Anfängerfehler in Python vermeiden

Jeder macht Programmierfehler – sogar der arrogante Typ am Ende des Flurs, der schon seit 30 Jahren programmiert (er hat schon im Kindergarten angefangen). Niemand macht gerne Fehler und manche Leute geben sie auch nicht zu, aber jeder macht sie. Also sollten Sie sich nicht allzu schlecht fühlen, wenn Sie einen Fehler machen. Beheben Sie ihn einfach und machen Sie weiter.

Natürlich ist es etwas anderes, ob Sie einfach einen Fehler machen oder einen vermeidbaren, häufig auftretenden Fehler machen. Ja, sogar die Profis machen alltägliche Fehler, aber das ist sehr viel unwahrscheinlicher, da ihnen in der Vergangenheit solche Fehler schon begegnet sind und sie wissen, dass sie sie vermeiden müssen. Sie können sich gegenüber Ihrer Konkurrenz einen Vorteil verschaffen, indem Sie Anfängerfehler vermeiden, die jeder einmal erfahren muss. Um diese Fehler zu vermeiden, können Sie sich die folgende zweiteilige Serie anschauen:

Python Common Newbie Mistakes, Part 1 (http://blog.amir.rachum.com/blog/2013/07/06/python-common-newbie-mistakes-part-1)

Python Common Newbie Mistakes, Part 2 (http://blog.amir.rachum.com/blog/2013/07/09/python-common-newbie-mistakes-part-2)

Es gibt viele andere Seiten für Leute, die mit Python ihre Programmierkarriere starten, aber diese Seiten sind wirklich kurz gehalten und einfach zu verstehen. Sie können sie in relativ kurzer Zeit lesen, sich dazu etwas für später notieren und diese peinlichen Fehler, an die sich jeder lange erinnert, vermeiden.

Unicode verstehen

Auch wenn dieses Buch versucht, das lästige Thema Unicode zu umgehen, werden Sie wahrscheinlich doch darüber stolpern, wenn Sie richtige Anwendungen schreiben werden. Leider ist Unicode so ein Thema, bei dem ein Komitee entschieden hat, wie Unicode aussehen soll, sodass es nur eine sehr spärliche Definition dafür gibt und jede Menge Standards, um es zu definieren. Das bedeutet im Klartext, dass es keine eindeutige Definition für Unicode gibt.

Bei der Arbeit an etwas komplexeren Python-Anwendungen werden Ihnen sehr viele Unicode-Standards begegnen, speziell dann, wenn Sie mit mehreren Sprachen arbeiten (die jeweils ihre eigene Unicode-Variante bevorzugen). Mit dem Ziel vor Augen, herauszufinden, was Unicode ist, folgen ein paar Seiten, die Sie sich anschauen sollten:

The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!) (http://joelonsoftware.com/articles/Unicode.html)

The Updated Guide to Unicode on Python (http://lucumr.pocoo.org/2013/7/2/the-updated-guide-to-unicode)

Python Encodings and Unicode (http://eric.themoritzfamily.com/pythonencodings-and-unicode.html)

Unicode Tutorials and Overviews (www.unicode.org/standard/tutorial-info.html)

Explain it like I’m five: Python and Unicode? (www.reddit.com/r/Python/comments/1g62eh/explain_it_like_im_five_python_and_unicode)

Unicode Pain (http://nedbatchelder.com/text/unipain.html)

Machen Sie Ihre Python-Anwendung flott

Nichts nervt einen Benutzer schneller als ein langsames Programm. Wenn Ihre Anwendung langsam ist, können Sie damit rechnen, dass Benutzer sie gar nicht verwenden werden. Tatsächlich ist eine schlechte Performance im Firmenumfeld ein gewichtiger Grund für das Scheitern von Anwendungen. Eine Firma kann haufenweise Geld ausgeben, um ein beeindruckendes Programm zu schreiben, das alles macht, was man sich nur vorstellen kann, aber keiner benutzt es, da es zu langsam läuft oder andere schwerwiegende Performanceprobleme hat.

Performance setzt sich eigentlich aus Verlässlichkeit, Sicherheit und Geschwindigkeit zusammen. Viele Entwickler konzentrieren sich nur auf den Geschwindigkeitsteil der Performance, aber erreichen ihr Ziel am Ende doch nicht. Sie müssen sich genau anschauen, welche Ressourcen Ihre Anwendungen benötigen, und müssen die besten Programmiertechniken einsetzen.

Es gibt viele Quellen, die Ihnen Performance im Zusammenhang mit Python-Programmen erklären. Die absolut beste Seite ist jedoch »A guide to analyzing Python performance« unter www.huyng.com/posts/python-performance-analysis. Der Autor erklärt ausführlich, warum etwas ein Performanceengpass ist, und sagt nicht nur, dass es einen gibt. Nachdem Sie diesen Artikel gelesen haben, sollten Sie sich unbedingt auch die PythonSpeed Performance Tips unter https://wiki.python.org/moin/PythonSpeed/PerformanceTips anschauen.

18

Zehn Wege, mit Python Geld zu
verdienen

In diesem Kapitel

Python zur Qualitätsprüfung verwenden

In einem kleineren Unternehmen Ihr eigenes Ding machen

Python für das Skripting in Anwendungen einsetzen

Als Administrator arbeiten

Programmiertechniken demonstrieren

Sich eingehender mit geografischen Daten beschäftigen

Verschiedene Data-Mining-Methoden anwenden

Mit eingebetteten Systemen arbeiten

Wissenschaftliche Daten verarbeiten

Daten in Echtzeit analysieren

Sie können buchstäblich jede gewünschte Anwendung in jeder beliebigen Sprache schreiben, wenn Sie genug Zeit, Geduld und Aufwand investieren. Aber manche Projekte sind so verworren und zeitaufwendig, dass Ihre Frustrationsgrenze schnell erreicht ist. Kurz die meisten (wahrscheinlich sogar alle) Dinge sind möglich, aber nicht alles ist der Mühe wert. In einer Welt, wo Zeit als etwas sehr Wertvolles angesehen wird, das nicht verschwendet werden darf, ist es immer von Vorteil, das richtige Werkzeug für den richtigen Zweck einzusetzen.

Python ist für bestimme Aufgaben hervorragend geeignet und bietet sich daher für bestimmte Programmiermethoden an. Der Job, den Sie bekommen werden, und die Art und Weise, wie Sie Ihren Lebensunterhalt verdienen, ist davon abhängig, welche Programmiertechniken Sie beherrschen. Zum Beispiel ist Python wahrscheinlich nicht so gut geeignet wie C/C++, wenn Sie Gerätetreiber programmieren wollen. Also werden Sie mit Python-Kenntnissen allein wahrscheinlich nicht für einen Hardwarehersteller arbeiten. Zwar kann man mit Python auf Datenbanken zugreifen, aber wenn Sie zusätzlich nicht die Structured Query Language (SQL) beherrschen, werden Sie nicht für große Datenbankprojekte eingesetzt werden. Da Python jedoch eine sehr gute Sprache ist, mit der man Programmieren lernen kann, werden Sie sie häufig im wissenschaftlichen Umfeld finden.

Die folgenden Abschnitte beschreiben einige Berufe, in denen Python regelmäßig eingesetzt wird, damit Sie einen Eindruck davon bekommen, was Sie mit Ihrem neu erworbenen Wissen anfangen können. Natürlich kann ich in diesem Kapitel nicht alle erdenklichen Einsatzgebiete auflisten. Betrachten Sie es einfach als Überblick über die üblichsten.

In der Qualitätssicherung arbeiten

Viele Firmen haben eine eigene Abteilung für die Qualitätssicherung (QS), die Anwendungen testet, ob sie wie angepriesen funktionieren. Es gibt viele Testskriptsprachen, aber auch Python ist dafür sehr gut geeignet, da es so unglaublich flexibel ist. Außerdem können Sie die Sprache in vielen Umgebungen einsetzen – sowohl auf dem Client als auch auf dem Server. Haben Sie die Sprache einmal erlernt, ermöglicht Ihnen Pythons breites Spektrum, es in jeder Umgebung und überall dort zum Testen einzusetzen, wo Sie etwa testen müssen.

In diesem skizzierten Szenario können die Entwickler meist noch eine andere Sprache, zum Beispiel C++, und verwenden Python, um die in C++ geschriebenen Anwendungen zu testen. Der Mensch aus der QS muss im Großen und Ganzen aber keine andere Sprache kennen. Manchmal werden Blindtests verwendet, um zu bestätigen, dass eine Anwendung in der Praxis gut funktioniert oder um die Funktionsweise eines externen Dienstanbieters zu prüfen. Sie müssen mit der Firma, mit der Sie zusammenarbeiten wollen, abklären, welche Qualifikationen bezüglich der Sprache an einen Job gestellt werden.

Warum Sie mehrere Programmiersprachen kennen müssen

Die meisten Firmen erachten es als großen Vorteil, wenn man mehrere Programmiersprachen beherrscht (manche finden sogar, dass es ein Muss ist). Wenn Sie ein Arbeitgeber sind, möchten Sie natürlich den oder die Beste als Mitarbeiter auswählen. Beherrschen Sie mehrere Programmiersprachen, haben Sie eine größere Auswahl an Jobs und sind für eine Firma wertvoller. Anwendungen in einer anderen Sprache noch einmal neu zu schreiben, ist sehr zeitaufwendig, fehleranfällig und teuer, und daher suchen Firmen Leute, die an einer Anwendung in der vorhandenen Sprache arbeiten können, statt sie von Grund auf neu zu schreiben.

Aus Ihrer Warte heraus bedeutet die Kenntnis mehrere Sprachen, dass Sie interessantere Jobs bekommen und die Wahrscheinlichkeit geringer ist, dass Sie jeden Tag dieselbe langweilige Arbeit machen müssen. Außerdem verringert das Beherrschen mehrerer Sprachen die Frustration. Viele große Anwendungen setzen sich heutzutage aus Komponenten zusammen, die in vielen verschiedenen Sprachen geschrieben wurden. Damit Sie die Anwendung und wie sie funktioniert, besser verstehen können, müssen Sie jede Sprache, mit der die Anwendung geschrieben wurde, kennen.

Es ist auch einfacher für Sie, eine neue Sprache zu erlernen, wenn Sie schon mehrere Sprachen beherrschen. Nach einer Weile werden Sie Muster erkennen, wie Programmiersprachen aufgebaut sind, wodurch Sie die Grundlagen überspringen und direkt mit den fortgeschrittenen Themen starten können. Je schneller Sie sich neue Technologien aneignen können, desto größer sind Ihre Chancen, in den wirklich interessanten Gebieten der Informatik zu arbeiten. Zusammengefasst bedeutet das, je mehr Sprachen Sie beherrschen, desto mehr Türen stehen Ihnen offen.

IT-Mitarbeiter in einer kleinen Firma werden

Eine kleine Firma hat meist nur ein oder zwei IT-Mitarbeiter, die ein breites Spektrum an Aufgaben schnell und effizient erledigen müssen. Mit Python können Sie Hilfsprogramme und betriebsinterne Anwendungen sehr flott schreiben. Zwar könnte Python die Anforderungen einer großen Firma nicht erfüllen, da es interpretiert ist (und daher potenziell anfällig für Diebstahl und Bastelei durch unfähige Mitarbeiter), es kann aber in einer kleinen Firma sehr sinnvoll eingesetzt werden, da Sie besser kontrollieren können, wer darauf zugreift, und Sie schnell Änderungen machen können. Da man Python in vielen verschiedenen Umgebungen einsetzen kann, wird außerdem der Bedarf, andere Programmiersprachen für ihre Zwecke einzusetzen, geringer.

Manchen Entwicklern ist gar nicht klar, dass Python in manchen nicht so offensichtlichen Produkten verwendet wird. Zum Beispiel können Sie Python-Skripte zwar nicht direkt mit dem Internet Information Server (IIS) verwenden, aber Sie können mit den Schritten, die im Knowledge-Base-Artikel unter http://support.microsoft.com/kb/276494 beschrieben werden, den IIS mit einem Trick für Python-Skripte konfigurieren. Sollten Sie sich unsicher sein, ob eine bestimmte Anwendung mit Python funktioniert, sollten Sie dies erst im Internet nachschauen.

Spezialskripte für Anwendungen schreiben

Eine Vielzahl an Anwendungen verwendet Python als Skriptsprache. In Maya (www.autodesk.com/products/autodesk-maya/overview) können Sie beispielsweise Skripte mit Python programmieren. Wenn Sie wissen, welche Produkte Python verwenden, können Sie sich eine Arbeit, bei der diese Produkte eingesetzt werden, in jedem beliebigen Bereich suchen. Im Folgenden finden Sie ein paar Beispiele für Produkte, die Python als Skriptsprache verwenden:

3ds Max

Abaqus

Blender

Cinema 4D

GIMP

Google App Engine

Houdini

Inkscape

Lightwave

Modo

MotionBuilder

Nuke

Paint Shop Pro

Scribus

Softimage

Das ist nur die Spitze des Eisbergs. Sie können Python auch mit dem GNU-Debugger verwenden, um komplexe Strukturen, wie die in C++-Containern, verständlicher auszugeben. Manche Computerspiele basieren auch auf Python als Skriptsprache. Zusammengefasst ist es also möglich, dass Sie Ihren Lebensunterhalt mit dem Schreiben von Anwendungsskripten mit Python als Skriptsprache verdienen können.

Ein Netzwerk administrieren

Nicht wenige Administratoren setzen Python ein, um ihr Netzwerk zu überwachen oder Hilfsprogramme zu schreiben, die bestimmte Aufgaben automatisieren. Administratoren haben oft wenig Zeit und daher ist alles, was sie automatisieren können, eine große Hilfe. Tatsächlich sind viele Programme für die Netzwerkadministration in Python geschrieben, so zum Beispiel Trigger (http://trigger.readthedocs.org/en/latest). Viele dieser Tools sind quelloffen und stehen kostenlos zum Download zur Verfügung, sodass Sie sie in Ihrem Netzwerk mal ausprobieren können. Es gibt auch ein paar interessante Artikel, die die Verwendung von Python zur Netzwerkadministration diskutieren, wie »Intro to Python & Automation for Network Engineers« unter http://packetpushers.net/show-176-intro-to-pythonautomation-for-network-engineers. Sie können Ihre Arbeitsbelastung erheblich reduzieren und sich viele Aufgaben erleichtern, wenn Sie wissen, wie Sie Python effektiv für Ihr Netzwerk einsetzen können. Wenn Sie sich mal Skripte anschauen möchten, die zur Netzwerkadministration gedacht sind, finden Sie 25 Skripte in der Kategorie »Network Management« unter http://freecode.com/tags/network-management.

Programmierkenntnisse vermitteln

Viele Lehrer suchen nach einer schnelleren, konsistenteren Methode, um Computerwissen zu vermitteln. Der Raspberry Pi (www.raspberrypi.org) ist ein Einplatinencomputer, der die Anschaffung der benötigten Ausstattung für Schulen sehr viel günstiger macht. Die kleinen Geräte kann man an einen Fernseher oder Computermonitor anschließen und so die komplette Funktionalität eines Computers mit unglaublich einfachem Aufbau nutzen. Interessanterweise spielt Python eine große Rolle dabei, aus dem Raspberry Pi eine Lehr- und Lernplattform zur Vermittlung von Programmierkenntnissen zu machen (https://www.raspberrypi.org/picademy).

Im Alltag verwenden Lehrer Python oft, um die ursprünglichen Fähigkeiten des Raspberry Pi so zu erweitern, dass er verschiedene interessante Aufgaben erledigen kann (www.raspberrypi.org/tag/python). Das Projekt mit dem Titel »Boris, the Twitter Dino-Bot« (www.raspberrypi.org/boris-the-twitter-dino-bot) ist besonders interessant. Haben Sie auch ein bestimmtes Lernziel vor Augen, dann ist die Kombination aus Raspberry Pi und Python fantastisch dafür geeignet.

Leuten dabei helfen, einen bestimmten Ort zu finden

Ein Geografisches Informationssystem (GIS) bietet die Möglichkeit, geografische Informationen mit Geschäftsanforderungen zu verbinden. Zum Beispiel könnten Sie ein GIS verwenden, um den besten Ort für eine neue Zweigstelle oder eine optimale Transportroute für Waren zu bestimmen. Aber GIS werden für noch ganz andere Dinge als die Auswahl eines Ortes verwendet – sie können geografische Informationen viel besser als Karten, Berichte und andere Grafiken vermitteln und stellen eine Methode zur Präsentation von geografischen Orten für andere dar. Es ist auch sehr interessant, dass viele GIS-Produkte Python als die Sprache der Wahl betrachten. Es gibt aktuell jede Menge Python-spezifischer Informationen zum Thema GIS, zum Beispiel:

The GIS and Python Software Laboratory (http://gispython.org)

Python and GIS Resources (www.gislounge.com/python-and-gis-resources)

GIS Programming and Automation (https://www.e-education.psu.edu/geog485/node/17)

Viele GIS-spezifische Produkte, wie ArcGIS (www.esri.com/software/arcgis), verwenden Python zur Automatisierung von Aufgaben. Es gibt ganze Communitys, die solche Software-Angebote entwickeln, wie Python for ArcGIS (http://resources.arcgis.com/de/communities/python). Sie können Ihre neuen Programmierkenntnisse also noch in anderen Gebieten als der reinen Datenverarbeitung einsetzen, um damit Geld zu verdienen.

Data Mining verwenden

Jeder sammelt Daten über jeden und alles. Es ist unmöglich, sich durch die Berge aus Daten zu wühlen ohne jede Menge genau abgestimmte Automationsprozesse. Durch seine flexible Art, kombiniert mit seiner prägnanten Sprache, mit der Änderungen schnell umgesetzt sind, ist Python der Favorit für Leute, die tagtäglich Data Mining verwenden. Sie finden zu diesem Thema unter http://guidetodatamining.com ein Buch im Internet, »A Programmer’s Guide to Data Mining«. Python vereinfacht Data-Mining-Aufgaben sehr. Der Zweck des Data Minings ist es, Trends zu erkennen, indem in den Daten nach verschiedenen Mustern gesucht wird. Die Verwendung von künstlicher Intelligenz in Python ermöglicht diese Mustererkennung. Ein Artikel zum Thema »Data Mining: Discovering and Visualizing Patterns with Python« (http://refcardz.dzone.com/refcardz/data-mining-discovering-and) erklärt Ihnen, wie eine solche Analyse funktioniert. Sie können Python verwenden, um ein Werkzeug zu erstellen, das ein Muster für Verkäufe erkennt, die Ihr Konkurrent verpasst hat.

Sicher ist Data Mining noch für andere Dinge geeignet, als den Verkauf anzukurbeln. Zum Beispiel verwendet man Data Mining, um neue Planeten um Sterne herum zu finden, oder für andere Aufgaben, die unser Wissen über das Universum erweitern. Python ermöglicht auch diese Art des Data Minings. Sie finden zu jeder Art von Data Mining, das Sie gerne machen wollen, jede Menge Bücher und andere Literatur, in denen Python als die Sprache der Wahl erwähnt wird.

Mit eingebetteten Systemen arbeiten

Für nahezu jede Aufgabe auf dieser Erde gibt es ein eingebettetes System. Besitzen Sie beispielsweise ein programmierbares Thermostat für Ihr Haus, interagieren Sie schon mit einem eingebetteten System. Der Raspberry Pi (er wurde etwas weiter vorne in diesem Kapitel schon erwähnt) ist ein Beispiel für ein etwas komplexeres eingebettetes System. Viele eingebettete Systeme verwenden Python als Programmiersprache. Es gibt auch eine spezielle Variante von Python, Embedded Python (https://wiki.python.org/moin/EmbeddedPython), die manchmal für diese Geräte eingesetzt wird. Es gibt sogar eine YouTube-Präsentation darü-ber, wie man mit Python ein eingebettetes System baut (www.youtube.com/watch?v=WZoeqnsY9AY).

Vielleicht verwenden Sie ja schon ein Python-basiertes eingebettetes System. Viele Sicherheitssysteme in Autos sind beispielsweise in Python programmiert (http://pythoncarsecurity.com). Vielleicht haben Sie ein Fernstartsystem, das auf Python basiert. Ihr Heimautomatisierungs- und Haussicherheitssystem (http://linuxjournal.com/article/8513) könnte auch mit Python geschrieben sein.

Python wird sehr gerne für eingebettete Systeme verwendet, da es nicht kompiliert werden muss. Ein Hersteller für eingebettete Systeme kann für jedes eingebettete System eine Aktualisierung erstellen und einfach nur die Python-Datei auf das Gerät kopieren. Der Interpreter verwendet automatisch diese Datei, ohne dass irgendwelche neuen ausführbaren Dateien hochgeladen oder irgendwelche aufwendigen Prozeduren, die andere Sprachen erfordern, durchlaufen werden müssen.

Wissenschaftliche Aufgaben erledigen

Python scheint sehr viel mehr Zeit als andere Programmiersprachen wissenschaftlichen und numerischen Berechnungsaufgaben zu widmen. Die Anzahl der wissenschaftlichen und numerischen Berechnungswerkzeuge ist überwältigend (https://wiki.python.org/moin/NumericAndScientific). Wissenschaftler lieben Python, da es klein, einfach zu erlernen und trotzdem sehr präzise bei der Datenverarbeitung ist. Man kann mit nur wenigen Zeilen Code schon Ergebnisse produzieren. Natürlich könnten Sie dieselben Ergebnisse auch in anderen Sprachen erreichen, aber andere Sprachen enthalten vielleicht keine vorgefertigten Module für diese Aufgabe und sie würden definitiv mehr Zeilen Code erfordern, auch wenn diese vorhanden wären.

Für die beiden Disziplinen Raumfahrt und Biowissenschaften gibt es spezielle Python-Module. Zum Beispiel gibt es ein spezielles Modul zum Bereich Solarphysik. Sie finden auch ein Modul zum Thema Genombiologie. Es ist sehr wahrscheinlich, dass Sie, wenn Sie in der Wissenschaft arbeiten, mit Ihren Python-Kenntnissen schnell Ergebnisse erzielen können, während Ihre Kollegen immer noch überlegen, wie sie die Daten analysieren können.

Datenanalyse in Echtzeit ausführen

Entscheidungen erfordern, dass man aktuelle, verlässliche und genaue Daten hat. Häufig kommen diese Daten aus vielen unterschiedlichen Quellen und müssen zunächst analysiert werden, bevor sie sinnvoll eingesetzt werden können. Viele Leute im Management geben an, dass sie Python einsetzen. Sie verwenden Python, um die verschiedenen Informationsquellen zu untersuchen, die nötigen Analysen durchzuführen, um dann dem Manager, der die Informationen haben wollte, einen Überblick zu präsentieren. Da diese Aufgabe regelmäßig ansteht, wäre eine manuelle Ausführung zu zeitaufwendig. Im Grunde wäre es einfach Zeitverschwendung. In der Zeit, in der der Manager die erforderliche Arbeit erledigt, kann der Zeitpunkt für die Entscheidung schon verpasst worden sein. Python erledigt solche Aufgaben schnell genug, sodass Entscheidungen den größtmöglichen Effekt erzielen.

Vorhergehende Abschnitte erwähnten schon Pythons Fähigkeiten in den Bereichen Data Mining, Mathematik und Grafik. Ein Manager kann all diese Dinge in einer Sprache kombinieren, die nicht so schwer zu erlernen ist wie C++. Außerdem kann man sehr einfach Änderungen umsetzen und der Manager braucht keine Programmierkenntnisse, zum Beispiel für das Kompilieren der Anwendung. Ein paar Änderungen an einer Zeile Code in einem interpretierten Modul reichen meist, um die Aufgabe zu erledigen.

Wie bei den anderen Berufszweigen in diesem Kapitel sollten Sie auch hier über den Tellerrand hinausschauen, wenn Sie eine Arbeit in diesem Bereich suchen. Viele Leute brauchen Echtzeitanalysen. Viele Tätigkeiten, wie das Schießen einer Rakete ins All, die Steuerung einer Produktionsstraße oder die pünktliche Lieferung eines Paketes, brauchen aktuelle, verlässliche und genaue Daten. Sie können sich vielleicht Ihren eigenen Arbeitsplatz schaffen, indem Sie Python einfach zum Ausführen von Echtzeitdatenanalysen einsetzen.

19

Zehn interessante Tools

In diesem Kapitel

Programmfehler dokumentieren

Einen sicheren Ort zum Testen von Anwendungen schaffen

Ihre Anwendung auf einem Benutzersystem installieren

Ihre Anwendung dokumentieren

Ihren eigenen Anwendungscode schreiben

Programmfehler suchen

Mit einer interaktiven Umgebung arbeiten

Eine Anwendung testen

Die import-Anweisungen in Ihrer Anwendung sortieren

Programmversionen nachhalten

Wie für viele andere Programmiersprachen auch gibt es für Python viele verschiedene Tools von Drittanbietern. Ein Tool oder Werkzeug ist jedes Hilfsprogramm, das die ursprünglichen Fähigkeiten von Python bei der Anwendungsentwicklung erweitert. Ein Debugger ist zum Beispiel ein Werkzeug, da es ein Hilfsprogramm ist, eine Bibliothek ist keins. Bibliotheken werden stattdessen gebraucht, um bessere Anwendungen schreiben zu können. (Sie finden einige davon in Kapitel 20.)

Aber die Unterscheidung zwischen Werkzeugen und den Dingen, die keine sind, wie Bibliotheken, verkürzen die Liste nicht besonders. Für Python gibt es erfreulicherweise eine große Auswahl an Allzweck- und Spezialwerkzeugen jeglicher Art. Die Seite https://wiki.python.org/moin/DevelopmentTools teilt die Tools in 13 verschiedene Kategorien auf:

Automatisierte Tools zur Refaktorierung

Bug Tracking

Konfigurations- und Build-Tools

Tools zur Auslieferung von Software

Dokumentationswerkzeuge

Integrierte Entwicklungsumgebungen

Python-Debugger

Python-Editoren

Python-Shells

Verzeichnis-Tools

Tools zum Testen von Software

Praktische Module

Versionskontrolle

Es kann durchaus möglich sein, dass die Listen auf der Python-Seite noch nicht einmal vollständig sind. Im Internet werden Sie aber noch weitere Python-Tools finden.

Da ein einziges Kapitel unmöglich alle existierenden Tools behandeln kann, beschreibt dieses Kapitel ein paar der interessanteren – solche, die Ihre Aufmerksamkeit auch verdienen. Nachdem dieses Kapitel Ihnen den Mund wässrig gemacht hat, sollten Sie sich auch im Internet nach weiteren Tools umtun. Vielleicht finden Sie heraus, dass das Tool, das Sie eigentlich selbst schreiben wollten, schon existiert und das sogar in verschiedenen Varianten.

Programmfehler mit dem Roundup Issue Tracker dokumentieren

Für Python gibt es einige Seiten, die zusätzlich einen Bug Tracker oder Issue Tracker (ein Werkzeug zum Dokumentieren und Nachverfolgen von Programmfehlern) anbieten, zum Beispiel die folgenden: Github (https://github.com), BitBucket (https://bitbucket.org) und Launchpad (https://launchpad.net). Diese öffentlich verfügbaren Seiten sind aber meist nicht so komfortabel wie Ihre eigene lokal installierte Bug-Tracking-Software. Auch da steht Ihnen einige Software zur Auswahl, aber der Roundup Issue Tracker (http://roundup.sourceforge.net) ist einer der besseren der angebotenen Programme. Roundup sollte auf jedem System, das auch Python unterstützt, funktionieren und bietet die folgenden Features ohne jeglichen Zusatzaufwand:

Fehlerdokumentation und -nachverfolgung

Verwaltung von TODO-Listen

Wenn Sie bereit sind, noch etwas mehr Arbeit in die Installation zu investieren, stehen Ihnen auch noch weitere Features zur Anpassung der Software zur Verfügung. Damit Sie diese aber verwenden können, müssen Sie eventuell noch andere Programme installieren, wie ein Datenbankmanagementsystem (DBMS). Die Installationsanleitungen zum Produkt erklären Ihnen, was Sie installieren müssen und welche Produkte von welchen Drittanbietern kompatibel sind. Nachdem Sie diese zusätzlichen Dinge installiert haben, stehen Ihnen folgende Funktionen zur Verfügung:

Helpdesk-Unterstützung mit den folgenden Features:

• Assistent für den Telefon-Support

• Verbindung zu anderen Issue Trackern für Netzwerke, Produktivsysteme und in der Entwicklung

Fehlerverwaltung für Internet Engineering Task Force (IETF)-Arbeitsgruppen

Dokumentation von Kundenkontakten und Geschäftsmöglichkeiten

Übermittlung von Konferenzartikeln und deren Verwaltung für ein doppelblindes Review-Verfahren

Blogging (noch sehr rudimentär, aber es wird noch ausgebaut)

Eine virtuelle Umgebung mit VirtualEnv erstellen

Es gibt mannigfaltige Gründe, warum man eine virtuelle Umgebung braucht, aber der Hauptgrund, um dies mit Python zu tun, ist das Schaffen einer sicheren und bekannten Testumgebung. Wenn Sie stets dieselbe Testumgebung verwenden, bieten Sie Ihrer Anwendung eine stabile Umgebung, bis Sie die Anwendung so weit haben, dass man sie in einer Produktivumgebung testen kann. VirtualEnv (https://pypi.python.org/pypi/virtualenv) ermöglicht es Ihnen, eine virtuelle Python-Umgebung zu erstellen, die Sie für die ersten Tests verwenden können oder um Fehler nachzuvollziehen, von denen Sie glauben, dass sie aufgrund der Umgebung auftreten. Sie sollten sich gut merken, dass es beim Testen mindestens drei Standardstufen gibt, die Sie durchlaufen müssen:

Programmfehler: Nach Fehlern in Ihrer Anwendung suchen.

Performance: Sicherstellen, dass Ihre Anwendung die Anforderungen bezüglich Geschwindigkeit, Verlässlichkeit und Sicherheit erfüllt.

Bedienbarkeit: Prüfen, ob Ihre Anwendung den Benutzerbedürfnissen entspricht und adäquat auf Benutzereingaben reagiert.

Aufgrund der Art und Weise, wie die meisten Python-Programme verwendet werden (Sie finden ein paar Ideen dazu in Kapitel 18), müssen Sie sie meist nicht in virtuellen Umgebungen ausführen, wenn Ihre Anwendung schon im produktiven Einsatz ist. Die meisten Python-Programmen müssen auf Dinge außerhalb des ausführenden Computers zugreifen und die Isolation in einer virtuellen Umgebung würde das verhindern.

Testen Sie niemals auf einem Produktivsystem

Manche Entwickler machen den Fehler, ihre unveröffentlichte Anwendung auf einem Produktivserver zu testen, auf den der Benutzer leicht Zugriff hat. Der gewichtigste Grund, niemals auf einem Produktivsystem zu testen, ist der mögliche Datenverlust. Wenn Sie Benutzer Zugriff auf eine unveröffentlichte Version Ihrer Anwendung gewähren, die Fehler enthält, die die Datenbank oder andere Datenquellen betreffen, könnten Daten verloren gehen oder nachhaltig beschädigt werden.

Außerdem sollten Sie daran denken, dass Sie immer nur eine Chance für den ersten Eindruck bekommen. Viele Software-Projekte scheitern, weil Benutzer das letztendliche Ergebnis nicht verwenden. Die Anwendung ist fertig, aber keiner benutzt sie, da die Benutzer den Eindruck haben, dass die Anwendung in irgendeiner Weise fehlerhaft ist.

Benutzer haben nur ein Ziel im Sinn: ihre Arbeit zu erledigen und dann nach Hause zu gehen. Sind Benutzer der Auffassung, dass eine Anwendung sie zu viel Zeit kostet, verwenden sie sie nicht.

Unveröffentlichte Anwendungen können auch Sicherheitslücken enthalten, die ruchlose Individuen ausnutzen könnten, um sich Zugang zu Ihrem Netzwerk zu verschaffen. Ihre Sicherheitssoftware kann noch so gut funktionieren, wenn Sie die Tür für jedermann offen stehen lassen. Nachdem sie dann drin sind, ist es fast unmöglich, sie wieder loszuwerden, und selbst wenn Sie sie wieder loswerden, ist der Schaden an Ihren Daten schon passiert. Sich von Sicherheitslücken zu erholen, ist bekanntermaßen schwierig – und manchmal unmöglich. Kurzum sollten Sie niemals auf einem Produktivsystem testen, da die Kosten dafür viel zu hoch sind.

Ihre Anwendung mit PyInstaller installieren

Benutzer möchten mit der Installation ihrer Anwendung nicht viel Zeit verbringen, egal wie hilfreich sie für sie am Ende auch ist. Auch wenn Benutzer tatsächlich einen Installationsversuch wagen, werden weniger erfahrene sehr wahrscheinlich scheitern. Sie brauchen also eine bombensichere Methode, um Ihre Anwendung von Ihrem System auf das System des Benutzers zu bringen. Installationsprogramme, wie PyInstaller (www.pyinstaller.org), bieten genau das. Sie machen aus Ihrem Programm ein nettes Paket, das der Benutzer sehr einfach installieren kann.

Glücklicherweise funktioniert PyInstaller auf allen Systemen, die Python auch unterstützt. So brauchen Sie nur dieses eine Programm, um alle Ihre Anforderungen an eine Installation zu erfüllen. Außerdem stellt PyInstaller bei Bedarf auch plattformspezifische Unterstützung zur Verfügung. Arbeiten Sie beispielsweise mit einem Windows-System, können Sie digital signierte exe-Dateien erzeugen. Mac-Entwickler werden glücklich sein, dass PyInstaller auch Bundles unterstützt, also auch app-Dateien erzeugen kann. Sie sollten plattformspezifische Features aber nur dann verwenden, wenn Sie Ihr Programm auf einem bestimmten System ausführen wollen, da das Installationsprogramm dann nur darauf funktionieren wird.

Viele Tools zur Erstellung von Installationsprogrammen im Internet sind plattformspezifisch. Wenn Sie ein Tool finden, wo nur exe-Dateien erwähnt werden, kann es sein, dass diese nur auf einem bestimmten System laufen und nicht auf allen Systemen, die Sie unterstützen wollen. Sie sollten sich also ein Tool suchen, das Installationsprogramme für alle Systeme erzeugen kann, für die Sie Ihre Anwendung anbieten wollen. Ihnen hilft eine plattformunabhängige Sprache nichts, wenn Sie kein Installationsprogramm haben, das Sie auf verschiedenen Systemen ausführen können.

Vermeiden Sie nicht mehr unterstützte Produkte

Im Internet gibt es immer Python-Tools, die vom Entwickler nicht mehr aktiv weiterentwickelt werden. Andere Entwickler nutzen diese Tools immer noch, da sie die Features und die Art, wie die Programme funktionieren, mögen. Die Verwendung alter Tools ist aber immer risikoreich, da Sie nie sicher sein können, dass das Tool mit einer neuen Version von Python noch funktioniert. Am besten, Sie halten sich bei der Tool-Auswahl immer an solche, die vollständig vom Entwickler oder Hersteller unterstützt werden. Müssen Sie ein veraltetes Tool doch unbedingt verwenden (wenn es beispielsweise das Einzige ist, das diese Aufgabe erledigen kann), sollten Sie sich erkundigen, ob es noch durch die Community, also durch andere Anwender, aktiv unterstützt wird. Den Hersteller gibt es vielleicht nicht mehr, aber zumindest können Ihnen andere Anwender helfen, wenn Sie mal Probleme haben. Andernfalls werden Sie viel Zeit mit einem veralteten Produkt verschwenden, das Sie vielleicht nie richtig ans Laufen bekommen.

Eine Entwicklerdokumentation mit pdoc erzeugen

Für Programme gibt es zwei verschiedene Dokumentationsarten: eine Benutzer- und eine Entwicklerdokumentation. Die Benutzerdokumentation (auch Handbuch oder Bedienungsanleitung genannt) zeigt, wie man die Anwendung verwendet, während die Entwicklerdokumentation beschreibt, wie die Anwendung funktioniert. Eine Bibliothek benötigt nur eine Dokumentationsart, die Entwicklerdokumentation, während eine Desktop-Anwendung zusätzlich auch eine Benutzerdokumentation haben sollte. Ein Dienst kann auch beides haben, je nachdem, wer ihn benutzen soll und wie er aufgebaut ist. Der Hauptteil Ihrer Dokumentation wird wahrscheinlich die Entwickler betreffen und pdoc (https://github.com/BurntSushi/pdoc) ist ein einfaches Tool, um sie zu erzeugen.

Das Programm pdoc verwendet die Dokumentation, die Sie in Ihren Code in Form von Dokumentationsstrings und Kommentaren schreiben. Ausgabe ist eine Textdatei oder ein HTML-Dokument. Sie können pdoc auch so konfigurieren, dass die Ausgabe an einen Webserver weitergeleitet wird, sodass die Entwickler sich die Dokumentation direkt im Browser anschauen können. pdoc ersetzt quasi epydoc, das von seinem Entwickler nicht mehr weiterentwickelt wird.

Anwendungscode mit PyCharm entwickeln

Einige Kapitel des Buches haben sich schon mit Integrierten Entwicklungsumgebungen (IDEs) befasst, aber nirgendwo gab es eine konkrete Empfehlung. Die von Ihnen gewählte IDE hängt im Wesentlichen von Ihren Anforderungen als Entwickler, Ihrem Kenntnisstand und der Art der Programme ab, die Sie entwickeln wollen. Manche IDEs sind für bestimmte Anwendungstypen besser geeignet als andere. Eine sehr gute Allzweck-IDE ist PyCharm (https://www.jetbrains.com/pycharm). Sie können diese IDE gratis herunterladen. Sie enthält eine Vielzahl an Features, die Ihnen die Anwendungsentwicklung sehr viel leichter von der Hand gehen lässt, als das bei IDLE der Fall ist. PyCharm bietet unter anderem die folgenden Features:

Autovervollständigung und automatische Code-Formatierung inklusive Einrückung

Einen vollwertigen Debugger

Refactoring

Verwaltung von Projekten, sodass schon manche Dinge für eine Anwendung automatisch erzeugt werden, bevor Sie überhaupt mit der Programmierung angefangen haben.

Code-Schnipsel, die als Vorlage für Code-Blöcke verwendet werden können.

PyCharm steht in einer frei verfügbaren Community Edition und einer Professional Edition zur Verfügung, wobei Letztere noch zusätzliche Funktionalität, wie Remote Entwicklung oder Unterstützung für weitere Programmiersprachen anbietet.

Ihre Anwendung mit pydbgr debuggen

In einer vollwertigen IDE, wie PyCharm, ist ein kompletter Debugger schon integriert. Haben Sie allerdings einen einfachen Lieblingseditor, wie Komodo Edit, gehört ein Debugger wahrscheinlich nicht zu der Standardausstattung. Ein Debugger hilft Ihnen dabei, Programmfehler in Ihrer Anwendung zu finden und zu beheben. Je besser Ihr Debugger, desto weniger Aufwand haben Sie, um den Fehler zu finden und zu beheben. Enthält Ihr Editor keinen Debugger, müssen Sie einen externen wie pydbgr (https://code.google.com/p/pydbgr) verwenden.

Ein halbwegs passabler Debugger enthält einige Standard-Features, wie das Setzen von Haltepunkten, bedingtes Anhalten oder Logging. Es gibt aber auch darüber hinaus einige Eigenschaften, die einen Debugger von anderen unterscheidet. Im Folgenden finden Sie ein paar Funktionen, die pydbgr empfehlenswert machen, sollte Ihr Editor keinen Debugger besitzen:

Schlaues eval: Der Befehl eval zeigt Ihnen, was passieren wird, wenn Sie eine bestimmte Zeile Code ausführen, bevor diese in der eigentlichen Anwendung ausgeführt wird. Es macht also eine »Was wäre, wenn«-Analyse, die einen Hinweis darauf geben kann, was in der Anwendung schiefläuft.

Out-of-Process-Debugging: Normalerweise debuggen Sie Anwendungen, die auf demselben System ausgeführt werden. Der Debugger ist eigentlich ein Teil des Anwendungsprozesses, sodass er in die Ausführung eingreifen kann. Out-of-Process-Debugging bedeutet, dass der Debugger die Anwendung nicht beeinflusst und Sie die Anwendung noch nicht einmal auf demselben System ausführen müssen.

Intensives Untersuchen des Bytecodes: Manchmal kann es bei schwierigen Problemen helfen, sich anzuschauen, wie der von Ihnen geschriebene Code in Bytecode (der Code, den der Python-Interpreter eigentlich versteht) übersetzt wird.

Ereignisfilterung und -verfolgung: Während Ihre Anwendung im Debugger ausgeführt wird, generiert sie Ereignisse, die dem Debugger mitteilen, was gerade passiert. Zum Beispiel verursacht die Ausführung der nächsten Codezeile ein Ereignis, das Zurückkehren aus einem Funktionsaufruf erzeugt auch ein Ereignis und so weiter. Diese Funktionalität kontrolliert, wie der Debugger durch eine Anwendung wandert und auf welche Ereignisse er reagiert.

Eine interaktive Umgebung mit IPython betreten

Die Python-Shell ist für viele interaktive Aufgaben sehr gut geeignet. Sie haben sie in diesem Buch intensiv genutzt. Ihnen wird aber sicher schon aufgefallen sein, dass die Standard-Shell gewisse Schwächen hat (und wenn es Ihnen noch nicht aufgefallen ist, werden Sie es beim Durcharbeiten der etwas komplexeren Beispiele merken). Der größte Mangel ist natürlich, dass die Python-Shell eine reine textbasierte Umgebung ist, in der Sie Befehle eingeben müssen, um irgendeine Aufgabe auszuführen. Eine etwas höher entwickelte Shell, wie IPython (http://ipython.org), bietet mit einer grafischen Benutzeroberfläche eine komfortablere interaktive Umgebung, sodass Sie sich nicht die Syntax für irgendwelche langweiligen Befehle merken müssen.

IPython ist eigentlich mehr als eine einfache Shell. Es bietet eine Umgebung, in der Sie mit Python auf ganz neue Art und Weise interagieren können, wie die grafische Darstellung von Rechenergebnissen, die Sie mit Python erzeugt haben. Außerdem wurde IPython als Frontend für weitere Sprachen entworfen. Die IPython-Shell sendet in Wirklichkeit im Hintergrund die Befehle an die eigentliche Shell, sodass Sie auch Shells anderer Sprachen, wie Julia und Haskell verwenden können. (Machen Sie sich keine Gedanken, wenn Sie noch nie von diesen Sprachen gehört haben.)

Eine spannende Besonderheit von IPython ist die Möglichkeit, in Parallelrechenumgebungen zu arbeiten. Normalerweise wird eine Shell in einem einzigen Thread ausgeführt, sodass keine parallele Verarbeitung von Befehlen möglich ist. Das bedeutet, dass Sie auch keine Multithreading-Umgebung ausführen können. Schon deshalb lohnt es sich, IPython mal auszuprobieren.

Anwendungen mit PyUnit testen

Irgendwann müssen Sie Ihre Anwendungen testen, damit Sie wissen, dass sie wie beabsichtigt funktionieren. Sie können sie testen, indem Sie einen Befehl nach dem anderen eingeben und das Ergebnis prüfen, oder Sie können diesen Vorgang automatisieren. Offensichtlich ist der automatische Ansatz besser, da Sie ja auch irgendwann mal zum Abendessen nach Hause gehen wollen und das manuelle Testen wirklich, wirklich lange dauert (insbesondere, wenn Sie Fehler machen, was sehr wahrscheinlich ist). Programme wie PyUnit (https://wiki.python.org/moin/PyUnit) erleichtern das Unit-Testing (das Testen einzelner Funktionalitäten) ungemein.

Das Schöne an PyUnit ist, dass Sie wiederum Python-Code schreiben, um die Tests auszuführen. Ihr Skript ist einfach ein weiteres, spezialisiertes Programm, das die Hauptanwendung auf Probleme hin prüft.

Sie denken vielleicht, dass die Testskripte statt Ihrer Anwendung fehlerhaft sein könnten. Die Testskripte sind extrem einfach gehalten, sodass Programmierfehler klein und schnell gefunden sind. Natürlich können (und werden manchmal) Fehler auftreten, sodass Sie auch das Skript prüfen sollten, wenn Sie den Fehler nicht in der Anwendung finden.

Ihren Code mit Isort aufräumen

Es scheint eine Nichtigkeit zu sein, aber manchmal kann Code wirklich unordentlich werden, zum Beispiel, wenn Sie nicht alle import-Anweisungen am Anfang der Datei in alphabetischer Reihenfolge anordnen. Manchmal wird es schwierig, wenn nicht unmöglich, Ihren Code zu durchblicken, wenn er nicht gepflegt wird. Das Programm Isort (http://timothycrosley.github.io/isort) übernimmt die scheinbar winzige Aufgabe, alle Ihre import-Anweisungen zu sortieren und sicherzustellen, dass sie alle am Anfang der Quellcodedatei stehen. Dieser kleine Schritt kann einen entscheidenden Einfluss auf die Verständlichkeit und Wartbarkeit Ihres Codes haben.

Einfach zu wissen, welche anderen Module ein bestimmtes Modul benötigt, kann schon bei der Lokalisierung potenzieller Probleme hilfreich sein. Wenn Sie beispielsweise eine ältere Version eines benötigten Moduls auf Ihrem System haben, ist es einfacher, die referenzierten Module für Ihre Anwendung zu finden, wenn Sie wissen, um welche es sich handelt.

Außerdem sollten Sie wissen, welche Module Ihre Anwendung benötigt, wenn Sie sie an Benutzer ausliefern. Wenn man weiß, dass dem Benutzer die richtigen Module zur Verfügung stehen, kann man auch sicherstellen, dass die Anwendung wie beabsichtigt funktioniert.

Versionskontrolle mit Mercurial verwenden

Die Anwendungen, die Sie im Laufe dieses Buches geschrieben haben, sind nicht besonders komplex. Auch nachdem Sie dieses Buch zu Ende gelesen haben und etwas größere Beispielanwendungen programmieren, werden Sie wahrscheinlich keine Versionskontrolle brauchen. Sobald Sie aber in einer Entwicklungsumgebung einer Firma arbeiten und an Anwendungen, die für Benutzer jederzeit zur Verfügung stehen sollen, mitentwickeln, wird Versionskontrolle unabdingbar. Die Versionskontrolle verfolgt die Änderungen an einer Anwendung, zum Beispiel zwischen verschiedenen Produkt-Releases in einer Produktivumgebung, aber auch schon in der reinen Entwicklungsphase. Verwenden Sie beispielsweise MeineAnwendung 1.2, dann beziehen Sie sich auf die Version 1.2 dieser Anwendung. Mit der Versionierung weiß man immer, welches Release der Anwendung man verwendet, speziell wenn man Patches und anderen Support in Anspruch nimmt.

Für Python gibt es zahlreiche Software zur Versionskontrolle. Ein interessantes Programm ist Mercurial (http://mercurial.selenic.com). Mercurial gibt es für nahezu jedes System, auf dem auch Python läuft, sodass Sie sich keine Gedanken über eine andere Software machen müssen, wenn Sie das System wechseln. (Sollte es für Ihr System keine Installationsdatei oder ausführbare Datei geben, können Sie sich immer noch eine selbst aus dem Quellcode von der Downloadseite zusammenbauen.)

Im Gegensatz zu vielen anderen Programmen zum Thema ist Mercurial kostenlos. Auch wenn Sie mal später ein besser ausgestattetes Programm brauchen, sammeln Sie bei ein oder zwei Projekten, die Sie mit Mercurial durchführen, sehr nützliche Erfahrungen.

Der Vorgang des Speicherns aller Versionen einer Anwendung an einem separaten Ort, um Änderungen bei Bedarf rückgängig zu machen oder zu wiederholen, nennt man Quellcodeverwaltung. Viele Leute meinen, dass Quellcodeverwaltung schwierig ist. Da die Mercurial-Umgebung sehr nachgiebig ist, lernen Sie etwas über die Quellcodeverwaltung, ohne bei Fehlern zu sehr bestraft zu werden. Es ist sehr wichtig, dass man auf jede Version des Quellcodes einer Anwendung zugreifen kann, wenn man Probleme beheben muss, die durch ein neues Release entstanden sind.

Das Beste an Mercurial ist, dass es ein tolles Online-Tutorial unter http://mercurial.selenic.com/wiki/Tutorial gibt. Sie lernen am besten etwas über Quellcodeverwaltung, wenn Sie die Inhalte anhand Ihres eigenen Systems nachvollziehen, aber auch allein das Lesen bringt Sie schon weiter. Klar handelt das erste Tutorial davon, wie man Mercurial ordentlich installiert. Die Tutorials führen Sie dann durch das Erstellen eines Repositorys (der Ort, an dem die Versionen Ihres Programms gespeichert werden) und wie man es bei der Anwendungsentwicklung verwendet. Nachdem Sie die Tutorials beendet haben, sollten Sie eine gute Vorstellung davon bekommen haben, wie Quellcodeverwaltung funktionieren sollte und warum die Versionierung ein wichtiger Teil der Anwendungsentwicklung ist.

20

Zehn Bibliotheken, die Sie kennen sollten

In diesem Kapitel

Schützen Sie Ihre Daten mit Kryptografie

Mit Datenbanken arbeiten

Ans Ziel kommen und neue Orte entdecken

Den Benutzern eine GUI zur Verfügung stellen

Tabellen erstellen, die die Benutzer gerne anschauen

Mit Grafik arbeiten

Benötigte Informationen finden

Aus Ihrer Python-Anwendung Zugriff auf Java-Code gewähren

Auf lokale Netzwerkressourcen zugreifen

Informationsquellen im Internet verwenden

Python ist sehr mächtig, wenn Sie einfach nur eine ganz normale Anwendung schreiben wollen. Die meisten Anwendungen sind aber nicht normal und erfordern spezielle Maßnahmen, damit man sie realisieren kann. Hier kommen Bibliotheken ins Spiel. Eine gute Bibliothek erweitert die Funktionalität von Python derart, dass es Ihre speziellen Programmieranforderungen erfüllt. Beispielsweise müssen Sie vielleicht Statistiken in Diagrammform darstellen oder auf ein Laborgerät zugreifen. Diese Aufgaben erfordern die Verwendung spezieller Bibliotheken.

Eine der besten Seiten im Internet, wo Sie eine Auflistung toller Bibliotheken finden, ist die Seite UsefulModules unter https://wiki.python.org/moin/UsefulModules. Natürlich gibt es noch viele andere Seiten, auf denen Sie auch nach Bibliotheken suchen können. Zum Beispiel bietet Ihnen der Artikel »7 Python Libraries you should know about« (http://doda.co/7-pythonlibraries-you-should-know-about) eine relativ vollständige Beschreibung der im Titel angegebenen sieben Bibliotheken. Arbeiten Sie mit einem bestimmten System, zum Beispiel Windows, gibt es dafür auch plattformspezifische Seiten, wie die Seite Unofficial Windows Binaries for Python Extension Packages (www.lfd.uci.edu/~gohlke/pythonlibs). Sie finden also überall Listen mit Bibliotheken, in denen Sie stöbern oder suchen können.

Der Sinn dieses Kapitels liegt nicht darin, Ihnen auf Ihre ohnehin schon lange Liste mit potenziellen Bibliothekskandidaten weitere oben auf zu packen. Stattdessen präsentiert es Ihnen eine Liste mit zehn Bibliotheken, die auf jedem System funktionieren und grundlegende Aufgaben erledigen, die jeder einmal gebrauchen kann. Dieses Kapitel soll Ihnen einen Grundstock an Bibliotheken bieten, auf den Sie in Ihrem nächsten Programmierprojekt zurückgreifen können.

Eine sichere Umgebung mit PyCrypo entwickeln

Datensicherheit sollte ein grundlegender Teil jedes Programmiervorhabens sein. Anwendungen werden sehr geschätzt, da sie das Manipulieren und Verwenden von Daten aller Couleur so einfach machen. Aber die Anwendung muss die Daten auch schützen, sonst ist alle Arbeit daran umsonst. Daten stellen einen unschätzbaren Wert für ein Unternehmen dar – eine Anwendung ist einfach nur ein Werkzeug. Zum Schutz der Daten gehört dazu, dass niemand sie stehlen oder auf eine Weise verwenden kann, die vom Urheber nicht so beabsichtigt war. Hier kommen Kryptografie-Bibliotheken, wie PyCrypto (www.dlitz.net/software/pycrypto), ins Spiel.

Der hauptsächliche Zweck dieser Bibliothek besteht darin, Ihre Daten so zu verändern, dass andere sie nicht lesen können, während sie auf der Festplatte gespeichert sind. Eine sinnvolle Änderung der Daten auf diese Weise nennt sich Verschlüsselung. Werden die Daten in den Hauptspeicher geladen, nimmt sich ein Algorithmus zur Entschlüsselung der verstümmelten Daten an und bringt sie wieder in ihre ursprüngliche Form, damit die Anwendung damit arbeiten kann. Im Mittelpunkt all dessen steht der Schlüssel, der zum Verschlüsseln und Entschlüsseln der Daten verwendet wird. Beim Schreiben der Anwendung müssen Sie auch sicherstellen, dass der Schlüssel geheim bleibt. Nur Sie können die Daten lesen, da Sie den Schlüssel haben; niemand anders kann das, da ihnen der Schlüssel fehlt.

Auf Datenbanken mit SQLAlchemy zugreifen

Eine Datenbank ist im Grunde eine Methode, um gleichartige oder strukturierte Daten permanent zu speichern. Zum Beispiel sind Datensätze (einzelne Einträge in der Datenbank) über Kunden gleichartig, da zu jedem Kunden die gleichen Informationen existieren, wie Name, Adresse und Telefonnummer. Die Natur der Daten bestimmt die Art der Datenbank, die Sie dafür verwenden können. Manche Datenbanksysteme sind auf Texte spezialisiert, andere verwenden tabellarische Informationen und wieder andere Binärdaten (zum Beispiel von Messungen eines Laborinstruments). Datenbanksysteme können intern zum Beispiel baumartige Datenstrukturen oder sehr einfach strukturierte Textdateien (sogenannte Flat Files) zur Speicherung der Daten verwenden. Ihnen werden sehr viele langweilige Begriffe begegnen, wenn Sie sich mit Datenbankmanagementsystemen (DBMS) auseinandersetzen – die meisten sagen nur Datenbankadministratoren (DBA) etwas und müssen Sie nicht kümmern.

Der am häufigsten verwendete Datenbanksystemtyp ist das Relationale Datenbankmanagementsystem (RDBMS), in dem Tabellen aus Reihen (den Datensätzen) und Spalten (oder Feldern) bestehen (so, wie Sie auch eine Tabelle auf einem Blatt Papier darstellen würden). Jede Spalte enthält denselben Informationstyp, wie den Kundennamen. Tabellen können auf unterschiedliche Arten miteinander verknüpft sein, sodass man komplexe Beziehungen zwischen ihnen bilden kann. Zum Beispiel können ein oder mehrere Einträge in einer Tabelle »Bestellung« mit einem Kunden verknüpft sein und daher stehen diese Tabellen miteinander in Beziehung.

Auf die einzelnen Datensätze in einem RDBMS kann mit einer speziellen Abfragesprache zugegriffen werden, die sich Structured Query Language (SQL) nennt. Natürlich brauchen Sie auch ein Hilfsmittel, mit dem Sie mit beidem, dem RDBMS und SQL, arbeiten können. Hier kommt SQLAlchemy (www.sqlalchemy.org) ins Spiel. Diese Bibliothek reduziert den Aufwand für Aufgaben rund um die Datenbank, wie einen bestimmten Kundendatensatz zurückzugeben, einen neuen Datensatz anzulegen, einen existierenden Datensatz zu ändern und einen alten Datensatz zu löschen, ungemein.

Die Welt mit Google Maps bereisen

Geokodierung oder Verortung (die Zuordnung geografischer Koordinaten, wie Längen- und Breitengrad zu ortsbezogenen Daten, zum Beispiel einer Adresse) wird heutzutage auf vielfältige Weise verwendet, beispielsweise um ein gutes Restaurant oder einen vermissten Wanderer in den Bergen zu finden. Von einem Ort zum anderen zu kommen, erfordert auch oft Geokodierung. Mit Google Maps (https://pypi.python.org/pypi/googlemaps) können Sie Ihrer Anwendung Routeninformationen hinzufügen.

Neben der Routenberechnung und dem Auffinden eines armen Teufels in der Wüste unterstützt Sie Google Maps auch bei Geografischen Informationssystemen (GIS). Der Abschnitt Leuten dabei helfen, einen bestimmten Ort zu finden in Kapitel 18 beschreibt diese Technologie etwas genauer, aber im Grunde dreht sich bei einem GIS alles darum, einen bestimmten Ort für etwas zu finden oder festzustellen, warum ein Ort für eine bestimmte Aufgabe besser geeignet ist als ein anderer. Kurz gefasst bietet Google Maps Ihrer Anwendung die Möglichkeit, einen Blick auf die Außenwelt zu werfen, um Ihren Benutzern bei der Entscheidung zu helfen.

Eine Benutzeroberfläche mit TkInter erstellen

Benutzer finden grafische Benutzeroberflächen (Graphical User Interfaces, GUIs) toll, da sie einfacher zu bedienen sind und weniger Gehirnschmalz erfordern als eine Kommandozeile. Es gibt viele Programme, mit denen Sie für eine Python-Anwendung eine Benutzeroberfläche bauen können. Aber die am häufigsten verwendete Bibliothek ist TkInter (https://wiki.python.org/moin/TkInter). Entwickler lieben es, da TkInter einfach gehalten ist. Es ist eigentlich eine Schnittstelle für Tool Command Language (Tcl)/Toolkit (Tk), das Sie unter www.tcl.tk finden. Viele Sprachen nutzen Tcl/Tk als Grundlage zur Erstellung einer GUI.

Vielleicht gefällt Ihnen die Idee, Ihrer Anwendung eine GUI hinzuzufügen, nicht. GUIs kosten immer viel Zeit und machen die Anwendung nicht unbedingt funktionaler (in vielen Fällen macht es die Anwendung sogar langsamer). Benutzer lieben aber GUIs und wenn Sie möchten, dass Ihre Anwendung breit eingesetzt wird, sollten Sie sich nach den Benutzerwünschen richten.

Eine nette tabellarische Datendarstellung mit PrettyTable erstellen

Tabellarische Daten so darzustellen, dass Benutzer sie verstehen können, ist sehr wichtig. Anhand der Beispiele in diesem Buch haben Sie gesehen, dass Python diese Art von Daten optimal für die Verwendung im Programmcode speichert. Benutzer brauchen aber etwas, das von Menschen verstanden werden kann und dabei noch schön aussieht. Die Bibliothek PrettyTable (https://pypi/python.org/pypi/PrettyTable) erweitert Ihre Kommandozeilenanwendung sehr einfach um eine ansprechende Tabellendarstellung.

Ihre Anwendung mit Sound mit PyAudio bereichern

Sound ist praktisch, um dem Benutzer bestimmte Informationen näherzubringen. Sie müssen beim Einsatz von Sound aber vorsichtig sein, da Benutzer mit gewissen Handicaps es nicht hören können, und die, die es können, werden dadurch vielleicht bei ihrer normalen Arbeit gestört. Manchmal ist Ton aber ein wichtiges Medium, um dem Benutzer zusätzliche Informationen zu vermitteln (oder nur ein tolles Extra, um Ihre Anwendung interessanter zu machen).

Eine ganz gute plattformunabhängige Bibliothek, mit der Sie Ihre Anwendung mit Ton ausstatten können, ist PyAudio (http://people.csail.mit.edu/hubert/pyaudio). Mit dieser Bibliothek können Sie beliebig Geräusche aufnehmen und wiedergeben (zum Beispiel könnte der Benutzer eine Audionotiz mit später zu erledigenden Aufgaben machen und die Liste bei Bedarf wieder abspielen lassen).

Beim Arbeiten mit Sound am Computer müssen Sie immer abwägen. Zum Beispiel kann eine plattformunabhängige Bibliothek niemals besondere Funktionen eines bestimmten Systems ausnutzen. Außerdem unterstützt sie vielleicht nicht alle Dateiformate, die es für ein bestimmtes System gibt. Sie sollten eine plattformunabhängige Bibliothek verwenden, wenn Sie wollen, dass Ihre Anwendung einfache Soundunterstützung auf allen Zielsystemen zur Verfügung stellen kann.

Sound-Technologien in Python kategorisieren

Sound ist auf Computern in vielen Formen präsent. Die grundlegenden Multimedia-Dienste, die Python zur Verfügung stellt (siehe auch die Dokumentation unter https://docs.python.org/3/library/mm.html), bieten wichtige Wiedergabefunktionen an. Sie können auch bestimmte Audiodateitypen schreiben, aber die Auswahl an Dateiformaten ist begrenzt. Außerdem sind manche Module, wie winsound (https://docs.python.org/3/library/winsound.html) systemspezifisch, daher können Sie sie nicht in einer Anwendung verwenden, die plattformunabhängig sein soll. Die Standardfunktionen in Python sollen eine einfache Unterstützung für Multimediainhalte bieten, um Systemsounds wiederzugeben.

Bibliotheken, wie PyAudio, stellen erweiterte Audiofunktionen zur Verfügung, um die Bedienbarkeit von Anwendungen zu verbessern. Eine Liste dieser Bibliotheken finden Sie unter https://wiki.python.org/moin/Audio. Diese Bibliotheken orientieren sich aber meist an geschäftlichen Anforderungen, wie Notizen aufnehmen und später wieder abspielen. Auf einer qualitativ hochwertigen Klangwiedergabe liegt ihr Hauptaugenmerk nicht.

Leute, die Computerspiele spielen, brauchen spezielle Audiounterstützung, damit sie Spezialeffekte, zum Beispiel ein Monster hinter ihnen, gut hören können. Solche Anforderungen werden von Bibliotheken wie PyGame (www.pygame.org) erfüllt. Sollten Sie diese Bibliotheken verwenden, brauchen Sie eine hochwertige Audioausstattung und müssen sich darauf einrichten, viel Zeit nur mit der Arbeit an den Audioeigenschaften Ihrer Anwendung zu verbringen. Eine Liste dieser Bibliotheken finden Sie unter https://wiki.python.org/moin/PythonGameLibraries.

Bilder mit PyQtGraph bearbeiten

Menschen sind visuell geprägt. Wenn Sie jemandem eine Tabelle mit Informationen zeigen und dieselben Informationen dann als Diagramm präsentieren, wird immer das Diagramm als beste Möglichkeit zum Vermitteln der Informationen gewinnen. Anhand von Diagrammen können Menschen Trends erkennen und verstehen, warum die Daten sich auf diese Weise entwickelt haben. Es ist allerdings schwierig, die Pixel, die diese Diagramme darstellen, auf den Bildschirm zu bekommen, und darum brauchen Sie auch eine Bibliothek wie PyQtGraph (www.pyqtgraph.org), um sich diese Arbeit zu erleichtern.

Auch wenn diese Bibliothek eigentlich für ingenieurstechnische, mathematische und naturwissenschaftliche Anforderungen entworfen wurde, sollte Sie das nicht davon abhalten, sie auch für andere Zwecke zu verwenden. PytQtGraph unterstützt sowohl 2D- als auch 3D-Darstellungen und Sie können neue Grafiken aus numerischen Daten erzeugen. Die Ausgabe ist vollständig interaktiv, sodass der Benutzer Bildbereiche zur Vergrößerung oder für andere Bildbearbeitungen auswählen kann. Außerdem enthält die Bibliothek viele nützliche Widgets (Steuerelemente, beispielsweise Schaltflächen, die Sie am Bildschirm anzeigen lassen können), um die Programmierung noch leichter zu machen.

Im Gegensatz zu anderen Bibliotheken in diesem Kapitel können Sie PyQtGraph nicht eigenständig verwenden, sondern müssen andere Programme installieren, um es zu benutzen. Das ist nicht verwunderlich, da PyQtGraph einen großen Funktionsumfang hat. Sie müssen die folgenden Dinge auf Ihrem System installieren, um es zu verwenden:

Python, Version 2.7 oder höher

PyQt, Version 4.8 oder höher (https://wiki.python.org/moin/PyQt) oder PySide (https://wiki.python.org/moin/PySide)

numpy (http://www.numpy.org)

scipy (www.scipy.org)

PyOpenGL (http://pyopengl.sourceforge.net)

Informationen mit IRLib finden

Informationen wiederzufinden, ist gar nicht so einfach, wenn sie eine bestimmte Größe erreicht haben. Betrachten Sie Ihre Festplatte als große, formatlose, Baum-basierte Datenbank, die keinen sinnvollen Index hat. Jedes Mal, wenn ein solches Gebilde groß genug wird, findet man Daten einfach nicht wieder. (Suchen Sie mal nach Bildern aus dem letzten Sommer und dann wissen Sie, was ich meine.) Daher macht es Sinn, Suchmöglichkeiten in Ihre Anwendung einzubauen, sodass Benutzer vermisste Dateien oder andere Informationen finden können.

Auch hier gibt es wieder eine Vielzahl an Bibliotheken für die Suche in Python. Die meisten davon sind entweder schwer zu installieren oder bieten keinen konsistenten Plattformsupport. Manche davon funktionieren nur auf ein oder zwei Systemen. Im Gegensatz dazu ist IRLib (https://github.com/gr33ndata/irlib) vollständig in Python geschrieben, sodass man es auf jedem System einsetzen kann. Sollte IRLib nicht alle Ihre Anforderungen erfüllen, sollten Sie aufpassen, dass die von Ihnen stattdessen gewählte Software die erforderliche Suchfunktion auf allen Zielsystemen zur Verfügung stellt und dass die Installationsanforderungen im Rahmen bleiben.

IRLab erstellt einen Suchindex über alle beliebigen Informationen, mit denen Sie arbeiten wollen. Sie können diesen Index dann für den späteren Gebrauch auf Festplatte speichern. Der Suchmechanismus funktioniert mit Metriken – Sie bestimmen ein oder zwei Einträge, die am besten den Suchkriterien entsprechen.

Eine interoperable Java-Umgebung mit JPype erstellen

Python hat Zugriff auf eine sehr große Auswahl an Bibliotheken und Sie werden mit Sicherheit nicht alle davon verwenden. Es kann aber sein, dass Sie mal eine Java-Bibliothek finden, die genau Ihren Anforderungen entspricht, aber Sie können sie nicht ohne größeren Aufwand in Ihrer Python-Anwendung einsetzen. Die Bibliothek JPype (http://jpype.sourceforge.net) bietet aus Python heraus direkten Zugriff auf die meisten (aber nicht alle) Java-Bibliotheken. Die Bibliothek bildet auf Bytecode-Ebene eine Brücke zwischen den beiden Sprachen. Daher müssen Sie nichts Verrücktes anstellen, damit Ihre Anwendung auf Java-Bibliotheken zugreifen kann.

Sie werden bei der Sprach-Interoperabilität immer Kompromisse machen müssen, egal für welche Lösung Sie sich entscheiden. Bei JPype haben Sie auf bestimmte Java-Bibliotheken keinen Zugriff. Außerdem gibt es eine Geschwindigkeitseinbuße, da die JPype-Brücke ständig Aufrufe und Daten konvertieren muss. Bei Jython können Sie Ihren Code nach der Konvertierung nicht mehr ändern. Alle Änderungen würden zu einer Inkompatibilität zwischen dem ursprünglichen Python-Code und seinem Java-Gegenstück führen. Es gibt also keine perfekte Lösung, das Beste beider Sprachen in einer Anwendung zu vereinen.

Ihre Python-Anwendung in Java konvertieren

Es gibt viele Methoden, wie man Interoperabilität zwischen zwei Sprachen erreichen kann. Eine Methode ist das Überbrücken der Sprachen, so wie JPype das macht. Eine weitere Methode ist das Übersetzen des Codes in die jeweils andere Sprache. Dieser Ansatz wird von Jython verfolgt (https://wiki.python.org/jython). Dieses Programm konvertiert Ihren Python-Code in Java, sodass Sie den vollen Funktionsumfang von Java nutzen können, aber trotzdem die Funktionen behalten können, die Sie an Python so toll finden.

Auf lokale Netzwerkressourcen mit Twisted Matrix zugreifen

Abhängig von dem Aufbau Ihres Netzwerks müssen Sie auf Dateien und andere Ressourcen zugreifen können, die man nicht mit den im System integrierten Möglichkeiten erreichen kann. In diesem Fall brauchen Sie eine Bibliothek, wie Twisted Matrix (https://twistedmatrix.com/trac), die diesen Zugriff ermöglicht. Die Grundidee hinter dieser Bibliothek ist, dass Ihnen jegliche Aufrufe zum Herstellen einer Verbindung zur Verfügung stehen, egal welches Protokoll verwendet wird.

Diese Bibliothek ist insbesondere so praktisch, da sie ereignisgesteuert ist. Das bedeutet, dass sich Ihre Anwendung nicht aufhängt, während sie auf eine Antwort vom Netzwerk wartet. Außerdem kann man bei einem ereignisgesteuerten Aufbau sehr einfach eine asynchrone Kommunikation (bei der eine Anfrage durch eine Methode geschickt und die Antwort dann von einer ganz anderen Methode bearbeitet wird) implementieren.

Mit Bibliotheken auf Ressourcen im Internet zugreifen

Auch wenn Bibliotheken, wie Twisted Matrix, eine Kommunikation über das Internet ermöglichen, ist es oft besser, eine dedizierte Bibliothek für das HTTP-Protokoll zu verwenden, wenn man mit dem Internet arbeitet, da eine dedizierte Bibliothek schneller ist und einen vollständigeren Funktionsumfang hat. Brauchen Sie insbesondere Unterstützung für HTTP oder HTTPS, können Sie eine Bibliothek wie httplib2 (https://github.com/jcgregorio/httplib2) verwenden. Diese Bibliothek ist vollständig in Python geschrieben und macht die Umsetzung HTTP-spezifischer Anforderungen, wie das Setzen eines Keep-Alive-Wertes relativ einfach. (Ein Keep-Alive ist ein Wert, der bestimmt, wie lange ein Port offen bleibt und auf eine Antwort wartet, damit die Anwendung nicht ständig die Verbindung wiederherstellen muss und dadurch Ressourcen und Zeit verschwendet.)

Sie können httplib2 für jegliche Internet-spezifischen Arbeiten verwenden – es unterstützt sowohl GET- als auch POST-Anfragen. Die Bibliothek enthält auch Algorithmen für Standard-Kompressionsmethoden im Internet, wie deflate und gzip. Außerdem bietet sie auch eine gewisse Automation. Zum Beispiel fügt httplib2 ETags wieder in PUT-Anfragen ein, wenn die Ressourcen schon zwischengespeichert wurden.

Stichwortverzeichnis

A

Abfragesprache
absoluter Pfad

Addition

Akzente

Akzessor
and

Anhang

Anweisung
break
continue
for
from...import
if
if...elif
if...else
import 1, 2,

Schleife
switch 1, 2,
while
with

Anweisung|from...import

Anweisung|import

Anwendung 1, 2,
ausführen 1, 2, 3,
ausliefern

Ausnahmebehandlung
beenden

Benutzereingabe

Datei bearbeiten

Datei erstellen

Datei lesen

Datei löschen

Deque erstellen

Dictionary erstellen

E-Mail erstellen

E-Mail übertragen

E-Mail versenden 1, 2,

Echtzeit

Eigenschaften

Entscheidung
im Code beenden
im Editierfenster ausführen
im Shell-Fenster ausführen
in der Kommandozeile ausführen 1, 2,

Instanz initialisieren

Klasse definieren

Klasse schreiben

Klasse verwenden
laden

Liste

Liste bearbeiten

Liste durchlaufen

Liste durchsuchen

Liste erstellen

Liste sortieren

Liste verwenden

Menü programmieren

Module

Performance

Pfadliste

Qualität

Qualitätssicherung

Skript
testen

Tupel erzeugen

Versionskontrolle

Warteschlange erstellen

Webanwendung

App siehe Anwendung
append() 1, 2,

Arbeitsablauf

ArithmeticError-Ausnahme
arithmetischer Operator
as-Klausel

ASCII-Zeichensatz

Attribut

___class___

___sizeof___()

sys.path

Audio

Aufrufer 1, 2,

Ausdruck 1, 2,
verknüpfen

Vorrangsregel
ausführen

Anwendung

Ausgabe
auskommentieren

Bereich

Ausnahme
abfangen 1, 2, 3,

ArithmeticError
auslösen 1, 2,

Basisklassen
behandeln
benutzerdefinierte
definieren

FileNotFound
integriert

IOError

KeyboardInterrupt
konkrete Klassen

Laufzeitfehler
mehrere Typen behandeln

MemoryError

Parameter

Parameter ausgeben lassen

ResourceWarning

ValueError
vom Betriebssystem erzeugt

Warnung
werfen 1, 2,

ZeroDivisionError

Ausnahmebasisklassen

Ausnahmebehandlung 1, 2,
as-Klausel

Ausnahme auslösen
benutzerdefinierte Ausnahme
except-Block
except-Klausel

Fehlerquellen

Fehlertypen 1, 2,
finally-Klausel 1, 2,
generisch

Informationen ausgeben
mehrere Ausnahmetypen behandeln

Parameter
raise-Klausel

Strategie
try-Block

Verschachtelung
vordefinierte Ausnahmen
automatische Einrückung

B

Basis

Batchdatei siehe Stapeldatei

Bearbeiten

Datei

Bedingung
if...elif
if...else
kombinieren 1, 2,

Selektionsbaum
verknüpfen
verschachteln

Befehl

Anwendung ausführen
ausführen
eingeben
import 1, 2, 3,
in Editierfenster eingeben

Run Module

Befehl|import

Benutzereingabe

Benutzeroberfläche

Bereich auskommentieren

Bereichsprüfung

Betreff

Betriebssystemausnahme

Bibliothek 1, 2,
suchen
bin()

Binärcode

Binärsystem 1, 2,
bitweiser Operator

Boolean 1, 2,

Boolescher Wert
break

Bug Tracker

Bug siehe Fehler

C#

Vergleich mit Python

C

CC-Feld
chdir()

clear()

close()

Code

Attribute
aufrufender
ausführen
auskommentieren

Ausnahmebehandlung

Bedingungen verschachteln

Bibliothek

Block

Datei bearbeiten

Datei erstellen

Datei lesen

Datei löschen

Dekorator

Deque erstellen

Dictionary erstellen

Dokumentation erzeugen
dokumentieren

E-Mail erstellen

E-Mail übertragen

E-Mail versenden 1, 2,
einkommentieren

Einrückung

Entscheidung

Funktion

Funktionsaufruf
gruppieren
if...elif
if...else

Instanz initialisieren

Introspektion

Klasse definieren

Klasse schreiben

Klasse verwenden

Klassen 1, 2, 3,

Kommentar 1, 2,
kommentieren

Liste

Liste bearbeiten

Liste durchlaufen

Liste durchsuchen

Liste erstellen

Liste sortieren

Liste verwenden

Modul

Modul importieren 1, 2,

Pfadliste

Rückgabewert

Schleife

Spaghetti-Code
strukturieren

Strukturierung 1, 2,

Syntax-Highlighting

Tupel erzeugen

Warteschlange erstellen

Wiederverwendbarkeit

Codeblock

Collection

Deque

Dictionary 1, 2,

Menge

Stapel 1, 2,

Tupel 1, 2,

Warteschlange

Collection|Deque

Collection|Warteschlange
collections-Modul

Comma Separated Value-Format siehe CSV-Format

Computer

Virtualisierung

.config-Datei
continue
copy()

count() 1, 2,

Counter-Objekt

CRUD 1, 2, 3, 4,

CSV-Format
csv-Modul

D

Data Mining

DataWriter
date()

Datei
bearbeiten
close()

erstellen

Format
in Verzeichnissen strukturieren
lesen
löschen
öffnen 1, 2,
open()

permanent speichern
schließen
speichern

Dateierweiterung

Dateiformat

CSV

XML

Dateipfad

Dateityp

Daten-Member
auslesen

CRUD
geografische
in Variablen speichern

Längenprüfung

Operatoren 1, 2, 3,
permanent speichern 1, 2,
speichern 1, 2,
strukturieren 1, 2,
strukturierte
unstrukturierte
vergleichen
verschlüsseln
verwalten

Datenbank 1, 2,

Datensatz
zugreifen auf

Datenbankmanagementsystem siehe DBMS

Datenintegrität

Datensatz

Datensicherheit

Datentyp

Boolean 1, 2,
datetime
einer Variablen bestimmen
float
int

Komplexe Zahl

String 1, 2,
umwandeln
datetime

Datum und Uhrzeit
ausgeben lassen

Funktionen

DBMS

Debugger 1, 2,

Debugging

Dekorator

Deque 1, 2,
append()

Element anhängen

Elemente entfernen
erstellen
extend()

mehrere Elemente hinzufügen
pop()

Deque|remove()

Dezimalsystem

Dezimalteil

Diagramm

Dictionary 1, 2,
auf Elemente zugreifen
del 1, 2,

Elemente ändern

Elemente entfernen
erstellen
keys()

Länge bestimmen
len()

Schlüssel

Schlüssel-Wert-Paar

Schlüsselliste ausgeben
sorted()

switch-Anweisung nachbilden

Dictionary|clear()

Dictionary|leeren
dir()

Division
doc()

Dokumentation
durchsuchen
erstellen
in IDLE aufrufen
mit Kommentaren

Modul

Schnellzugriff

Doppelkreuzzeichen siehe #

Download

E

E-Mail-Adresse

Bestandteile

Host

Hostname
lokaler Hostname

Port 1, 2,

E-Mail-Nachricht

Bestandteile

E-Mail-Programm

Adressfelder

Anhang
anschauen

Betreff

CC-Feld

Empfänger

Host 1, 2,

Hostname
html-Format

HTML-Nachricht versenden

Kopf

Korpus
lokaler Hostname

MIME

Nachricht 1, 2, 3,

Nachricht erstellen

NurText-Format

Port 1, 2,

Prozess

Sender
text-Format
übertragen

Umschlag 1, 2,

Versand
versenden 1, 2,

Echtzeitanalyse

Editierfenster

Editierfenster öffnen

Anwendung ausführen

Befehle eingeben

Datei öffnen

Datei speichern

Editor
vim

Einerkomplement

Eingabe siehe Benutzereingabe

Eingabeparameter
eingebettetes System
einkommentieren

Einrückung
automatisch
in IDLE konfigurieren
einzeiliger Kommentar
else

Elternklasse 1, 2,
email.mime-Modul
empty()

Endlosschleife

Entscheidung

Bedingung
kombinieren 1, 2,

Selektionsbaum
verschachteln

Entschlüsselung

Entwicklungswerkzeug

Escape-Sequenz
except
except-Block
ohne Ausnahmetyp
except-Klausel

Exception-Handling siehe Ausnahmebehandlung

Exception siehe Ausnahme
exec()

exit()

Exponentialdarstellung

Exponentialwert
extend()

Extensible Markup Language siehe XML

F

False

Farbcodierung siehe Syntax-Highlighting 1, 2,

Fehler

Debugger

Laufzeit
logischer

Quellen
semantischer
syntaktischer

Typen 1, 2,
zur Kompilierzeit

Fehlerbehandlung siehe Ausnahmebehandlung

FIFO

FileNotFound-Ausnahme
finally
finally-Klausel
find()

First in /First out siehe FIFO

Flat File

Fließkommazahl

Basis

Dezimalteil

Exponent

Exponentialdarstellung

Kapazität

Mantisse
wissenschaftliche Notation
float() 1, 2,
float siehe Fließkommazahl
for
for-Schleife 1, 2,
format() 1, 2,

Format
einer Datei

Formel siehe Ausdruck
from...import 1, 2,
full()

Funktion

___getattribute___()

___init___()

append()

aufrufen
aufrufende
chdir()

close()

count() 1, 2,
date()

definieren
dir 1, 2,
doc()

empty()

erstellen 1, 2,
exec()

extend()

find()

format() 1, 2,
full()

für Datum und Uhrzeit
index()

input()

insert()

keys()

len() 1, 2, 3,
max()

Methode
mit variablen Parametern
now()

open() 1, 2, 3,

Parameter

Parameter per Schlüsselwort übergeben
partielle
pop() 1, 2,
print()

put()

range()

read()

remove()

reverse()

rmdir()

rmtree()

Rückgabewert

Rückgabewerte vergleichen
sendmail()

sort()

sorted()

split() 1, 2,

Standardwert für Parameter
str()

sys.exit()

time()

upper()

verwenden 1, 2,
zur Bearbeitung von Strings

Funktion|append()

Funktion|bin()

Funktion|clear()

Funktion|copy()

Funktion|float() 1, 2,

Funktion|get()

Funktion|help()

Funktion|hex()

Funktion|int()

Funktion|oct()

Funktion|print()

Funktion|range()

Funktion|remove()

Funktionsaufruf 1, 2,

Funktionsüberladung

G

Ganzzahl siehe Integer

Ganzzahldivision

Generator
geografische Daten
geografisches Informationssystem

Geokodierung
get()

GIS

Github

Gleichung siehe Ausdruck
grafische Symbole

Graphical User Interface siehe GUI

GUI
help()

hex()

H

Hexadezimalsystem

Hilfe

Hilfemodus
in IDLE
in IDLE konfigurieren

Soforthilfe

Themen

Hilfemodus
in IDLE

Host

Adresse

Name

Socket

Hostname

HTML

E-Mail

HTTP
verwenden
https

Port

HTTPS
verwenden

I

IDE 1, 2, 3,

Identitätsoperatoren

IDLE

About-Dialog

Anwendung ausführen
auskommentieren
automatische Einrückung
beenden 1, 2,

Befehle

Befehle eingeben

Close

Datei öffnen

Datei speichern

Dialog Preferences

Editierfenster

Editierfenster öffnen

Einrückung konfigurieren

Einstellungen

Exit

Funktionsumfang

Hilfe

Hilfe konfigurieren

Hilfemodus

Informationen über

Kommentar
konfigurieren

Profil

Python-Dokumentation

Registerkarte Fonts/Tabs

Registerkarte General

Registerkarte Highlighting

Registerkarte Keys

Schrift konfigurieren

Speichereinstellungen

Starteinstellungen

Starten 1, 2,

Syntax-Highlighting 1, 2, 3,

Tastenkürzel

Theme

Version
if else-Operator
if-Anweisung
if...elif
if...else

Bedingungen verknüpfen

Imaginärteil
import 1, 2, 3, 4,

Befehle sortieren
in
index()

input()

insert()

Installation

Linux

Mac

Windows

Installationspfad

Installationsprogramm erstellen

Instanz 1, 2,

Variable 1, 2,

Instanziierung

Instanzmethode

Parameter
self

Instanzvariable 1, 2,
int()

int siehe Integer

Integer

Kapazität

Integrated Development Environment siehe IDE

Integrierte Entwicklungsumgebung siehe IDE 1, 2,

Internetprotokoll
verwenden

Introspektion

IOError-Ausnahme
is
is not

Issue Tracker

Java

Bibliotheken verwenden
mit Python zugreifen

Vergleich mit Python

K

KeyboardInterrupt-Ausnahme
keys()

Kindklasse 1, 2,

Klasse 1, 2,

___init___()

Akzessor

Attribute

DataWriter

Daten-Member
definieren

Definition

Elternklasse 1, 2,

Funktionsüberladung

Getter

Instanz

Instanz initialisieren

Instanziierung 1, 2,

Instanzmethode

Instanzvariable 1, 2,

Kindklasse 1, 2,

Klassenmethode

Klassenvariable 1, 2,

Komponenten

Konstruktor

Methode 1, 2,

MIMEText

Operatorüberladung 1, 2,
schreiben
self

Setter

Variable 1, 2,

Vererbung 1, 2,
verwenden

Writer

Klassenmethode
schreiben

Klassenvariable 1, 2,

Kommandozeile 1, 2, 3,

Anwendung ausführen 1, 2,
beenden

Option siehe Kommandozeilenparameter

Parameter 1, 2,

Kommandozeilenoption siehe Kommandozeilenparameter

Kommandozeilenparameter 1, 2,

Kommentar

#
einzeilig
mehrzeilig

Verwendung

Kompilierzeitfehler
komplexe Zahl

Imaginärteil

Realteil

Konkatenation siehe Verkettung 1, 2,
konkrete Ausnahmeklassen

Konstruktor
laden

Anwendung

L

Längenprüfung

Last in/First out siehe LIFO

Laufzeitfehler
len() 1, 2, 3,

LIFO

Linksverschiebung

Linux
grafische Installation

Installation

Installationspfad

Programmordner

Standard-Installation

Liste
auf Element zugreifen
bearbeiten

Counter-Objekt
durchlaufen
durchsuchen

Element einfügen

Element entfernen 1, 2,

Elemente

Elemente zählen
erstellen

Funktionen
in umgekehrter Reihenfolge sortieren
insert()

Länge bestimmen
len() 1, 2,

Menge

Nummerierung
pop()

remove()

reverse()

Sequenz
sort()

sortieren

Stapel nachbauen
verwenden

Liste|append()

Liste|copy()

Liste|Element anhängen

Liste|kopieren
logischer Fehler 1, 2,
logischer Operator 1, 2,
lokaler Hostname

Löschen

Datei

Mac

Installation

Installationspfad

Programmordner

M

Mantisse
max()

mehrzeiliger Kommentar

Membership-Operator

MemoryError

Menge

Methode 1, 2,

Akzessor

Getter

Parameter

Setter
variable Parameterliste

MIME

Formate

MIMEText

Modul

___main___

Attribute 1, 2,

Attribute ausgeben

Bibliothek
collections
csv

Dokumentation
email.mime
finden
from...import
import-Anweisung
importieren 1, 2, 3, 4,

Inhalt anschauen

Pfad
queue
socket

Umgebungsvariable PYTHONPATH

Modul|from...import

Modul|import

Modul|os

Modulo

Multi-Purpose Internet Mail Extension siehe MIME

Multiplikation

N

Netzwerk

Netzwerkadministration
not
not in
now()

O

Objekt siehe Instanz
oct()

Oktalsystem

Online-Dokumentation
open() 1, 2, 3,

Operand

Operator 1, 2, 3, 4,

!=

%

%=

*

**

**=

*=

+ 1, 2,

+=

- 1, 2,

-=

/

//

//=

/=

<

<=

>

>=

=

==
arithmetisch

Ausdruck 1, 2,
bitweiser

Identitätsoperatoren
if else
logischer 1, 2,

Membership-Operator

Operanden
ternär

Überladung 1, 2,
unär

Vergleichsoperator 1, 2, 3,

Vorrangsregeln

Zuweisungsoperatoren

~

Operator|&

Operator|^

Operator|>>

Operator|<<

Operator|~

Operator|and

Operator|Einerkomplement

Operator|in

Operator|is

Operator|is not

Operator|Linksverschiebung

Operator|not

Operator|not in

Operator|or

Operator|Rechtsverschiebung

Operator|XOR
optionale Parameter
or

Ordner siehe Verzeichnis
os-Modul 1, 2,

P

Parameter

Ausnahmebehandlung
für Ausnahme ausgeben lassen
optional
per Schlüsselwort übergeben

Reihenfolge

Standardwert
übergeben
variable Anzahl
partielle Funktion
pass

PATH-Variable

Performance

Perl

Vergleich mit Python
permanente Datenspeicherung

Pfad
absoluter
relativer

Pfadliste
ausgeben

Plattform

Point-of-Presence-Server siehe POP3-Server
pop() 1, 2,

POP3-Server

Port

Port 1, 2,
https

POP3-Server

SMTP-Server

Socket

Posteingang
print() 1, 2,

Profil
in IDLE konfigurieren

Programm siehe Anwendung

Programmausführung

Programmiersprache 1, 2,

Vergleich

Programmordner

Programmversion
verwalten

Prozess
put()

pydoc
öffnen

Schnellzugriff
suchen

Python Launcher

Python-Shell siehe Kommandozeile
aktuelles Verzeichnis ändern

Anwendungsgebiete
auf dem System finden
beenden

Bibliotheken

Datentypen

Diagramm erstellen

Dokumentation 1, 2, 3,

Dokumentation durchsuchen

Download

Echtzeit

Editierfenster

Eigenschaften
eingebettetes System

Hilfe

IDE

Installation

Interoperabilität mit Java

Klassen

Kommandozeile 1, 2,

Netzwerkadministration

Online-Dokumentation

Pfadliste

Plattformen
pydoc

README-Datei

Shell siehe Kommandozeile

Skript

Starten

Tutorial 1, 2,
über die Kommandozeile starten

Vergleich mit anderen Sprachen

Version

Versionskontrolle

Python|Version ausgeben

PYTHONPATH

Q

Qualitätssicherung
testen

Unit-Tests
queue-Modul

Queue siehe Warteschlange
quit()

raise-Klausel
range() 1, 2,

R

Raspberry Pi

RDBMS
read()

README-Datei

Realteil

Rechtsverschiebung
regulärer Ausdruck

Relationales Datenbankmanagementsystem siehe RDBMS
relativer Pfad
remove() 1, 2,

ResourceWarning-Ausnahme

Restart
reverse()

rmdir()

rmtree()

Rückgabewert

S

Sammlung siehe Collection

Schachtelung siehe Verschachtelung

Schleife
abbrechen
break-Klausel
continue-Klausel

Durchlauf überspringen
else-Klausel

Endlosschleife
for 1, 2,
pass-Klausel

Verschachtelung 1, 2,

Schleife|range()

Schlüssel

Schlüssel-Wert-Paare

Schlüsselwort
as
bei der Parameterübergabe
break
continue
elif
else 1, 2,
except
finally 1, 2,
for
if
import
pass
raise
self
try
while
with

Schlüsselwort|import 1, 2,

Schrift
in IDLE konfigurieren

Selektionsbaum
self
semantischer Fehler
sendmail()

Sequenz

Collection
count()

Elemente zählen

FIFO
index()

LIFO

Liste

Position eines Elements bestimmen

Serialisierung

Server

Hostname

Port

Shell-Fenster

Anwendung ausführen

Shortcut siehe Tastenkürzel

Simple Mail Transfer Protocol siehe SMTP 1, 2,

Skript

Anwendung erweitern

SMTP 1, 2,

SMTP-Server

Port

Socket
socket-Modul

Host

Port

Soforthilfe

Sonderzeichen
sort()

sorted()

Sound

Spaghetti-Code

Speicher

Daten
speichern

Datei

Daten
split() 1, 2,

SQL

Standardwert
bei Parametern

Stapel 1, 2,

Stapeldatei

Steuerzeichen
str()

String 1, 2, 3,

Akzente

ASCII-Zeichensatz
count()

Definition
durchsuchen

Escape-Sequenz
find()

format()

formatieren

Funktionen
grafische Symbole
in anderen Datentyp umwandeln
in Großbuchstaben umwandeln
max()

mit Sonderzeichen
mit Zahlen darstellen
split()

Steuerzeichen
typografische Zeichen

Verkettung 1, 2,

Zeichen auswählen

Zeichensatz
zerteilen

Structured Query Language siehe SQL
strukturierte Daten

Subtraktion
switch
switch-Anweisung
syntaktischer Fehler

Syntax-Highlighting 1, 2, 3,
sys.exit()

sys.path

T

Tab siehe Einrückung

Tastenkürzel
in IDLE konfigurieren
ternärer Operator

Testen

Text
ausgeben

Verkettung

Texteditor

Theme siehe Profil
time()

Tool

Entwicklungswerkzeug

True
try
try-Block

Tupel 1, 2,
auf Elemente zugreifen
ausgeben

Elemente hinzufügen
erzeugen

Index verwenden

Verschachtelung

Tutorial 1, 2,

XML
typografische Zeichen

U

Überladung

Operator

Umgebungsvariablen 1, 2,
setzen

Umgebunsgvariable

PYTHONPATH
unärer Operator

Unicode

Unit-Test
unstrukturierte Daten
upper()

V

ValueError-Ausnahme

Variable

Instanzvariable 1, 2,

Klassenvariable 1, 2,

Operatoren 1, 2,

Typ bestimmen

Wert zuweisen

Zuweisung

Vererbung 1, 2,

Vergleich

Bereichsprüfung

Vergleichsoperator 1, 2, 3,

Verkettung 1, 2,

Verortung

Verschachtelung

Ausnahmebehandlung

Schleife 1, 2,

Selektionsbaum

Tupel

Verschlüsselung 1, 2,

Schlüssel

Versionskontrolle

Verzeichnis
ändern

Hierarchie
löschen
rmdir()

rmtree()

vim-Editor

Virtualisierung
virtuelle Umgebung

Vorrangsregel

W

Warnung

Warteschlange 1, 2,

Deque

Element hinzufügen
empty()

erstellen
full()

Füllstand prüfen
put()

Warteschlange|Deque

Warteschlange|Element löschen

Warteschlange|get()

Webanwendung

Werkzeug siehe Entwicklungswerkzeug

Wert

Bereichsprüfung

Boolescher

Längenprüfung

Variablen zuweisen
while
while-Schleife

Bedingung

Windows

Installation

Installationspfad

PATH-Variable

Programmordner

Umgebungsvariable setzen

Umgebungsvariablen
wissenschaftliche Notation
with

Writer

X

XML 1, 2,

Tutorial

XOR

Z

Zahlensysteme

Binärsystem

Dezimalsystem

Hexadezimalsystem

Oktalsystem

Umrechnung

Zeichen
in einem String auswählen

Zeichenkette siehe String 1, 2, 3,

Zeichensatz

ZeroDivisionError-Ausnahme

Zugriffsmethode siehe Akzessor

Zuweisung

Zuweisungsoperator 1, 2,

~

WILEY END USER LICENSE AGREEMENT

Go to www.wiley.com/go/eula to access Wiley's ebook EULA.