O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Effektiv Python programmieren - 59 Wege für bessere Python-Programme

Book Description

  • Bewährte Verfahren, Tipps und Tricks für stabilen und schnellen Code
  • Grundlegende Aufgaben besser und effektiver lösen
  • Detaillierte Erklärungen und zahlreiche Beispiele

Der Einstieg in die Python-Programmierung ist einfach, daher ist die Sprache so beliebt. Pythons einzigartige Vorteile, Vorzüge und Ausdrucksstärke sind allerdings nicht immer ganz einfach zu verstehen und es gibt verborgene Fallstricke, über die man leicht stolpern kann.

»Effektiv Python programmieren« wird Ihnen dabei helfen, eine wirklich Python-typische Herangehensweise an die Programmierung zu meistern und macht sich dabei die Möglichkeiten zunutze, in Python außerordentlich stabilen und schnellen Code zu schreiben. Brett Slatkin stellt im kompakten, an Fallbeispielen orientierten Stil von Scott Meyers populären Buch »Effektiv C++ programmieren« 59 bewährte Verfahren, Tipps und Tricks vor, die er anhand realistischer Codebeispiele erläutert.

Slatkin kann auf jahrelange Erfahrung mit der Python-Infrastruktur bei Google zurückblicken und zeigt wenig bekannte Eigenarten und Sprachelemente, die großen Einfluss auf das Verhalten des Codes und die Performance haben können. Sie erfahren, wie grundlegende Aufgaben am besten erledigt werden, damit Sie leichter verständlichen, wartungsfreundlicheren und einfach zu verbessernden Code schreiben können.

Aus dem Inhalt:
  • Gängige Richtlinien für alle wichtigen Gebiete der Entwicklung in Python 2.x und 3.x mit detaillierten Erklärungen und Beispielen
  • Gebräuchliche Vorgehensweisen beim Schreiben von Funktionen, die deren Absicht verdeutlichen, die Wiederverwendung von Code begünstigen und dabei helfen, Fehler zu vermeiden
  • Verhaltensweisen mithilfe von Klassen und Objekten ausdrücken
  • Stolpersteine beim Umgang mit Metaklassen und dynamischen Attributen umgehen
  • Effizientere Ansätze für Nebenläufigkeit und parallele Ausführung
  • Tipps und Tricks zur Nutzung Pythons integrierter Module
  • Tools und bewährte Verfahren bei der Zusammenarbeit mit anderen Entwicklern
  • Lösungen für das Debuggen, Testen und Optimieren zur Verbesserung der Qualität und der Performance

Table of Contents

  1. Impressum
  2. Vorwort
  3. Über den Autor
  4. Danksagungen
  5. Kapitel 1: Pythons Sicht der Dinge
    1. 1.1 Punkt 1: Kenntnis der Python-Version​
    2. 1.2 Punkt 2: Stilregeln gemäß PEP 8
    3. 1.3 Punkt 3: Unterschiede zwischen bytes, str und unicode
    4. 1.4 Punkt 4: Hilfsfunktionen statt komplizierter Ausdrücke​​
    5. 1.5 Punkt 5: Zugriff auf Listen​
    6. 1.6 Punkt 6: Verzicht auf Abstand und Start-/End-Index​​
    7. 1.7 Punkt 7: Listen-Abstraktionen statt map und filter
    8. 1.8 Punkt 8: Nicht mehr als zwei Ausdrücke in Listen-Abstraktionen
    9. 1.9 Punkt 9: Generator-Ausdrücke in Listen-Abstraktionen
    10. 1.10 Punkt 10: enumerate statt range
    11. 1.11 Punkt 11: Gleichzeitige Verarbeitung von Iteratoren mit zip
    12. 1.12 Punkt 12: Verzicht auf else-Blöcke nach for- und while-Schleifen
    13. 1.13 Punkt 13: Alle Blöcke einer try/except/else/finally-Anweisung nutzen
  6. Kapitel 2: Funktionen
    1. 2.1 Punkt 14: Exceptions statt Rückgabe von None
    2. 2.2 Punkt 15: Closures und der Gültigkeitsbereich von Variablen​
    3. 2.3 Punkt 16: Generatoren​ statt Rückgabe von Listen
    4. 2.4 Punkt 17: Vorsicht beim Iterieren über Argumente​
    5. 2.5 Punkt 18: Klare Struktur dank variabler Argumente​
    6. 2.6 Punkt 19: Optionale Funktionalität durch Schlüsselwort-Argumente​
    7. 2.7 Punkt 20: Dynamische Standardwerte von Argumenten mittels None und Docstrings
    8. 2.8 Punkt 21: Eindeutigkeit durch Schlüsselwort-Argumente
  7. Kapitel 3: Klassen und Vererbung
    1. 3.1 Punkt 22: Hilfsklassen statt Dictionaries und Tupel
    2. 3.2 Punkt 23: Funktionen statt Klassen bei einfachen Schnittstellen
    3. 3.3 Punkt 24: Polymorphismus und generische Erzeugung von Objekten
    4. 3.4 Punkt 25: Initialisierung von Basisklassen durch super
    5. 3.5 Punkt 26: Mehrfache Vererbung nur für Mix-in-Hilfsklassen
    6. 3.6 Punkt 27: Öffentliche statt private Attribute
    7. 3.7 Punkt 28: Benutzerdefinierte Container-Klassen durch Erben von collections.abc
  8. Kapitel 4: Metaklassen und Attribute
    1. 4.1 Punkt 29: Einfache Attribute statt Getter- und Setter-Methoden
    2. 4.2 Punkt 30: @property statt Refactoring von Attributen
    3. 4.3 Punkt 31: Deskriptoren für wiederverwendbare @property-Methoden verwenden
    4. 4.4 Punkt 32: Verzögerte Zuweisung zu Attributen mittels __getattr__, __getattribute__ und __setattr__
    5. 4.5 Punkt 33: Unterklassen mit Metaklassen überprüfen
    6. 4.6 Punkt 34: Klassen mittels Metaklassen registrieren
    7. 4.7 Punkt 35: Zugriff auf Klassenattribute mit Metaklassen​
  9. Kapitel 5: Nebenläufigkeit und parallele Ausführung
    1. 5.1 Punkt 36: Verwaltung von Kindprozessen mittels subprocess
    2. 5.2 Punkt 37: Threads, blockierende Ein-/Ausgabevorgänge und parallele Ausführung
    3. 5.3 Punkt 38: Wettlaufsituationen in Threads mit Lock verhindern
    4. 5.4 Punkt 39: Threads koordinieren mit Queue
    5. 5.5 Punkt 40: Parallele Ausführung mehrerer Funktionen mit Coroutinen
    6. 5.6 Punkt 41: Echte parallele Ausführung mit concurrent.futures
  10. Kapitel 6: Standardmodule
    1. 6.1 Punkt 42: Funktions-Decorators mit functools.wraps definieren
    2. 6.2 Punkt 43: contextlib und with-Anweisung statt try/finally-Konstrukt
    3. 6.3 Punkt 44: Verlässliches pickle durch copyreg
    4. 6.4 Punkt 45: Für örtliche Zeitangaben datetime statt time verwenden
    5. 6.5 Punkt 46: Verwendung von Algorithmen und Datenstrukturen der Standardbibliothek​​
    6. 6.6 Punkt 47: Falls Genauigkeit an erster Stelle steht, decimal verwenden
    7. 6.7 Punkt 48: Module der Python-Community
  11. Kapitel 7: Zusammenarbeit
    1. 7.1 Punkt 49: Docstrings für sämtliche Funktionen, Klassen und Module​
    2. 7.2 Punkt 50: Pakete zur Organisation von Modulen und zur Bereitstellung stabiler APIs verwenden
    3. 7.3 Punkt 51: Einrichten einer Root-Exception zur Abschottung von Aufrufern und APIs
    4. 7.4 Punkt 52: Zirkuläre Abhängigkeiten auflösen​
    5. 7.5 Punkt 53: Virtuelle Umgebungen zum Testen von Abhängigkeiten
  12. Kapitel 8: Veröffentlichung
    1. 8.1 Punkt 54: Modulbezogener (Module-scoped) Code zur Konfiguration der Deployment-Umgebung
    2. 8.2 Punkt 55: Debuggen mit repr-Strings
    3. 8.3 Punkt 56: Überprüfung mit unittest
    4. 8.4 Punkt 57: Interaktives Debuggen mit pdb
    5. 8.5 Punkt 58: Vor der Optimierung Messungen vornehmen​
    6. 8.6 Punkt 59: Nutzung des Arbeitsspeichers und Speicherlecks mit tracemalloc untersuchen