Effektiv Python programmieren, 2. A.

Table of contents

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