Code-Bibliothek — Capypad · Code Zeile für Zeile lesen

Python · ExperteSnippet

Asynchrone Iteration mit Kontext-Managern

Dies demonstriert die Kombination von asynchronen Kontext-Managern (__aenter__/__aexit__) mit asynchronen Iteratoren (__aiter__). Es ermöglicht ein sicheres Ressourcenmanagement in nebenläufigen Umgebungen, während Datenströme asynchron mit 'async with' und 'async for' verarbeitet werden.

snippet.py

python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

import asyncio
 
class AsyncBuffer:
    async def __aenter__(self):
        print('Opening...')
        return self
 
    async def __aexit__(self, *args):
        print('Closing...')
 
    async def __aiter__(self):
        for i in range(3):
            await asyncio.sleep(0.1)
            yield i
 
async def main():
    async with AsyncBuffer() as buf:
        async for item in buf:
            print(item)

Async & ConcurrencyKontrollstrukturen

Python · ExperteSnippet

Metaklassen zur Erzwingung von Singletons

Metaklassen sind die 'Klassen von Klassen'. Durch das Überschreiben der __call__-Methode einer Metaklasse kann man den Instanziierungsprozess ihrer Klassen steuern. In diesem Beispiel stellt die Metaklasse sicher, dass nur eine einzige Instanz der Database-Klasse existiert, indem sie diese in einem privaten Dictionary speichert und wiederverwendet.

snippet.py

python

1

2

3

4

5

6

7

8

9

class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]
 
class Database(metaclass=Singleton):
    pass

OOPDesign Patterns

Python · ExperteSnippet

Zero-Copy-Slicing mit memoryview

Das memoryview-Objekt ermöglicht es Python-Code, auf die internen Daten eines Objekts zuzugreifen, das das Buffer-Protokoll unterstützt (wie bytearray), ohne diese zu kopieren. Das Slicing einer memoryview gibt eine neue memoryview zurück, die denselben zugrunde liegenden Puffer nutzt, was eine extrem effiziente Speicherbearbeitung bei großen Datensätzen ermöglicht.

snippet.py

python

1

2

3

4

5

6

data = bytearray(b'X' * 100_000_000)
mv = memoryview(data)
chunk = mv[1000:2000]
# No data is copied here
chunk[0] = ord('Y')
print(data[1000]) # Outputs: 89 ('Y')

PerformanceDatentypen

Python · ExperteSnippet

Erweitertes Pattern Matching mit Guards

Structural Pattern Matching (eingeführt in Python 3.10) ermöglicht die ausdrucksstarke Dekonstruktion von Daten. Die Verwendung von 'Guards' (die 'if'-Klausel nach einem Muster) erlaubt das Hinzufügen bedingter Logik direkt in den Matching-Prozess, was eine präzisere Kontrolle über komplexe Dictionary- oder Objektstrukturen ermöglicht.

snippet.py

python

1

2

3

4

5

6

7

8

def process_data(payload):
    match payload:
        case {"type": "user", "id": int(uid)} if uid > 1000:
            return f"Admin logic for {uid}"
        case {"type": "user", "id": int(uid)}:
            return f"User logic for {uid}"
        case _:
            raise ValueError("Unknown format")

SyntaxKontrollstrukturen

Python · ExperteSnippet

Deskriptor-Protokoll für Typsicherheit

Deskriptoren sind Klassen, die eine der Methoden __get__, __set__ oder __delete__ definieren. Sie werden verwendet, um benutzerdefinierte Logik für den Attributzugriff zu implementieren. In diesem Snippet erfasst __set_name__ automatisch den Attributnamen und __set__ erzwingt, dass der dem 'age' zugewiesene Wert immer eine Ganzzahl ist.

snippet.py

python

1

2

3

4

5

6

7

8

9

10

11

class IntegerField:
    def __set_name__(self, owner, name):
        self.name = name
 
    def __set__(self, instance, value):
        if not isinstance(value, int):
            raise ValueError(f'{self.name} must be an integer')
        instance.__dict__[self.name] = value
 
class User:
    age = IntegerField()

OOPBest Practices

Python · ExperteSnippet

Strukturelle Untertypisierung mit Protokollen

Protokolle (PEP 544) ermöglichen statisches Duck Typing. Im Gegensatz zur Standardvererbung wird eine Klasse als Untertyp eines Protokolls betrachtet, wenn sie lediglich die erforderlichen Methoden implementiert, ohne explizit von der Protokollklasse erben zu müssen.

snippet.py

python

1

2

3

4

5

6

7

8

9

10

11

12

13

from typing import Protocol, runtime_checkable
 
@runtime_checkable
class Drawable(Protocol):
    def draw(self) -> str: ...
 
class Circle:
    def draw(self) -> str: return "Circle drawn"
 
def render(obj: Drawable):
    if isinstance(obj, Drawable):
        return obj.draw()
    return "Not drawable"

OOPBest Practices

Python · ExperteSnippet

Verwaltete Nebenläufigkeit mit TaskGroups

Eingeführt in Python 3.11, bieten TaskGroups eine moderne API für nebenläufige Aufgaben. Wenn eine Aufgabe fehlschlägt, werden die anderen automatisch abgebrochen, was ein 'Alles-oder-Nichts'-Ausführungsmuster mit sauberer Ausnahmebehandlung über ExceptionGroups gewährleistet.

snippet.py

python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

import asyncio
 
async def fail_task():
    await asyncio.sleep(0.1)
    raise ValueError("Atomic failure")
 
async def main():
    try:
        async with asyncio.TaskGroup() as tg:
            tg.create_task(asyncio.sleep(1))
            tg.create_task(fail_task())
    except* ValueError as eg:
        for e in eg.exceptions:
            print(f"Caught: {e}")

Async & ConcurrencyFehlerbehandlung

Python · ExperteSnippet

Speichereffizientes Caching mit WeakRef

Ein WeakValueDictionary hält 'schwache' Referenzen auf seine Werte. Wenn ein Objekt nirgendwo anders im Programm mehr referenziert wird, kann der Garbage Collector es löschen, selbst wenn es noch ein Wert im Dictionary ist, was automatisch Speicherlecks in Caches verhindert.

snippet.py

python

1

2

3

4

5

6

7

8

9

10

11

12

import weakref
 
class DataBlob:
    def __init__(self, data): self.data = data
 
cache = weakref.WeakValueDictionary()
blob = DataBlob("heavy-data")
cache["key"] = blob
 
print("Cached:", "key" in cache)
del blob
print("After del:", "key" in cache)

PerformanceDesign Patterns