Untitled - Hugendubel
Werbung
Xpert.press Die Reihe Xpert.press vermittelt Professionals in den Bereichen Softwareentwicklung, Internettechnologie und IT-Management aktuell und kompetent relevantes Fachwissen über Technologien und Produkte zur Entwicklung und Anwendung moderner Informationstechnologien. Mark Pilgrim Python 3 – Intensivkurs Projekte erfolgreich realisieren Übersetzt aus dem Amerikanischen von Florian Wollenschein 1 3 Mark Pilgrim 101 Forestcrest Court Apex NC 27502 USA [email protected] Übersetzer Florian Wollenschein Wertheimer Straße 21 97828 Marktheidenfeld Deutschland [email protected] Übersetzung aus dem Amerikanischen mit freundlicher Genehmigung des Autors. Titel der amerikanischen Originalausgabe: Dive into Python 3, Apress 2009. ISBN 978-3-642-04376-5 e-ISBN 978-3-642-04377-2 DOI 10.1007/978-3-642-04377-2 Springer Heidelberg Dordrecht London New York Xpert.press ISSN 1439-5428 Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar. Springer-Verlag Berlin Heidelberg 2010 Dieses Werk ist urheberrechtlich geschützt. Die dadurch begründeten Rechte, insbesondere die der Übersetzung, des Nachdrucks, des Vortrags, der Entnahme von Abbildungen und Tabellen, der Funksendung, der Mikroverfilmung oder der Vervielfältigung auf anderen Wegen und der Speicherung in Datenverarbeitungsanlagen, bleiben, auch bei nur auszugsweiser Verwertung, vorbehalten. Eine Vervielfältigung dieses Werkes oder von Teilen dieses Werkes ist auch im Einzelfall nur in den Grenzen der gesetzlichen Bestimmungen des Urheberrechtsgesetzes der Bundesrepublik Deutschland vom 9. September 1965 in der jeweils geltenden Fassung zulässig. Sie ist grundsätzlich vergütungspflichtig. Zuwiderhandlungen unterliegen den Strafbestimmungen des Urheberrechtsgesetzes. Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Werk berechtigt auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dürften. Einbandentwurf: KünkelLopka GmbH, Heidelberg Gedruckt auf säurefreiem Papier Springer ist Teil der Fachverlagsgruppe Springer Science+Business Media (www.springer.com) Vorwort Geschichte einer Übersetzung Es begann im April 2009. Ich hatte gerade nichts Wichtiges zu tun, da kam mir die Idee, Dive Into Python (das englische Original der älteren Version dieses Buches) ins Deutsche zu übersetzen. Erfahrung im Übersetzen und in der Programmierung hatte ich über die letzten Jahre gesammelt. Probleme sollte es also nicht geben. Doch: vielleicht eins. Ich wusste nicht, ob DIP, wie ich es mittlerweile nenne, bereits ins Deutsche übersetzt war (immerhin hatte es schon über fünf Jahre auf dem Buckel). Ein Besuch der Homepage brachte aber schnell Klarheit und es stellte sich heraus, dass es bisher keine deutsche Übersetzung gab. Sodann beschloss ich frohen Mutes die Idee in die Tat umzusetzen und schrieb Mark Pilgrim eine E-Mail mit einem Hinweis darauf. Einen Tag (es können auch zwei gewesen sein) später antwortete er auch schon mit der Mitteilung, dass bereits Dive Into Python 3 in Arbeit sei und ich doch vielleicht lieber das übersetzen solle, da DIP veraltet sei und in nächster Zeit auch nicht aktualisiert werde. Gut, dachte ich mir, dann eben DIP 3! Je aktueller, desto besser. Ich begann sofort mit der Übersetzung. Am 18. Mai 2009 stöberte ich ein wenig im Internet und stieß eher zufällig auf das Impressum der amerikanischen Ausgabe von DIP, die bei Apress erschienen war. Springer-Verlag, Heidelberg, Germany fiel mir sofort ins Auge. Offensichtlich gehörte Apress also zum deutschen Springer-Verlag. Mir kam ein Gedanke, der sich im Nachhinein als nicht so abwegig herausstellte, wie ich anfangs vermutet hatte. Eine E-Mail an Springer musste her. Ich surfte also zu springer.com und klickte mich zum Kontaktformular. Ich fragte, ob sie Interesse daran hätten, Dive Into Python 3 auf Deutsch herauszubringen. Die Chance überhaupt eine – nicht automatisch generierte – Antwort zu erhalten, schätzte ich damals auf etwa 25 Prozent. Warum gerade 25 Prozent? Sagen wir vielleicht lieber, es erschien mir recht unwahrscheinlich. Springer ist immerhin der zweitgrößte Wissenschaftsverlag der Welt. Warum sollte gerade dieser riesige Verlag sich für die Idee eines jungen Übersetzers erwärmen? Ich sollte eines Besseren belehrt werden. Dorothea Glaunsinger, die Assistentin des für den Informatik-Bereich zuständigen Lektors Hermann Engesser, antwortete bereits nach kurzer Zeit vi Vorwort und teilte mir mit, dass es in der Tat eine sehr interessante Idee sei. Wenn möglich sollte ich ein Probekapitel senden, damit sie sich ein Urteil über meine Übersetzung bilden könnten. Hermann Engesser melde sich dann bei mir. Ich schickte meine zwei, bereits fertigen, Kapitel per E-Mail an Frau Glaunsinger und war nun aufgeregter denn je. Werden sie die Übersetzung positiv aufnehmen? (Nun, Sie wissen bereits, wie die Geschichte ausgegangen ist, da Sie dieses Buch nun in Händen halten, doch ich wusste es damals nicht.) Nachdem Frau Glaunsinger mir bereits kurze Zeit später geschrieben hatte, dass die Probekapitel sehr gut seien, teilte mir auch Herr Engesser später sein Urteil mit. Sehr gut, meinte auch er. Hätte ich Champagner gehabt – würde ich überhaupt Champagner trinken – hätte ich mir nun eine Flasche aufgemacht. Sie müssen wissen, dass dies mein erster Versuch war, bei einem richtigen Verlag zu veröffentlichen. Wenn man dann ein so positives Feedback erhält, ist das wie ein Sechser im Lotto … oder … nein, sagen wir lieber wie ein Fünfer mit Zusatzzahl. Der Sechser kommt erst noch. Nach weiteren E-Mails kam das erste Telefonat mit Hermann Engesser, meinem Lektor in Spe (und das meine ich in der wörtlichen Übersetzung „in der Hoffnung“). Es wurden hauptsächlich rechtliche Fragen besprochen und ich sollte Mark Pilgrim mitteilen, dass er doch bitte seine Erlaubnis zur Veröffentlichung an Springer sendet. Abschließend fragte ich, wie hoch er die Wahrscheinlichkeit einer Veröffentlichung einschätze. 80:20. Wow! Ich versuchte cool zu bleiben, was mir aber – auch bei unserem zweiten Telefonat – nicht sehr gut gelang. Doch auch Hermann Engesser klang immer so begeistert, dass er mich damit ansteckte. Nachdem auch die Marketingleute das Projekt abgesegnet hatten, rief mich Herr Engesser am 20. Juli, also fast genau zwei Monate nach meiner ersten Kontaktaufnahme, erneut an. Er werde mir einen Vertrag zuschicken. Diesen Vertrag erhielt ich in dreifacher Ausfertigung. Als ich alle drei Exemplare unterschrieben hatte, schickte ich sie weiter an Mark Pilgrim nach North Carolina (die Deutsche Post berechnete dafür sechs Euro, die es mir aber mehr als wert waren). Parallel dazu erschien auf springer.com bereits „unser“ Buch. Der Grafiker (oder die Grafikerin), der/die den Umschlag gestaltet hat, hat wirklich ganze Arbeit geleistet. Sehen Sie doch einfach selbst nach. Die Schlange in den Händen des Männleins ist doch ein toller Verweis auf Python. Leider war die deutsche (oder die amerikanische) Post nicht in der Lage den Vertrag auszuliefern. Die Gründe dafür werde ich wohl niemals erfahren. Als er auch nach vier Wochen noch nicht bei Mark Pilgrim angekommen war, schickte Frau Glaunsinger den Vertrag per E-Mail an ihn. Kurze Zeit später erhielt ich zwei unterschriebene Exemplare zurück und sendete eines davon unverzüglich nach Heidelberg. Damit war nun also auch rechtlich alles in trockenen Tüchern. Unterdessen übersetzte ich den restlichen Text und führte schließlich die Formatierung des Manuskripts aus. Die letze Seite stellte ich an einem Samstagmorgen fertig. Ich kann nur sagen, dass die Arbeit an diesem Buch eine unglaubliche Erfahrung für mich war. Ein halbes Jahr Arbeit meinerseits steckt zwischen den beiden Buchdeckeln. Ein halbes Jahr Nachtschichten, Wochenendarbeit und ab und zu ein klein wenig Ärger mit meinem PC. Ich hoffe, dass sich diese Arbeit gelohnt hat und Sie Vorwort vii einiges aus diesem Buch lernen und in der Praxis anwenden werden. Sie finden in diesem Werk in sehr kompakter Form alle wichtigen Elemente, die Python 3 zu bieten hat. Über Feedback freue ich mich sehr; besuchen Sie einfach python3-intensivkurs. de oder florianwollenschein.de und setzen Sie sich mit mir in Verbindung. Wenn Sie Mark Pilgrim etwas zukommen lassen möchten, surfen Sie zu diveintomark.org. Unter python3-intensivkurs.de finden Sie außerdem den in diesem Buch verwendeten Beispielcode zum Herunterladen. Nun wünsche ich Ihnen viel Spaß und Erfolg bei der Arbeit mit diesem Buch. November 2009 Florian Wollenschein Danksagung Danksagung von Mark Pilgrim Ich danke meiner Frau, die mit ihrer nie enden wollenden Unterstützung und Ermutigung dazu beigetragen hat, dass dieses Buch nicht nur ein weiterer Punkt auf meiner To-Do-Liste ist. Mein Dank gilt Raymond Hettinger, dessen Alphametik-Löser die Grundlage des achten Kapitels bildet. Ebenso danke ich Jesse Noller dafür, dass sie mir während der PyCon 2009 so viele Dinge erklärt hat, die ich somit jedem anderen erklären konnte. Schließlich danke ich den vielen Menschen, die mir während des Schreibens ihr Feedback zukommen ließen, insbesondere gilt mein Dank Giulio Piancastelli, Florian Wollenschein und all den netten Menschen von python.reddit.com. Danksagung des Übersetzers Mein Dank gilt zu allererst Mark Pilgrim, der diese Übersetzung mit seinem Buch und seiner unglaublichen Unterstützung während der ganzen Monate überhaupt erst möglich gemacht hat. Thank you very much, Mark. Außerdem danke ich Hermann Engesser, Dorothea Glaunsinger und Gabriele Fischer vom Springer-Verlag. Alle drei haben das Projekt voller Begeisterung betreut und mir immer und immer wieder Fragen beantwortet. Es waren harte (und dennoch schöne) Wochen dieses Buch zu übersetzen und so gilt mein Dank auch und ganz besonders Daniela, die mir Tag für Tag unter die Arme gegriffen hat. Meine Eltern Jürgen und Cornelia, meine Schwester Sarah und meine Oma Margarete darf ich nicht außen vor lassen … Hey, es ist endlich gedruckt!!! ix Inhaltsverzeichnis 1 Python installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1.1 Los geht’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1.2 Welche Python-Version ist die Richtige für Sie? . . . . . . . . . . . . . . . . 1 1.3 Installation unter Microsoft Windows . . . . . . . . . . . . . . . . . . . . . . . . 2 1.4 Installation unter Mac OS X . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 1.5 Installation unter Ubuntu Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 1.6 Installation auf anderen Plattformen . . . . . . . . . . . . . . . . . . . . . . . . . . 7 1.7 Verwenden der Python-Shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 1.8 Python-Editoren und -IDEs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 2 Ihr erstes Python-Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.1 Los geht’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.2 Funktionen deklarieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 2.2.1 Pythons Datentypen im Vergleich mit denen anderer Sprachen������������������������������������������������������������ 13 2.3 Lesbaren Code schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 2.3.1 Docstrings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 2.4 Der import-Suchpfad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 2.5 Alles ist ein Objekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 2.5.1 Was ist ein Objekt? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 2.6 Code einrücken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 2.7 Ausnahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 2.7.1 Importfehler abfangen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 2.8 Ungebundene Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.9 Groß- und Kleinschreibung bei Namen . . . . . . . . . . . . . . . . . . . . . . . 21 2.10 Skripte ausführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 3 Native Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 3.1 Los geht’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 3.2 Boolesche Werte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 3.3 Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 3.3.1 int- in float-Werte umwandeln und anders herum . . . . . . 25 3.3.2 Einfache Rechenoperationen . . . . . . . . . . . . . . . . . . . . . . . . . . 26 xi xii Inhaltsverzeichnis 3.3.3 Brüche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.3.4 Trigonometrie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.3.5 Zahlen in einem booleschen Kontext . . . . . . . . . . . . . . . . . . . 28 3.4 Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 3.4.1 Erstellen einer Liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 3.4.2 Slicing einer Liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 3.4.3 Elemente zu einer Liste hinzufügen . . . . . . . . . . . . . . . . . . . . 31 3.4.4 Innerhalb einer Liste nach Werten suchen . . . . . . . . . . . . . . . 33 3.4.5 Elemente aus einer Liste entfernen . . . . . . . . . . . . . . . . . . . . . 34 3.4.6 Elemente aus einer Liste entfernen: Bonusrunde . . . . . . . . . . 34 3.4.7 Listen in einem booleschen Kontext . . . . . . . . . . . . . . . . . . . . 35 3.5 Tupel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 3.5.1 Tupel in einem booleschen Kontext . . . . . . . . . . . . . . . . . . . . 38 3.5.2 Mehrere Werte auf einmal zuweisen . . . . . . . . . . . . . . . . . . . . 38 3.6 Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 3.6.1 Ein Set erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 3.6.2 Ein Set verändern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 3.6.3 Elemente aus einem Set entfernen . . . . . . . . . . . . . . . . . . . . . 42 3.6.4 Einfache Mengenoperationen . . . . . . . . . . . . . . . . . . . . . . . . . 43 3.6.5 Sets in einem booleschen Kontext . . . . . . . . . . . . . . . . . . . . . 45 3.7 Dictionarys . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 3.7.1 Erstellen eines Dictionarys . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 3.7.2 Ein Dictionary verändern . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 3.7.3 Dictionarys mit gemischten Werten . . . . . . . . . . . . . . . . . . . . 48 3.7.4 Dictionarys in einem booleschen Kontext . . . . . . . . . . . . . . . 49 3.8 None . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 3.8.1 None in einem booleschen Kontext . . . . . . . . . . . . . . . . . . . . 50 4 Comprehensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 4.1 Los geht’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 4.2 Mit Dateien und Verzeichnissen arbeiten . . . . . . . . . . . . . . . . . . . . . . 51 4.2.1 Das aktuelle Arbeitsverzeichnis . . . . . . . . . . . . . . . . . . . . . . . 51 4.2.2 Mit Dateinamen und Verzeichnisnamen arbeiten . . . . . . . . . . 52 4.2.3 Verzeichnisse auflisten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 4.2.4 Metadaten von Dateien erhalten . . . . . . . . . . . . . . . . . . . . . . . 55 4.2.5 Absolute Pfadnamen erstellen . . . . . . . . . . . . . . . . . . . . . . . . . 56 4.3 List Comprehensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 4.4 Dictionary Comprehensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 4.4.1 Andere tolle Sachen, die man mit Dictionary Comprehensions machen kann�������������������������������������������������� 60 4.5 Set Comprehensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 5 Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 5.1 Langweiliges Zeug, das Sie wissen müssen, bevor es losgeht . . . . . . 61 5.2 Unicode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 5.3 Los geht’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 Inhaltsverzeichnis xiii 5.4 Strings formatieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 5.4.1 Zusammengesetzte Feldnamen . . . . . . . . . . . . . . . . . . . . . . . 67 5.4.2 Formatmodifizierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 5.5 Andere häufig verwendete String-Methoden . . . . . . . . . . . . . . . . . . 69 5.5.1 Slicen eines Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 5.6 Strings vs. Bytes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 5.7 Nachbemerkung – Zeichencodierung von Python-Quelltext . . . . . . 75 6 Reguläre Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 6.1 Los geht’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 6.2 Fallbeispiel: Adresse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 6.3 Fallbeispiel: römische Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 6.3.1 Prüfen der Tausender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 6.3.2 Prüfen der Hunderter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 6.4 Verwenden der {n,m}-Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 6.4.1 Prüfen der Zehner und Einer . . . . . . . . . . . . . . . . . . . . . . . . . 85 6.5 Ausführliche reguläre Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 6.6 Fallbeispiel: Telefonnummern gliedern . . . . . . . . . . . . . . . . . . . . . . 88 6.7 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 7 Closures und Generatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 7.1 Abtauchen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 7.2 Nutzen wir reguläre Ausdrücke! . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 7.3 Eine Funktionsliste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 7.4 Eine Musterliste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 7.5 Eine Musterdatei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 7.6 Generatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 7.6.1 Ein Fibonacci-Generator . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 7.6.2 Ein Generator für Plural-Regeln . . . . . . . . . . . . . . . . . . . . . . 107 8 Klassen und Iteratoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 8.1 Los geht’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 8.2 Klassen definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 8.2.1 Die __init__()-Methode . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 8.3 Klassen instanziieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 8.4 Instanzvariablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 8.5 Ein Fibonacci-Iterator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 8.6 Ein Iterator für Plural-Regeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 9 Erweiterte Iteratoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 9.1 Los geht’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 9.2 Alle Vorkommen eines Musters finden . . . . . . . . . . . . . . . . . . . . . . . 123 9.3 Die einmaligen Elemente einer Folge finden . . . . . . . . . . . . . . . . . . 124 9.4 Bedingungen aufstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 9.5 Generator-Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 9.6 Permutationen berechnen … Auf die faule Art! . . . . . . . . . . . . . . . . 126 xiv Inhaltsverzeichnis 9.7 Anderes cooles Zeug im Modul itertools . . . . . . . . . . . . . . . 128 9.8 Eine neue Art der String-Manipulation . . . . . . . . . . . . . . . . . . . . . 132 9.9 Herausfinden, ob ein beliebiger String ein Python-Ausdruck ist ���������������������������������������������������������������������� 134 9.10 Alles zusammenfügen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 10 Unit Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 10.1 Los geht’s (noch nicht) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 10.2 Eine Frage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 10.3 Anhalten und Alarm schlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146 10.4 Wieder anhalten und wieder Alarm . . . . . . . . . . . . . . . . . . . . . . . . 150 10.5 Noch eine Kleinigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152 10.6 Eine erfreuliche Symmetrie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 10.7 Noch mehr schlechte Eingaben . . . . . . . . . . . . . . . . . . . . . . . . . . . 158 11 Refactoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 11.1 Los geht’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 11.2 Mit sich ändernden Anforderungen umgehen . . . . . . . . . . . . . . . . 166 11.3 Refactoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170 11.4 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 12 Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 12.1 Los geht’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 12.2 Aus Textdateien lesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 12.2.1 Die Zeichencodierung zeigt ihre hässliche Fratze . . . . . . 178 12.2.2 Streamobjekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 12.2.3 Daten aus einer Textdatei lesen . . . . . . . . . . . . . . . . . . . . 180 12.2.4 Dateien schließen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 12.2.5 Automatisches Schließen von Dateien . . . . . . . . . . . . . . . 183 12.2.6 Daten zeilenweise lesen . . . . . . . . . . . . . . . . . . . . . . . . . . 184 12.3 In Textdateien schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185 12.3.1 Schon wieder Zeichencodierung . . . . . . . . . . . . . . . . . . . 186 12.4 Binärdateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187 12.5 Streamobjekte aus anderen Quellen als Dateien . . . . . . . . . . . . . . 188 12.5.1 Umgang mit komprimierten Dateien . . . . . . . . . . . . . . . . 189 12.6 Standardeingabe, -ausgabe und -fehler . . . . . . . . . . . . . . . . . . . . . 191 12.6.1 Die Standardausgabe umleiten . . . . . . . . . . . . . . . . . . . . . 192 13 XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195 13.1 Los geht’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195 13.2 Ein XML-Crashkurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197 13.3 Der Aufbau eines Atom-Feeds . . . . . . . . . . . . . . . . . . . . . . . . . . . 199 13.4 XML parsen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201 13.4.1 Elemente sind Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202 13.4.2 Attribute sind Dictionarys . . . . . . . . . . . . . . . . . . . . . . . . 203 13.5 Innerhalb eines XML-Dokuments nach Knoten suchen . . . . . . . . 204 Inhaltsverzeichnis xv 13.6 Noch mehr XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207 13.7 XML erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209 13.8 Beschädigtes XML parsen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212 14 Python-Objekte serialisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215 14.1 Los geht’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215 14.1.1 Eine kurze Bemerkung zu den Beispielen dieses Kapitels ������������������������������������������������������������������ 216 14.2 Daten in einer pickle-Datei speichern . . . . . . . . . . . . . . . . . . . . 216 14.3 Daten aus einer pickle-Datei lesen . . . . . . . . . . . . . . . . . . . . . . 218 14.4 pickle ohne Datei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219 14.5 Bytes und Strings zeigen ein weiteres Mal ihre hässlichen Fratzen �������������������������������������������������������������������������� 220 14.6 pickle-Dateien debuggen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220 14.7 Serialisierte Python-Objekte in anderen Sprachen lesbar machen���������������������������������������������������������������������������������� 223 14.8 Daten in einer JSON-Datei speichern . . . . . . . . . . . . . . . . . . . . . . 223 14.9 Entsprechungen der Python-Datentypen in JSON . . . . . . . . . . . . 225 14.10 Von JSON nicht unterstützte Datentypen serialisieren . . . . . . . . . 226 14.11 Daten aus einer JSON-Datei laden . . . . . . . . . . . . . . . . . . . . . . . . 229 15 HTTP-Webdienste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233 15.1 Los geht’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233 15.2 Eigenschaften von HTTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234 15.2.1 Caching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234 15.2.2 Überprüfen des Datums der letzten Änderung . . . . . . . . 236 15.2.3 ETags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237 15.2.4 Komprimierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238 15.2.5 Weiterleitungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238 15.3 Wie man Daten nicht über HTTP abrufen sollte . . . . . . . . . . . . . . 239 15.4 Was geht über’s Netz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240 15.5 Vorstellung von httplib2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243 15.5.1 Ein kleiner Exkurs zur Erklärung, warum httplib2 Bytes statt Strings zurückgibt�������������������������������������������� 246 15.5.2 Wie httplib2 mit Caching umgeht . . . . . . . . . . . . . . . 247 15.5.3 Wie httplib2 mit Last-Modified- und ETagHeadern umgeht���������������������������������������������������������������� 250 15.5.4 Wie httplib2 mit Komprimierung umgeht . . . . . . . . . . . . 252 15.5.5 Wie httplib2 mit Weiterleitungen umgeht . . . . . . . . . . . . 253 15.6 Über HTTP-GET hinaus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257 15.7 Über HTTP-POST hinaus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260 16 Fallstudie: chardet zu Python 3 portieren . . . . . . . . . . . . . . . . . . . . 263 16.1 Los geht’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263 16.2 Was ist die automatische Zeichencodierungserkennung? . . . . . . . 263 16.2.1 Ist das nicht unmöglich? . . . . . . . . . . . . . . . . . . . . . . . . . 263 16.2.2 Existiert solch ein Algorithmus? . . . . . . . . . . . . . . . . . . . 264 xvi Inhaltsverzeichnis 16.3 Das chardet-Modul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264 16.3.1 UTF-n mit einer Byte Order Mark . . . . . . . . . . . . . . . . . . 265 16.3.2 Escape-Codierungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265 16.3.3 Multi-Byte-Codierungen . . . . . . . . . . . . . . . . . . . . . . . . . 265 16.3.4 Single-Byte-Codierungen . . . . . . . . . . . . . . . . . . . . . . . . 266 16.3.5 windows-1252 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267 16.4 2to3 ausführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267 16.5 Mehr-Dateien-Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270 16.6 Anpassen, was 2to3 nicht anpassen kann . . . . . . . . . . . . . . . . . . 272 16.6.1 False ist ungültige Syntax . . . . . . . . . . . . . . . . . . . . . . 272 16.6.2 Kein Modul namens constants . . . . . . . . . . . . . . . . . 273 16.6.3 Bezeichner 'file' ist nicht definiert . . . . . . . . . . . . . . 274 16.6.4 Ein Stringmuster kann nicht auf ein byteartiges Objekt angewandt werden ������������������������������������������������ 274 16.6.5 Implizite Umwandlung eines 'bytes'-Objekts in str nicht möglich ������������������������������������������������������������ 276 16.6.6 Nicht unterstützte Datentypen für Operand +: 'int' und 'bytes' ������������������������������������������������ 278 16.6.7 ord() erwartet String der Länge 1, int gefunden . . . . 280 16.6.8 Unsortierbare Datentypen: int() >= str() . . . . . . 282 16.6.9 Globaler Bezeichner 'reduce' ist nicht definiert . . . . 284 16.7 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286 17 Python-Bibliotheken packen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287 17.1 Los geht’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287 17.2 Was kann Distutils nicht für Sie tun? . . . . . . . . . . . . . . . . . . . . . . 288 17.3 Verzeichnisstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289 17.4 Das Setup-Skript schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291 17.5 Ihr Paket klassifizieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292 17.5.1 Beispiele guter Paket-Klassifizierer . . . . . . . . . . . . . . . . . 293 17.6 Zusätzliche Dateien mit einem Manifest angeben . . . . . . . . . . . . 294 17.7 Ihr Setup-Skript auf Fehler untersuchen . . . . . . . . . . . . . . . . . . . . 295 17.8 Eine Quellcode-Distribution erstellen . . . . . . . . . . . . . . . . . . . . . . 296 17.9 Einen grafischen Installer erstellen . . . . . . . . . . . . . . . . . . . . . . . . 298 17.9.1 Installierbare Pakete für andere Betriebssysteme erzeugen ���������������������������������������������������������������������������� 299 17.10 Ihre Software zum Python Package Index hinzufügen . . . . . . . . . 299 17.11 Die Zukunft des Packens von Python-Software . . . . . . . . . . . . . . 301 Anhang A – Code mithilfe von 2to3 von Python 2 zu Python 3 portieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303 A.1 Los geht’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303 A.2 print-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303 A.3 Unicode-Stringliterale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304 A.4 Globale unicode()-Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . 304
