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

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