Effektiv Python programmieren - Brett Slatkin - E-Book

Effektiv Python programmieren E-Book

Brett Slatkin

0,0

Beschreibung

  • Bewährte Verfahren, Tipps und Tricks für robusten, leistungsfähigen und wartungsfreundlichen Code
  • Grundlegende Aufgaben besser und effektiver erledigen
  • Lösungen für das Debuggen, Testen und Optimieren zur Verbesserung von Qualität und Performance

Der Einstieg in die Python-Programmierung ist einfach, daher ist die Sprache auch so beliebt. Pythons einzigartige Stärken und Ausdrucksmöglichkeiten sind allerdings nicht immer offensichtlich. Zudem gibt es diverse verborgene Fallstricke, über die man leicht stolpern kann.

Dieses Buch vermittelt insbesondere eine Python-typische Herangehensweise an die Programmierung. Brett Slatkin nutzt dabei die Vorzüge von Python zum Schreiben von außerordentlich stabilem und schnellem Code. Er stellt 90 bewährte Verfahren, Tipps und Tricks vor, die er anhand praxisnaher Codebeispiele erläutert. Er setzt dabei den kompakten, an Fallbeispielen orientierten Stil von Scott Meyers populärem Buch »Effektiv C++ programmieren« ein.

Auf Basis seiner jahrelangen Erfahrung mit der Python-Infrastruktur bei Google demonstriert Slatkin weniger bekannte Eigenarten und Sprachelemente, die großen Einfluss auf das Verhalten des Codes und die Performance haben. Sie erfahren, wie sich grundlegende Aufgaben am besten erledigen lassen, damit Sie leichter verständlichen, wartungsfreundlicheren und einfach zu verbessernden Code schreiben können.

Aus dem Inhalt:
  • Umsetzbare Richtlinien für alle wichtigen Bereiche der Entwicklung in Python 3 mit detaillierten Erklärungen und Beispielen
  • Funktionen so definieren, dass Code leicht wiederverwendet und Fehler vermieden werden können
  • Bessere Verfahren und Idiome für die Verwendung von Abstraktionen und Generatorfunktionen
  • Systemverhalten mithilfe von Klassen und Interfaces präzise definieren
  • Stolpersteine beim Programmieren mit Metaklassen und dynamischen Attributen umgehen
  • Effizientere und klare Ansätze für Nebenläufigkeit und parallele Ausführung
  • Tipps und Tricks zur Nutzung von Pythons Standardmodulen
  • Tools und Best Practices für die Zusammenarbeit mit anderen Entwicklern
  • Lösungen für das Debuggen, Testen und Optimieren zur Verbesserung von Qualität und Performance
Stimme zum Buch:

»Ich habe dieses Buch seit dem Erscheinen der ersten Ausgabe 2015 mit Begeisterung empfohlen. Die neue Ausgabe, die für Python 3 erweitert und aktualisiert wurde, ist eine wahre Fundgrube an Erfahrungen der Python-Programmierung in der Praxis, von denen Programmierer auf jedem Niveau profitieren.«

Wes McKinney, Begründer des Python-Projekts Pandas, Leiter von Ursa Labs

Sie lesen das E-Book in den Legimi-Apps auf:

Android
iOS
von Legimi
zertifizierten E-Readern
Kindle™-E-Readern
(für ausgewählte Pakete)

Seitenzahl: 488

Veröffentlichungsjahr: 2020

Das E-Book (TTS) können Sie hören im Abo „Legimi Premium” in Legimi-Apps auf:

Android
iOS
Bewertungen
0,0
0
0
0
0
0
Mehr Informationen
Mehr Informationen
Legimi prüft nicht, ob Rezensionen von Nutzern stammen, die den betreffenden Titel tatsächlich gekauft oder gelesen/gehört haben. Wir entfernen aber gefälschte Rezensionen.



Inhaltsverzeichnis
Impressum
Einleitung
Über den Autor
Danksagungen
Kapitel 1: Pythons Sicht der Dinge
Punkt 1: Kenntnis der Python-Version‌
Punkt 2: Stilregeln gemäß PEP 8
Punkt 3: Unterschiede zwischen bytes und str
Punkt 4: Interpolierte F-Strings statt C-Formatierungsstrings und str.format
Punkt 5: Hilfsfunktionen statt komplizierter Ausdrücke
Punkt 6: Mehrfachzuweisung beim Entpacken statt Indizierung
Punkt 7: enumerate statt range
Punkt 8: Gleichzeitige Verarbeitung von Iteratoren mit zip
Punkt 9: Verzicht auf else-Blöcke nach for- und while-Schleifen
Punkt 10: Wiederholungen verhindern durch Zuweisungsausdrücke
Kapitel 2: Listen und Dictionaries
Punkt 11: Zugriff auf Listen durch Slicing
Punkt 12: Verzicht auf Abstand und Start-/Ende-Index in einem einzigen Ausdruck
Punkt 13: Vollständiges Entpacken statt Slicing
Punkt 14: Sortieren nach komplexen Kriterien mit dem key-Parameter
Punkt 15: Vorsicht bei der Reihenfolge von dict-Einträgen
Punkt 16: get statt in und KeyError zur Handhabung fehlender Dictionary-Schlüssel verwenden
Punkt 17: defaultdict statt setdefault zur Handhabung fehlender Objekte verwenden
Punkt 18: Schlüsselabhängige Standardwerte mit __missing__ erzeugen
Kapitel 3: Funktionen
Punkt 19: Bei Funktionen mit mehreren Rückgabewerten nicht mehr als drei Variablen entpacken
Punkt 20: Exceptions statt Rückgabe von None
Punkt 21: Closures und der Gültigkeitsbereich von Variablen
Punkt 22: Klare Struktur dank variabler Anzahl von Positionsargumenten
Punkt 23: Optionale Funktionalität durch Schlüsselwort-Argumen‌te
Punkt 24: Dynamische Standardwerte von Argumenten mittels None und Docstrings
Punkt 25: Eindeutigkeit durch reine Schlüsselwort- und reine Positionsargumente
Punkt 26: Funktions-Decorators mit functools.wraps definieren
Kapitel 4: Listen-Abstraktionen und Generatoren
Punkt 27: Listen-Abstraktionen statt map und filter
Punkt 28: Nicht mehr als zwei Ausdrücke in Listen-Abstraktionen
Punkt 29: Doppelte Arbeit in Abstraktionen durch Zuweisungsausdrücke vermeiden
Punkt 30: Generatoren statt Rückgabe von Listen
Punkt 31: Vorsicht beim Iterieren über Argumente
Punkt 32: Generatorausdrücke für umfangreiche Listen-Abstraktionen verwenden
Punkt 33: Mehrere Generatoren mit yield from verknüpfen
Punkt 34: Keine Datenübermittlung an Generatoren mit send
Punkt 35: Zustandsübergänge in Generatoren mit throw vermeiden
Punkt 36: Iteratoren und Generatoren mit itertools verwenden
Kapitel 5: Klassen und Schnittstellen
Punkt 37: Klassen statt integrierte Datentypen verschachteln
Punkt 38: Funktionen statt Klassen bei einfachen Schnittstellen
Punkt 39: Polymorphismus und generische Erzeugung von Objekten
Punkt 40: Initialisierung von Basisklassen durch super
Punkt 41: Verknüpfte Funktionalität mit Mix-in-Klassen
Punkt 42: Öffentliche statt private Attribute
Punkt 43: Benutzerdefinierte Container-Klassen durch Erben von collections.abc
Kapitel 6: Metaklassen und Attribute
Punkt 44: Einfache Attribute statt Getter- und Setter-Methoden
Punkt 45: @property statt Refactoring von Attributen
Punkt 46: Deskriptoren für wiederverwendbare @property-Methoden verwenden
Punkt 47: Verzögerte Zuweisung zu Attributen mittels __getattr__, __getattribute__ und __setattr__
Punkt 48: Unterklassen mit __init_subclass__ überprüfen
Punkt 49: Klassen mittels __init_subclass__ registrieren
Punkt 50: Zugriff auf Klassenattribute mit __set_name__
Punkt 51: Klassen-Decorators statt Metaklassen für Klassenerweiterungen nutzen
Kapitel 7: Nebenläufigkeit und parallele Ausführung
Punkt 52: Verwaltung von Kindprozessen mittels subprocess
Punkt 53: Threads, blockierende Ein-/Ausgabevorgänge und parallele Ausführung
Punkt 54: Wettlaufsituationen in Threads mit Lock verhindern
Punkt 55: Threads koordinieren mit Queue
Punkt 56: Erkennen, wann parallele Ausführung erforderlich ist
Punkt 57: Keine neuen Thread-Instanzen beim Fan-Out
Punkt 58: Die Verwendung von Queue zur parallelen Ausführung erfordert Refactoring
Punkt 59: ThreadPoolExecutor zur parallelen Ausführung verwenden
Punkt 60: Parallele Ausführung mehrerer Funktionen mit Coroutinen
Punkt 61: asyncio statt threaded I/O
Punkt 62: Threads und Coroutinen verwenden, um die Umstellung auf asyncio zu erleichtern
Punkt 63: asyncio-Event-Loop nicht blockieren
Punkt 64: Echte parallele Ausführung mit concurrent.futures
Kapitel 8: Robustheit und Performance
Punkt 65: Alle Blöcke einer try/except/else/finally-Anweisung nutzen
Punkt 66: contextlib und with-Anweisung für wiederverwendbares try/finally-Verhalten verwenden
Punkt 67: Für örtliche Zeitangaben datetime statt time verwenden
Punkt 68: Verlässliches pickle durch copyreg
Punkt 69: Falls Genauigkeit an erster Stelle steht, decimal verwenden
Punkt 70: Vor der Optimierung Messungen vornehmen
Punkt 71: deque für Erzeuger-Verbraucher-Warteschlangen verwenden
Punkt 72: Durchsuchen von Sequenzen geordneter Elemente mit bisect
Punkt 73: heapq für Prioritätswarteschlangen verwenden
Punkt 74: memoryview und bytearray für Zero-Copy-Interaktionen mit bytes verwenden
Kapitel 9: Testen und Debuggen
Punkt 75: Debuggen mit repr-Strings
Punkt 76: Ähnliches Verhalten mit TestCase-Unterklassen überprüfen
Punkt 77: Tests mit setUp, tearDown, setUpModule und tearDownModule voneinander abschotten
Punkt 78: Mocks für Tests von Code mit komplexen Abhängigkeiten verwenden
Punkt 79: Abhängigkeiten kapseln, um das Erstellen von Mocks und Tests zu erleichtern
Punkt 80: Interaktives Debuggen mit pdb
Punkt 81: Nutzung des Arbeitsspeichers und Speicherlecks mit tracemalloc untersuchen
Kapitel 10: Zusammenarbeit
Punkt 82: Module der Python-Community
Punkt 83: Virtuelle Umgebungen zum Testen von Abhängigkeiten
Punkt 84: Docstrings für sämtliche Funktionen, Klassen und Module‌
Punkt 85: Pakete zur Organisation von Modulen und zur Bereitstellung stabiler APIs verwenden
Punkt 86: Modulweiter Code zur Konfiguration der Deployment-Umgebung
Punkt 87: Einrichten einer Root-Exception zur Abschottung von Aufrufern und APIs
Punkt 88: Zirkuläre Abhängigkeiten auflösen
Punkt 89: warnings für Refactoring und Migration verwenden
Punkt 90: Statische Analyse mit typing zum Vermeiden von Bugs

Stimmen zum Buch

»Ich habe dieses Buch seit dem Erscheinen der ersten Ausgabe 2015 mit Begeisterung empfohlen. Die neue Ausgabe, die für Python 3 erweitert und aktualisiert wurde, ist eine wahre Fundgrube an Erfahrungen der Python-Programmierung in der Praxis, von denen Programmierer auf jedem Niveau profitieren.«

Wes McKinney –Begründer des Python-Projekts Pandas, Leiter von Ursa Labs

»Wenn Sie vorher in einer anderen Sprache programmiert haben, finden Sie mit diesem Buch eine Anleitung, die einzigartigen Features, die Python zu bieten hat, zu Ihrem vollen Vorteil zu nutzen. Ich verwende Python schon seit fast zwanzig Jahren, habe aber dennoch eine Menge nützlicher Tricks gelernt, insbesondere was die neuen Features in Python 3 betrifft. Das Buch ist randvoll mit in der Praxis verwertbaren Ratschlägen und definiert gewissermaßen, was die Community meint, wenn von typisch Python-artigem Code die Rede ist.«

Simon Willison –Mitbegründer von Django

»Ich programmiere seit Jahren in Python und dachte eigentlich, dass ich die Sprache ziemlich gut kenne. Dank dieser Fundgrube voller Tipps und Verfahren habe ich viele Möglichkeiten entdeckt, meinen Python-Code zu verbessern, um ihn zu beschleunigen (z.B. Bisektion für die Suche in geordneten Listen zu nutzen), leichter verständlich (z.B. durch das Erzwingen von reinen Schlüsselwort-Argumenten) und weniger fehleranfällig (z.B. durch Entpacken mit Sternchen-Ausdrücken) zu machen sowie für Python typischen Code zu schreiben (z.B. zur gleichzeitigen Verarbeitung von Iteratoren mit zip). Zudem bietet die zweite Ausgabe eine ausgezeichnete Gelegenheit, sich schnell mit den in Python 3 verfügbaren Features vertraut zu machen, wie etwa dem Walross-Operator, F-Strings oder dem typing-Modul.«

Pamela Fox –Begründerin von Programmierkursen der Khan Academy

»Brett Slatkin hat es wieder einmal geschafft, ein breites Spektrum fundierter Verfahrensweisen der Community in einem einzigen Buch zusammenzufassen. Von exotischen Themen wie Metaklassen und Nebenläufigkeit bis hin zu unverzichtbaren Grundlagen wie Robustheit, Testen und Zusammenarbeit: Das aktualisierte Buch Effektiv Python programmieren macht das, was nach übereinstimmender Meinung Python ausmacht, einem breiten Publikum zugänglich.

Brandon Rhodes –Autor vonhttps://python-patterns.guide

»Ein ausgezeichnetes Buch, sowohl für Einsteiger als auch für erfahrene Programmierer. Die Codebeispiele und die Erklärungen sind wohldurchdacht und werden kompakt und gründlich erläutert. Die zweite Ausgabe aktualisiert die Empfehlungen für Python 3 und das ist großartig! Ich verwende Python seit fast zwanzig Jahren und habe alle paar Seiten etwas Neues dazugelernt. Die Ratschläge in diesem Buch werden allen Lesern gute Dienste leisten.«

Titus Brown –Außerordentlicher Professor an der UC Davis

»Python 3 ist endlich zur Standardversion geworden und hat schon acht kleinere Aktualisierungen erfahren, mit denen viele neue Features eingeführt wurden. Brett Slatkin meldet sich mit einer zweiten Ausgabe von Effektiv Python programmieren zurück, die eine lange Liste neuer Sprachbestandteile von Python und unkomplizierte Empfehlungen enthält. Nun werden alle neu eingeführten Dinge bis zur Python-Version 3.8 behandelt, die wir alle verwenden möchten, da wir die Version 2 hinter uns lassen. In den ersten Kapiteln finden sich eine Menge Tipps bezüglich der neuen Syntax und der in Python 3 neuen Konzepte. Dazu gehören etwa String- und Byte-Objekte, F-Strings, Zuweisungsausdrücke (und deren eigentümlicher Spitzname, den Sie vielleicht noch nicht kennen) und das vollständige Entpacken von Tupeln. In nachfolgenden Kapiteln werden größere Themen in Angriff genommen, die alle mit Dingen vollgepackt sind, die ich entweder noch nicht wusste oder die ich immer wieder versuche, anderen zu erklären, beispielsweise Metaklassen und Attribute (das Kapitel enthält gute Ratschläge, wie Klassen-Decorators statt Metaklassen, und stellt die neue spezielle Methode __init__subclass__() vor, die mir nicht vertraut war), Nebenläufigkeit und parallele Ausführung (mein Favorit: Threads, blockierende Ein-Ausgabevorgänge und parallele Ausführung, es kommen aber auch asyncio und Coroutinen zur Sprache), und Robustheit und Performance (hier wird Vor der Optimierung Messungen vornehmen empfohlen). Es ist eine wahre Freude, die Kapitel zu lesen, denn es sind sorgfältig aufbereitete Informationen über ausgezeichnete Best Practices. Ich denke, ich werde dieses Buch künftig häufig zitieren, weil es durchgehend hervorragende Ratschläge enthält. Dieses Buch ist der eindeutige Gewinner des ›Wenn Sie in diesem Jahr nur ein Buch über Python lesen ...‹-Wettbewerbs.«

Mike Bayer –Begründer von SQL Alchemy

Brett Slatkin

Effektiv Python programmieren

90 Wege für bessere Python-Programme

Übersetzung aus dem Amerikanischen von Knut Lorenzen

Impressum

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.

ISBN 978-3-7475-0178-8 2. Auflage 2020

www.mitp.de E-Mail: [email protected] Telefon: +49 7953 / 7189 - 079 Telefax: +49 7953 / 7189 - 082

© 2020 mitp Verlags GmbH & Co. KG

Dieses Werk, einschließlich aller seiner Teile, ist urheberrechtlich geschützt. Jede Verwertung außerhalb der engen Grenzen des Urheberrechtsgesetzes ist ohne Zustimmung des Verlages unzulässig und strafbar. Dies gilt insbesondere für Vervielfältigungen, Übersetzungen, Mikroverfilmungen und die Einspeicherung und Verarbeitung in elektronischen Systemen.

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.

Authorized Translation from the English language edition, entitled EFFECTIVE PYTHON: 90 SPECIFIC WAYS TO WRITE BETTER PYTHON, 2nd Edition by BRETT SLATKIN, published by Pearson Education, Inc, publishing as Addison-Wesley Professional, Copyright © 2020 Pearson Education, Inc.

All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from Pearson Education, Inc.

GERMAN language edition published by mitp Verlags GmbH & Co KG Copyright © 2020.

Lektorat: Sabine Schulz, Lisa Kresse Sprachkorrektorat: Petra Heubach-Erdmann Cover: © ssuaphotos / shutterstock.comelectronic publication: III-satz, Husby, www.drei-satz.de

Dieses Ebook verwendet das ePub-Format und ist optimiert für die Nutzung mit dem iBooks-reader auf dem iPad von Apple. Bei der Verwendung anderer Reader kann es zu Darstellungsproblemen kommen.

Der Verlag räumt Ihnen mit dem Kauf des ebooks das Recht ein, die Inhalte im Rahmen des geltenden Urheberrechts zu nutzen. Dieses Werk, einschließlich aller seiner Teile, ist urheberrechtlich geschützt. Jede Verwertung außerhalb der engen Grenzen des Urheherrechtsgesetzes ist ohne Zustimmung des Verlages unzulässig und strafbar. Dies gilt insbesondere für Vervielfältigungen, Übersetzungen, Mikroverfilmungen und Einspeicherung und Verarbeitung in elektronischen Systemen.

Der Verlag schützt seine ebooks vor Missbrauch des Urheberrechts durch ein digitales Rechtemanagement. Bei Kauf im Webshop des Verlages werden die ebooks mit einem nicht sichtbaren digitalen Wasserzeichen individuell pro Nutzer signiert.

Bei Kauf in anderen ebook-Webshops erfolgt die Signatur durch die Shopbetreiber. Angaben zu diesem DRM finden Sie auf den Seiten der jeweiligen Anbieter.

Der Familie gewidmet

Einleitung

Die Programmiersprache Python besitzt einzigartige Stärken‌ und Vorteile, die nicht immer ganz einfach zu verstehen sind. Mit anderen Sprachen vertraute Programmierer nähern sich Python oftmals nur zögerlich, anstatt die enorme Ausdrucksfähigkeit willkommen zu heißen. Andere übertreiben in entgegengesetzter Richtung und überstrapazieren Python-Funktionalitäten, was später große Probleme verursachen kann.

Dieses Buch möchte Ihnen einen Einblick geben in das, was im Englischen als pythonic (»Python-artig«)‌ bezeichnet wird: die beste Art und Weise, Python zu verwenden. Dieser Programmierstil setzt grundlegende Kenntnisse der Sprache voraus, über die Sie, wie ich annehme, bereits verfügen. Programmieranfänger lernen die bewährten Vorgehensweisen zur Nutzung von Pythons Fähigkeiten kennen. Erfahrene Programmierer hingegen erfahren, wie sie souverän mit den Eigenheiten dieses neuen Werkzeugs zurechtkommen.

Ich möchte Sie darauf vorbereiten, mit Python große Wirkung zu erzielen.

Inhalt des Buchs

In den einzelnen Kapiteln des Buchs sind verschiedene Punkte aufgeführt, die jeweils weit gefasste, aber doch verwandte Themen betreffen. Es steht Ihnen frei, ganz nach Ihrem Interesse im Buch herumzublättern. Jeder Punkt enthält kompakte und präzise Anleitungen, die Ihnen dabei helfen sollen, effektivere Python-Programme zu schreiben. Sie finden dort Ratschläge, was zu tun und was besser zu lassen ist, Hinweise zum Eingehen von Kompromissen und Erklärungen, warum das eine oder das andere die bessere Wahl ist. Es gibt Querverweise, die Ihnen beim Lesen das Verständnis erleichtern sollen.

Die zweite Ausgabe dieses Buchs konzentriert sich vollständig auf Python 3 bis einschließlich Version 3.8 (siehe Punkt 1: Kenntnis der Python-Version). Die meisten Punkte der ersten Ausgabe wurden überarbeitet und sind nach wie vor vorhanden, bei vielen hat es jedoch beträchtliche Aktualisierungen gegeben. Bei einigen Punkten hat sich mein Rat im Vergleich zur ersten Ausgabe aufgrund der Best Practices, die sich bei der Weiterentwicklung von Python ergeben haben, sogar völlig verändert. Sollten Sie trotz der endgültigen Abkündigung zum 1. Januar 2020 noch immer vornehmlich Python 2 verwenden, dürfte die erste Ausgabe dieses Buchs für Sie nützlicher sein.

Python verfolgt hinsichtlich der Standardbibliothek die Philosophie, dass sozusagen die Batterien im Lieferumfang enthalten sein sollten. Viele andere Sprachen werden mit nur einigen wenigen gängigen Paketen ausgeliefert und Sie müssen sich selbst auf die Suche begeben, wenn Sie zusätzliche wichtige Funktionalitäten benötigen. Allerdings sind viele der Standardmodule so eng mit den typischen Spracheigenheiten Pythons verflochten, dass sie sehr wohl auch Bestandteil der Sprachspezifikation sein könnten. Viele dieser Pakete sind so eng mit typischem Python-Code verwoben, dass sie eigentlich auch Teil des Sprachumfangs sein könnten. Die Anzahl der Standardmodule ist zu groß, um sie in diesem Buch behandeln zu können. Dennoch habe ich diejenigen aufgenommen, deren Kenntnis und Nutzung ich für unverzichtbar halte.

Kapitel 1: Pythons Sicht der Dinge

In der Python-Community dient das englische Adjektiv pythonic zur Beschreibung von Code, der einem bestimmten Programmierstil folgt. Dieser Stil hat sich im Laufe der Zeit durch Erfahrung im Umgang mit der Sprache und die Zusammenarbeit der Community allmählich entwickelt. Dieses Kapitel beschreibt die beste Art und Weise, die gängigsten Aufgaben in Python zu erledigen.

Kapitel 2: Listen und Dictionaries

In Python ist die häufigste Methode zur Organisation von Informationen das Speichern einer Reihe von Werten in einer Liste. Die naheliegende Ergänzung dazu ist das Dictionary, das den Werten zugeordnete Schlüssel speichert. Dieses Kapitel beschreibt, wie sich Programme mit diesen vielfältigen Bausteinen erstellen lassen.

Kapitel 3: Funktionen

In Python besitzen Funktionen eine Vielzahl von Merkmalen, die einem Programmierer das Leben erleichtern. Einige sind den Fähigkeiten anderer Programmiersprachen ähnlich, viele gibt es jedoch nur in Python. Dieses Kapitel hat zum Thema, wie man Funktionen dazu verwendet, ihren Zweck zu verdeutlichen, ihre Wiederverwendung zu ermöglichen und Bugs zu vermeiden.

Kapitel 4: Listen-Abstraktionen und Generatoren

In Python gibt es eine spezielle Syntax, um Listen, Dictionaries und Sets schnell durchlaufen zu können und davon abgeleitete Datenstrukturen zu erzeugen. Ebenso ist es möglich, dass eine Funktion die durchlaufenen Werte der Reihe nach zurückgibt. Dieses Kapitel erläutert, wie diese Features eine bessere Leistung erbringen können, weniger Speicher benötigen und besser verständlich eingesetzt werden.

Kapitel 5: Klassen und Schnittstellen

Python ist eine objektorientierte Programmiersprache. Um Aufgaben in Python zu erledigen, ist es oft erforderlich, neue Klassen anzulegen und zu definieren, wie sie mittels ihrer Schnittstellen und der Klassenhierarchie interagieren. Dieses Kapitel erläutert, wie man Klassen zur Modellierung des beabsichtigten Verhaltens durch Objekte nutzt.

Kapitel 6: Metaklassen und Attribute

Metaklassen und dynamische Attribute sind leistungsfähige Python-Merkmale, die es allerdings auch ermöglichen, äußerst merkwürdiges und unerwartetes Verhalten zu implementieren. Dieses Kapitel stellt die üblichen Verwendungsweisen dieser Mechanismen vor, damit Sie dem Prinzip der geringsten Überraschung folgen können.

Kapitel 7: Nebenläufigkeit und parallele Ausführung

In Python können schnell und einfach Programme geschrieben werden, die scheinbar mehrere Aufgaben gleichzeitig erledigen. Python kann außerdem durch Systemaufrufe, Subprozesse oder C-Erweiterungen Code parallel ausführen. Dieses Kapitel führt vor, wie sich diese leicht unterschiedlichen Verfahren am besten einsetzen lassen.

Kapitel 8: Robustheit und Performance

Python bringt eine Reihe integrierter Features und Module mit, die dabei helfen, stabile und verlässliche Programme zu erstellen. Darüber hinaus bietet Python Tools, die es ermöglichen, mit minimalem Aufwand eine höhere Leistung zu erzielen. Dieses Kapitel beschreibt, wie Sie Python nutzen können, um die Stabilität und Effizienz Ihrer Programme zu maximieren.

Kapitel 9: Testen und Debuggen

In welcher Sprache Sie programmieren, spielt keine Rolle; Sie sollten Ihren Code stets testen. Pythons dynamische Features können allerdings das Risiko erhöhen, dass es zu Laufzeitfehlern kommt. Erfreulicherweise vereinfachen sie es jedoch auch, Tests zu schreiben und nicht richtig funktionierende Programme zu untersuchen. Dieses Kapitel befasst sich mit Pythons integrierten Werkzeugen zum Testen und Debuggen.

Kapitel 10: Zusammenarbeit

Bei der gemeinsamen Entwicklung von Python-Programmen muss dem Programmierstil Beachtung geschenkt werden. Selbst wenn Sie der einzige Programmierer sind, müssen Sie doch wissen, wie die von anderen Entwicklern erstellten Module verwendet werden. Dieses Kapitel behandelt die Standardwerkzeuge und bewährte Vorgehensweisen, die es ermöglichen, gemeinsam an Python-Programmen zu arbeiten.

Konventionen dieses Buchs

Die Codebeispiele in diesem Buch sind in einer nicht-proportionalen Schrift gedruckt. Wenn lange Zeilen umbrochen werden müssen, verwende ich zur Markierung das Zeichen »\«. Weggelassene Codeabschnitte sind durch Auslassungszeichen (...) gekennzeichnet. Sie weisen darauf hin, dass weiterer Code vorhanden ist, der im gegebenen Zusammenhang jedoch nicht von Bedeutung ist. Sie müssen sich den vollständigen Beispielcode herunterladen (siehe unten), um die gekürzten Codeschnipsel ausführen zu können.

Ich habe mir hinsichtlich der üblichen Python-Stilregeln eine gewisse »künstlerische Freiheit« genommen, um die Darstellung an die Gegebenheiten eines Buchs anzupassen oder die wichtigsten Teile hervorzuheben. Außerdem habe ich aus Platzgründen die Docstrings entfernt. Das sollten Sie in Ihren eigenen Projekten allerdings nicht tun – folgen Sie besser den üblichen Stilregeln (siehe Punkt 2: Stilregeln gemäß PEP 8) und dokumentieren Sie Ihren Code (siehe Punkt 84: Docstrings für sämtliche Funktionen, Klassen und Module).

Viele Codeabschnitte enthalten auch die bei der Ausführung des Codes erfolgenden Ausgaben. Damit sind die Ausgaben auf der Konsole oder im Terminalfenster gemeint, die erscheinen, wenn das Programm im interaktiven Python-Interpreter ausgeführt wird. Vor den in nicht-proportionaler Schrift gedruckten Ausgaben steht eine Zeile mit den Zeichen >>> (die interaktive Python-Eingabeaufforderung). Dem liegt der Gedanke zugrunde, dass Sie die Beispiele in einer Python-Shell eingeben und die Ausgaben reproduzieren können.

Schließlich gibt es noch weitere Abschnitte in nicht-proportionaler Schrift ohne führende >>>-Zeile. Sie stellen Ausgaben des laufenden Programms dar (nicht des Interpreters). Am Anfang der Beispiele steht oftmals ein Dollarzeichen ($), das darauf hinweist, dass ich Programme von einer Shell wie Bash aus starte. Falls Sie die Befehle unter Windows oder einem anderen System ausführen, müssen Sie die Programmnamen und Argumente womöglich entsprechend anpassen.

Beispielcode herunterladen

Manche Beispiele in diesem Buch sollten besser als komplette Programme ohne die eingestreuten Texte betrachtet werden. Sie können sich den Quellcode auf der englischen Website zum Buch (http://www.effectivepython.com) herunterladen. Sie haben dann auch die Möglichkeit, mit dem Code herumzuexperimentieren und die Funktionsweise besser zu verstehen.

Über den Autor

Brett Slatkin ist bei Google als Führungskraft in der Softwareentwicklung tätig. Er ist leitender Ingenieur und Mitbegründer des Projekts Google Surveys, ist Miterfinder des PubSubHubbub-Protokolls und war an der Entwicklung von Googles erstem Cloud-Computing-Produkt (App Engine) beteiligt. Vor 14 Jahren sammelte er bei der Verwaltung von Googles riesigem Serverbestand erste Erfahrungen mit Python.

Neben der alltäglichen Arbeit spielt er gern Klavier und surft (beides mehr schlecht als recht). Auf seiner privaten Website (http://www.onebigfluke.com) schreibt er über Programmierung und damit verwandte Themen. Er erwarb seinen Bachelor of Science in technischer Informatik an der Columbia-Universität in New York und lebt in San Francisco.

Danksagungen

Ohne die Hilfe, Unterstützung und den Zuspruch vieler Menschen würde es dieses Buch nicht geben.

Dank an Scott Meyers für die Buchreihe Effective Software Development. Als ich 15 Jahre alt war, habe ich erstmals Effective C++ gelesen und es war um mich geschehen. Es besteht kein Zweifel daran, dass Scotts Bücher zu meiner akademischen Laufbahn und meiner ersten Anstellung geführt haben. Ich bin begeistert, dass ich die Möglichkeit hatte, dieses Buch zu schreiben.

Dank an die technischen Korrekturleser für ihre ausführlichen und gründlichen Rückmeldungen zur zweiten Ausgabe dieses Buchs: Andy Chu, Nick Cohron, Andrew Dolan, Asher Mancinelli und Alex Martelli. Dank an meine Kollegen bei Google für die Durchsicht des Buchs. Ohne eure Hilfe wäre dieses Buch nicht vorstellbar.

Dank an alle Beteiligten beim amerikanischen Originalverlag Pearsons, die die zweite Ausgabe dieses Buchs Wirklichkeit werden ließen. Dank an meine Lektorin Debra Williams für unaufhörliche Unterstützung. Dank an das hilfreiche Team: Herausgeber Chris Zahn, Marketingleiter Stephane Nakib, Redakteurin Catherine Wilson, Projektleiterin Lori Lyons und Cover-Designer Chuti Prasertsith.

Dank an alle, die mich bei der ersten Ausgabe dieses Buchs unterstützt haben: Trina MacDonald, Brett Cannon, Tavis Rudd, Mike Taylor, Leah Culver, Adrian Holovaty, Michael Levine, Marzia Niccolai, Ade Oshineye, Katrina Sostek, Tom Cirtin, Chris Zahn, Olivia Basegio, Stephane Nakib, Stephanie Geels, Julie Nahil und Toshiaki Kurokawa. Dank an alle Leser, die Fehler und Raum für Verbesserungen aufzeigten. Dank an alle Übersetzer, die dieses Buch in anderen Sprachen verfügbar gemacht haben.

Dank an die wunderbaren Python-Programmierer, mit denen ich zusammenarbeiten durfte: Anthony Baxter, Brett Cannon, Wesley Chun, Jeremy Hylton, Alex Martelli, Neal Norwitz, Guido van Rossum, Andy Smith, Greg Stein und Ka-Ping Yee. Ich weiß eure Anleitungen und Hinweise wirklich zu schätzen. Die Python-Community ist großartig und ich bin dankbar, zu ihr zu gehören.

Dank an meine Teamkollegen, die seit all den Jahren erdulden müssen, dass ich das schwächste Glied in der Kette bin. Dank an Kevin Gibbs, der mich ermutigte, Risiken einzugehen. Dank an Ken Ashcraft, Ryan Barret und Jon McAlister, die mir zeigten, wie man’s macht. Dank an Brad Fitzpatrick, der alles auf Vordermann gebracht hat. Dank an Paul McDonald, der unser verrücktes Projekt mitbegründet hat. Dank an Jeremy Ginsberg, Jack Hebert, John Skidgel, Evan Martin, Tony Chang, Troy Trimble, Tessa Pupius und Dylan Lorimer, die mir halfen, zu lernen. Dank an Sagnik Nandy und Waleed Ojeil für euer Mentoring.

Dank an meine inspirierenden Programmierlehrer: Ben Chelf, Glenn Cowan, Vince Hugo, Russ Lewin, Jon Stemmle, Derek Thomson und Daniel Wang. Ohne eure Anleitung wäre es mir nie gelungen, unsere Tätigkeit auszuüben, und schon gar nicht, sie anderen zu lehren.

Dank an meine Mutter, die mir das Gefühl gab, etwas Sinnvolles zu tun, und mich ermutigte, Programmierer zu werden. Dank an meinen Bruder, meine Großeltern und den Rest meiner Familie sowie Jugendfreunde, die mir Vorbilder waren, als ich aufwuchs und meine Leidenschaft für die Programmierung entwickelte.

Und zum Schluss Dank an meine Frau Colleen, für ihre Zuneigung, ihre Unterstützung und ihr Lachen auf dem gemeinsamen Lebensweg.

Kapitel 1: Pythons Sicht der Dinge

Die Eigenheiten einer Programmiersprache werden durch die Benutzer festgelegt. Im Laufe der Jahre hat sich in der Python-Community das englische Adjektiv pythonic‌ eingebürgert, das Code beschreibt, der einem bestimmten Programmierstil‌ folgt. Dieser Stil‌ ist nicht reglementiert und spielt für den Compiler keine Rolle. Er hat sich im Laufe der Zeit allmählich durch die im Umgang mit der Sprache gewonnene Erfahrung und die Zusammenarbeit der Community entwickelt. Python-Programmierer befürworten eine klare Ausdrucksweise, ziehen Einfaches Komplexem vor und maximieren die Lesbarkeit. (Geben Sie doch mal importthis im Python-Interpreter ein, um The Zen of Python zu lesen.)‌

Mit anderen Sprachen vertraute Programmierer versuchen oft, Python-Code im Stil von C++ oder Java zu schreiben (oder im Stil derjenigen Sprache, die sie eben am besten kennen). Programmieranfänger gewöhnen sich aber meist schnell an die große Vielfalt von Konzepten, die sich in Python formulieren lassen. Es ist für alle Programmierer gleichermaßen wichtig, die beste Art und Weise zu kennen, mit der die gebräuchlichsten Aufgaben in Python erledigt werden. Davon sind alle Programme betroffen, die Sie jemals schreiben werden.

Punkt 1  Kenntnis der Python-Version‌

Der größte Teil der Beispiele in diesem Buch verwendet die Syntax der Python-Version 3.7, die im Juni 2018 veröffentlicht wurde. Es kommen jedoch auch einige Beispiele vor, in denen die Syntax der Version 3.8 verwendet wird (veröffentlicht im Oktober 2019), um neue Features aufzuzeigen, die schon bald weiter verbreitet sein werden. Dieses Buch befasst sich nicht mit Python 2.

Auf vielen Systemen sind mehrere Versionen der Standard-Laufzeitumgebung CPython‌ vorinstalliert. Dabei ist die standardmäßige Bedeutung des Befehls python auf der Kommandozeile nicht immer ganz klar. Meist ist python ein Alias für python2.7, gelegentlich verweist es aber auch auf ältere Versionen wie python2.6 oder python2.5. Verwenden Sie den Parameter --version, um die genaue Versionsnummer herauszufinden.

$ python --version Python 2.7.10

Python 3 ist für gewöhnlich unter der Bezeichnung python3 verfügbar.

$ python3 --version Python 3.8.0

Sie können die Versionsnummer auch zur Laufzeit feststellen, indem Sie die Werte des integrierten sys-Moduls‌‌ überprüfen.

import sys print(sys.version_info) print(sys.version) >>> sys.version_info(major=3, minor=8, micro=0, releaselevel='final', serial=0) 3.8.0 (default, Oct 21 2019, 12:51:17) [Clang 6.0 (clang-600.0.57))]

Python 3 wird von den Python-Kernentwicklern und der Community gepflegt und kontinuierlich verbessert. Python 3 enthält eine Vielzahl leistungsfähiger neuer Features, die in diesem Buch erläutert werden. Die meisten der gebräuchlichen Open-Source-Bibliotheken sind mit Python 3.1 kompatibel und nutzen die neuen Features. Ich empfehle dringend, für alle weiteren Python-Projekte die Version 3 zu verwenden.

Python2 ist zum 1. Januar 2020 abgekündigt (End-of-Life). Nach diesem Termin wird es keine Fehlerbehebungen, Sicherheitspatches und Rückportierungen von Features mehr geben. Die Verwendung von Python 2 nach diesem Datum geschieht auf eigene Gefahr, weil es keine offizielle Unterstützung mehr gibt. Wenn Sie noch immer auf eine Codebasis in Python 2 angewiesen sind, sollten Sie in Betracht ziehen, hilfreiche Werkzeuge wie 2to3 (wird zusammen mit Python installiert) und six (steht als Paket zur Verfügung; siehe Punkt 82: Module der Python-Community) zu verwenden, um zu Python 3 zu wechseln.

Kompakt

Python 3 ist die aktuellste und am besten unterstützte Version und sollte für neue Projekte verwendet werden.

Vergewissern Sie sich, dass auf der Kommandozeile Ihres Systems auch wirklich die erwartete Python-Version ausgeführt wird.

Verzichten Sie auf Python 2, da es nach dem 1. Januar 2020 nicht mehr unterstützt wird.

Punkt 2  Stilregeln gemäß PEP 8

Das Dokument Python Enhancement Proposal #8 (Vorschläge zur Verbesserung von Python Nr. 8) oder kurz PEP 8‌ gibt die Stilregeln‌ zur Formatierung von Python-Code vor. Es steht Ihnen natürlich frei, Ihren Python-Code so zu formatieren, wie Sie es für richtig halten, sofern Sie die Syntax beachten. Allerdings macht ein einheitlicher Stil den Code verständlicher und besser lesbar. Außerdem erleichtert ein einheitlicher Stil die Zusammenarbeit mit anderen Python-Programmierern der Community an größeren Projekten. Und auch wenn nur Sie selbst den Code jemals lesen werden, vereinfacht ein einheitlicher Stil nachträgliche Änderungen und hilft dabei, viele typische Fehler zu vermeiden.

PEP 8 legt eine Vielzahl von Details fest, die beim Schreiben von klarem Python-Code zu beachten sind. Die Regeln werden während der Weiterentwicklung von Python ständig überarbeitet. Es lohnt sich, das gesamte Dokument zu lesen (https://www.python.org/dev/peps/pep-0008/). Hier sind einige der Regeln, die Sie unbedingt einhalten sollten:

Leerraum (Whitespace):‌‌ In Python ist Leerraum syntaktisch von Bedeutung, daher schenken Python-Programmierer dem Einfluss von Leerraum auf die Klarheit des Codes besondere Beachtung.

Verwenden Sie Leerzeichen zum Einrücken von Text, keine Tabulatoren.

Verwenden Sie für jede Ebene syntaktisch relevanter Einrückungen vier Leerzeichen.‌

Zeilen sollten nicht mehr als 79 Zeichen enthalten.‌

Die Fortsetzung eines langen Ausdrucks in der nächsten Zeile sollte um zusätzliche vier Leerzeichen eingerückt werden.

In Dateien sollten Funktionen und Klassen durch zwei Leerzeilen voneinander getrennt sein.

Innerhalb einer Klasse sollten Methoden durch eine Leerzeile voneinander getrennt sein.

Fügen Sie in einem Dictionary kein Leerzeichen zwischen Schlüssel und Doppelpunkt ein. Fügen Sie genau ein Leerzeichen vor dem dazugehörigen Wert ein, sofern er in dieselbe Zeile passt.‌

Fügen Sie bei Variablenzuweisungen genau ein Leerzeichen vor und nach dem Zuweisungsoperator ein.

Vergewissern Sie sich, dass bei Methodensignaturzuweisungen zwischen Variablennamen und Doppelpunkt kein Leerraum steht. Verwenden Sie ein Leerzeichen vor der Typenbezeichnung.‌

Bezeichner:‌ Gemäß PEP 8 sollten zur Benennung der verschiedenen Teile der Sprache unterschiedliche Stile verwendet werden. Dadurch wird es beim Betrachten des Codes vereinfacht, den Typ eines Bezeichners zu erkennen.

Funktionen, Variablen und Attribute sollten als kleinbuchstaben_mit_unterstrich geschrieben werden.

Geschützte Instanzattribute sollten mit _führendem_unterstrich geschrieben werden.

Private Instanzattribute sollten mit __doppelten_führenden_unterstrichen geschrieben werden.

Klassen und Exceptions sollten als GroßgeschriebeneWörter geschrieben werden.

Modulweite Konstanten sollten IN_GROSSBUCHSTABEN geschrieben werden.

Instanzmethoden einer Klasse sollten als Bezeichnung des ersten Parameters (der auf das Objekt verweist) self verwenden.‌

Klassenmethoden sollten als Bezeichnung des ersten Parameters (der auf die Klasse verweist) cls verwenden.‌

Ausdrücke und Anweisungen: In The Zen of Python heißt‌‌ es: »Es sollte einen – und vorzugsweise nur einen – offensichtlichen Weg geben, ein Problem zu lösen.« PEP 8 schreibt daher für Ausdrücke und Anweisungen Folgendes fest:

Verwenden Sie Negierungen‌ möglichst inmitten eines Ausdrucks (ifaisnotb), statt positive Ausdrücke zu negieren (ifnotaisb).

Testen Sie leere Werte wie [] oder '' nicht, indem Sie deren Länge überprüfen (iflen(eineliste)0). Verwenden Sie stattdessen ifnoteineliste. Leere Werte werden implizit als False bewertet.‌

Gleiches gilt für nicht leere Werte wie [1] oder 'hallo'. Die Anweisung ifeineliste wird für nicht leere Werte implizit als True bewertet.

Verzichten Sie auf einzeilige if-Anweisungen, for- bzw. while-Schleifen und zusammengesetzte except-Anweisungen. Verteilen Sie sie der Übersichtlichkeit halber auf mehrere Zeilen.

Wenn ein Ausdruck nicht in eine Zeile passt, sollten Sie ihn einklammern und Zeilenumbrüche und Einrückungen verwenden, um die Lesbarkeit zu verbessern.

Importe: Gemäß PEP gelten für Importe die folgenden Regeln:

Platzieren Sie import-Anweisungen (auch in der Form fromximporty) immer am Anfang der Datei.

Verwenden Sie beim Import von Modulen stets absolute Pfadbezeichnungen, nicht die zum aktuellen Modul relativen. Wenn Sie beispielsweise das Modul foo des Pakets bar importieren, sollten Sie nicht importfoo, sondern frombarimportfoo verwenden.‌

Verwenden Sie die ausdrückliche Syntax from.importfoo, falls Sie auf relative Pfade angewiesen sind.

Importe sollten in folgender Reihenfolge stattfinden: Zuerst Module der Standardbibliothek, dann Module Dritter, dann die eigenen Module. Die jeweilige Gruppe sollte alphabetisch sortiert sein.‌

Hinweis

Pylint (http://www.pylint.org) ist ein beliebtes Werkzeug zur statischen Analyse von Python-Quelltexten. Pylint‌ erzwingt automatisch die Einhaltung der Stilregeln gemäß PEP 8 und kann viele weitere typische Fehler in Python-Programmen entdecken. Viele IDEs und Editoren bringen Linting-Tools mit oder unterstützen Plug-ins mit vergleichbarer Funktionalität.

Kompakt

Halten Sie sich beim Schreiben von Python-Code an die Stilregeln gemäß PEP 8.

Ein einheitlicher Stil erleichtert die Zusammenarbeit mit anderen Programmierern der Python-Community.

Außerdem erleichtert ein einheitlicher Stil nachträgliche Änderungen des eigenen Codes.