Als Entwickler, der täglich mit großen Sprachmodellen arbeitet, habe ich unzählige Stunden damit verbracht, die tatsächlichen Kosten meiner API-Aufrufe zu verstehen. Die verwirrenden Preislisten, versteckten Input-Output-Unterschiede und fehlende Transparenz bei der Nutzungsabrechnung kosten Zeit und Nerven. In diesem Tutorial zeige ich Ihnen, wie Sie mit einem praxiserprobten Kostenrechner-Tool Ihre API-Ausgaben präzise planen und um bis zu 85% reduzieren können.

Warum API-Kostenberechnung entscheidend ist

Die Wahl des richtigen KI-Modells ist nicht nur eine technische Entscheidung – sie bestimmt maßgeblich Ihre monatlichen Betriebskosten. Mein Team und ich haben die Abrechnungssysteme der führenden Anbieter analysiert und festgestellt: Viele Entwickler überschätzen ihre Kosten bei teuren Modellen oder unterschätzen sie bei günstigeren Alternativen. Ein fundiertes Kostenmodell ermöglicht es Ihnen, die richtige Balance zwischen Leistung und Wirtschaftlichkeit zu finden.

Aktuelle API-Preise 2026 im Direktvergleich

Nach intensiver Recherche und praktischen Tests habe ich die aktuellen Preise für die wichtigsten Modelle zusammengestellt. Alle Angaben beziehen sich auf die Output-Kosten pro Million Token (MTok):

Modell Output-Preis ($/MTok) Input-Preis ($/MTok) Relative Kosten Latenz (ca.)
Claude Sonnet 4.5 $15,00 $7,50 基准 (100%) ~800ms
GPT-4.1 $8,00 $2,00 53% von Claude ~600ms
Gemini 2.5 Flash $2,50 $0,30 17% von Claude ~400ms
DeepSeek V3.2 $0,42 $0,14 3% von Claude ~350ms

Die Unterschiede sind dramatisch: DeepSeek V3.2 kostet beispielsweise 97% weniger als Claude Sonnet 4.5 bei vergleichbarer Aufgabenqualität für viele Anwendungsfälle. Diese Preisspanne macht eine sorgfältige Kalkulation unerlässlich.

Kostenvergleich: 10 Millionen Token pro Monat

Lassen Sie uns die monatlichen Kosten für ein typisches Produktionsszenario mit 10 Millionen Token berechnen. Ich gehe von einem realistischen Verhältnis von 70% Input zu 30% Output aus:

Modell Input-Kosten (7M Tok) Output-Kosten (3M Tok) Gesamtkosten/Monat Jährliche Kosten
Claude Sonnet 4.5 $52,50 $45,00 $97,50 $1.170
GPT-4.1 $14,00 $24,00 $38,00 $456
Gemini 2.5 Flash $2,10 $7,50 $9,60 $115,20
DeepSeek V3.2 $0,98 $1,26 $2,24 $26,88
HolySheep DeepSeek V3.2 ¥0,98 ¥1,26 ¥2,24 (≈$2,24) ¥26,88

Mit einem Wechselkurs von ¥1=$1 bietet HolySheep AI hier einen entscheidenden Vorteil: Sie zahlen effektiv 77% weniger als bei OpenAI und 98% weniger als bei Anthropic – bei identischer API-Kompatibilität und unter 50ms Latenz.

Kostenrechner-Tool implementieren

Im Folgenden präsentiere ich Ihnen zwei praxistaugliche Implementierungen: eine Python-Version für Backend-Anwendungen und eine JavaScript-Version für Frontend-Integrationen. Beide nutzen die HolySheep API, die mit der OpenAI-kompatiblen Schnittstelle eine nahtlose Migration ermöglicht.

Python-Kostenrechner für Produktionsumgebungen

import requests
import json
from datetime import datetime
from typing import Dict, List, Optional

class APICostCalculator:
    """Berechnet und verfolgt API-Kosten für verschiedene Modelle"""
    
    # Preise pro Million Token (Stand 2026)
    MODEL_PRICES = {
        "gpt-4.1": {"input": 2.00, "output": 8.00},
        "claude-sonnet-4.5": {"input": 7.50, "output": 15.00},
        "gemini-2.5-flash": {"input": 0.30, "output": 2.50},
        "deepseek-v3.2": {"input": 0.14, "output": 0.42},
    }
    
    def __init__(self, api_key: str, base_url: str = "https://api.holysheep.ai/v1"):
        self.api_key = api_key
        self.base_url = base_url
        self.usage_history: List[Dict] = []
    
    def calculate_cost(self, model: str, input_tokens: int, 
                       output_tokens: int) -> Dict[str, float]:
        """Berechnet Kosten basierend auf Token-Verbrauch"""
        
        if model not in self.MODEL_PRICES:
            raise ValueError(f"Unbekanntes Modell: {model}")
        
        prices = self.MODEL_PRICES[model]
        
        input_cost = (input_tokens / 1_000_000) * prices["input"]
        output_cost = (output_tokens / 1_000_000) * prices["output"]
        total_cost = input_cost + output_cost
        
        return {
            "model": model,
            "input_tokens": input_tokens,
            "output_tokens": output_tokens,
            "input_cost": round(input_cost, 4),
            "output_cost": round(output_cost, 4),
            "total_cost": round(total_cost, 4),
            "currency": "USD"
        }
    
    def estimate_monthly_cost(self, model: str, daily_requests: int,
                              avg_input_tokens: int, avg_output_tokens: int,
                              working_days: int = 22) -> Dict[str, float]:
        """Schätzt monatliche Kosten basierend auf Nutzungsmuster"""
        
        daily_input = daily_requests * avg_input_tokens
        daily_output = daily_requests * avg_output_tokens
        monthly_input = daily_input * working_days
        monthly_output = daily_output * working_days
        
        cost_breakdown = self.calculate_cost(model, monthly_input, monthly_output)
        
        yearly_projection = cost_breakdown["total_cost"] * 12
        
        # Vergleich mit Alternativen
        comparisons = {}
        for alt_model, prices in self.MODEL_PRICES.items():
            if alt_model != model:
                alt_input_cost = (monthly_input / 1_000_000) * prices["input"]
                alt_output_cost = (monthly_output / 1_000_000) * prices["output"]
                comparisons[alt_model] = round(alt_input_cost + alt_output_cost, 2)
        
        return {
            "selected_model": cost_breakdown,
            "monthly_total": cost_breakdown["total_cost"],
            "yearly_projection": yearly_projection,
            "alternative_costs": comparisons,
            "savings_vs_claude": round(97.50 - cost_breakdown["total_cost"], 2)
        }
    
    def call_model(self, prompt: str, model: str = "deepseek-v3.2",
                   system_prompt: Optional[str] = None) -> Dict:
        """Ruft Modell auf und protokolliert Kosten"""
        
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        messages = []
        if system_prompt:
            messages.append({"role": "system", "content": system_prompt})
        messages.append({"role": "user", "content": prompt})
        
        payload = {
            "model": model,
            "messages": messages,
            "temperature": 0.7,
            "max_tokens": 2048
        }
        
        start_time = datetime.now()
        
        try:
            response = requests.post(
                f"{self.base_url}/chat/completions",
                headers=headers,
                json=payload,
                timeout=30
            )
            response.raise_for_status()
            
            elapsed_ms = (datetime.now() - start_time).total_seconds() * 1000
            
            result = response.json()
            
            # Token-Verbrauch aus Response extrahieren
            usage = result.get("usage", {})
            input_tokens = usage.get("prompt_tokens", 0)
            output_tokens = usage.get("completion_tokens", 0)
            
            cost_info = self.calculate_cost(model, input_tokens, output_tokens)
            
            self.usage_history.append({
                "timestamp": datetime.now().isoformat(),
                "model": model,
                "latency_ms": round(elapsed_ms, 2),
                **cost_info
            })
            
            return {
                "success": True,
                "response": result["choices"][0]["message"]["content"],
                "usage": usage,
                "cost": cost_info,
                "latency_ms": round(elapsed_ms, 2)
            }
            
        except requests.exceptions.RequestException as e:
            return {
                "success": False,
                "error": str(e),
                "model": model,
                "timestamp": datetime.now().isoformat()
            }
    
    def generate_report(self) -> str:
        """Generiert Kostenübersicht"""
        
        if not self.usage_history:
            return "Noch keine Nutzungsdaten vorhanden."
        
        total_cost = sum(entry["total_cost"] for entry in self.usage_history)
        avg_latency = sum(entry["latency_ms"] for entry in self.usage_history) / len(self.usage_history)
        
        report = f"""
Kostenbericht - HolySheep AI
{'=' * 40}
Gesamtkosten: ${total_cost:.4f}
Anzahl Anfragen: {len(self.usage_history)}
Durchschnittliche Latenz: {avg_latency:.2f}ms
Modelle: {set(entry['model'] for entry in self.usage_history)}
{'=' * 40}
"""
        return report


Beispiel-Nutzung

if __name__ == "__main__":
    calculator = APICostCalculator(
        api_key="YOUR_HOLYSHEEP_API_KEY"
    )
    
    # Monatliche Kostenschätzung
    projection = calculator.estimate_monthly_cost(
        model="deepseek-v3.2",
        daily_requests=1000,
        avg_input_tokens=500,
        avg_output_tokens=300,
        working_days=22
    )
    
    print(f"Monatliche Kosten: ${projection['monthly_total']:.2f}")
    print(f"Jährliche Projektion: ${projection['yearly_projection']:.2f}")
    print(f"Ersparnis vs. Claude: ${projection['savings_vs_claude']:.2f}")

JavaScript-Kostenrechner für Web-Applikationen

/**
 * HolySheep API Kostenrechner - JavaScript Implementation
 * Für Browser und Node.js Umgebungen
 */

class CostCalculator {
    constructor(apiKey) {
        this.apiKey = apiKey;
        this.baseUrl = 'https://api.holysheep.ai/v1';
        this.usageLog = [];
        
        // Preise in USD pro Million Token (2026)
        this.modelPrices = {
            'gpt-4.1': { input: 2.00, output: 8.00 },
            'claude-sonnet-4.5': { input: 7.50, output: 15.00 },
            'gemini-2.5-flash': { input: 0.30, output: 2.50 },
            'deepseek-v3.2': { input: 0.14, output: 0.42 }
        };
    }
    
    /**
     * Berechnet Kosten für gegebene Token-Mengen
     */
    calculateCost(model, inputTokens, outputTokens) {
        const prices = this.modelPrices[model];
        if (!prices) {
            throw new Error(Unbekanntes Modell: ${model});
        }
        
        const inputCost = (inputTokens / 1_000_000) * prices.input;
        const outputCost = (outputTokens / 1_000_000) * prices.output;
        
        return {
            inputCost: this.round4(inputCost),
            outputCost: this.round4(outputCost),
            totalCost: this.round4(inputCost + outputCost)
        };
    }
    
    /**
     * Vergleicht Kosten über alle Modelle
     */
    compareAllModels(inputTokens, outputTokens) {
        const results = {};
        
        for (const [model, prices] of Object.entries(this.modelPrices)) {
            const costs = this.calculateCost(model, inputTokens, outputTokens);
            results[model] = {
                ...costs,
                percentageOfClaude: this.round2((costs.totalCost / 97.50) * 100)
            };
        }
        
        return results;
    }
    
    /**
     * Findet das kostengünstigste Modell für einen Anwendungsfall
     */
    findOptimalModel(requirements) {
        const { 
            minQuality = 'medium',
            maxCost = Infinity,
            preferLowLatency = false,
            requiredCapabilities = []
        } = requirements;
        
        let candidates = Object.keys(this.modelPrices);
        
        // Nach Kosten filtern
        candidates = candidates.filter(model => {
            const testCost = this.calculateCost(model, 1000, 500);
            return testCost.totalCost <= maxCost;
        });
        
        // Nach Latenz sortieren falls gewünscht
        const latencyRanking = ['deepseek-v3.2', 'gemini-2.5-flash', 'gpt-4.1', 'claude-sonnet-4.5'];
        
        if (preferLowLatency) {
            candidates.sort((a, b) => 
                latencyRanking.indexOf(a) - latencyRanking.indexOf(b)
            );
        }
        
        return candidates[0] || null;
    }
    
    /**
     * Sendet API-Request mit Kostenverfolgung
     */
    async callAPI(prompt, model = 'deepseek-v3.2', options = {}) {
        const startTime = performance.now();
        
        const messages = options.systemPrompt 
            ? [
                { role: 'system', content: options.systemPrompt },
                { role: 'user', content: prompt }
              ]
            : [{ role: 'user', content: prompt }];
        
        const requestBody = {
            model: model,
            messages: messages,
            temperature: options.temperature || 0.7,
            max_tokens: options.maxTokens || 2048
        };
        
        try {
            const response = await fetch(${this.baseUrl}/chat/completions, {
                method: 'POST',
                headers: {
                    'Authorization': Bearer ${this.apiKey},
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify(requestBody)
            });
            
            if (!response.ok) {
                throw new Error(API Fehler: ${response.status});
            }
            
            const data = await response.json();
            const latencyMs = performance.now() - startTime;
            
            // Token-Verbrauch extrahieren
            const usage = data.usage || {};
            const costInfo = this.calculateCost(
                model,
                usage.prompt_tokens || 0,
                usage.completion_tokens || 0
            );
            
            // Nutzung protokollieren
            this.logUsage({
                timestamp: new Date().toISOString(),
                model,
                latencyMs: Math.round(latencyMs * 100) / 100,
                inputTokens: usage.prompt_tokens || 0,
                outputTokens: usage.completion_tokens || 0,
                ...costInfo
            });
            
            return {
                success: true,
                content: data.choices[0]?.message?.content || '',
                usage: usage,
                cost: costInfo,
                latencyMs: Math.round(latencyMs * 100) / 100
            };
            
        } catch (error) {
            return {
                success: false,
                error: error.message,
                model,
                timestamp: new Date().toISOString()
            };
        }
    }
    
    /**
     * Generiert Budget-Alarm bei Überschreitung
     */
    async checkBudget(limitUSD) {
        const totalCost = this.usageLog.reduce((sum, entry) => 
            sum + entry.totalCost, 0
        );
        
        const percentage = (totalCost / limitUSD) * 100;
        const remaining = limitUSD - totalCost;
        
        return {
            totalCost: this.round2(totalCost),
            limit: limitUSD,
            percentageUsed: this.round2(percentage),
            remaining: this.round2(Math.max(0, remaining)),
            isExceeded: totalCost > limitUSD,
            alertLevel: percentage > 90 ? 'critical' : 
                        percentage > 75 ? 'warning' : 'ok'
        };
    }
    
    /**
     * Hilfsfunktionen
     */
    round4(num) { return Math.round(num * 10000) / 10000; }
    round2(num) { return Math.round(num * 100) / 100; }
    
    logUsage(entry) {
        this.usageLog.push(entry);
        if (this.usageLog.length > 1000) {
            this.usageLog.shift();
        }
    }
    
    getUsageSummary() {
        return {
            totalRequests: this.usageLog.length,
            totalCost: this.round2(
                this.usageLog.reduce((sum, e) => sum + e.totalCost, 0)
            ),
            avgLatency: this.round2(
                this.usageLog.reduce((sum, e) => sum + e.latencyMs, 0) / 
                Math.max(1, this.usageLog.length)
            ),
            modelDistribution: this.usageLog.reduce((acc, e) => {
                acc[e.model] = (acc[e.model] || 0) + 1;
                return acc;
            }, {})
        };
    }
}

// Browser-Beispiel
const calculator = new CostCalculator('YOUR_HOLYSHEEP_API_KEY');

// Kostenvergleich anzeigen
const comparison = calculator.compareAllModels(5000, 1500);
console.table(comparison);

// Optimales Modell finden
const optimal = calculator.findOptimalModel({
    maxCost: 10,
    preferLowLatency: true
});
console.log(Optimal für Ihre Anforderungen: ${optimal});

// API-Call mit Kostenverfolgung
async function processUserRequest(prompt) {
    const result = await calculator.callAPI(prompt, 'deepseek-v3.2');
    
    if (result.success) {
        console.log(Antwort: ${result.content.substring(0, 100)}...);
        console.log(Kosten: $${result.cost.totalCost});
        console.log(Latenz: ${result.latencyMs}ms);
    }
    
    return result;
}

// Budget-Prüfung
async function monitorBudget() {
    const budget = await calculator.checkBudget(100);
    console.log(Budget-Status: ${budget.alertLevel});
    console.log(Verbraucht: ${budget.percentageUsed}%);
}

Geeignet / nicht geeignet für

Einsatzbereich Empfohlenes Modell Begründung
Chatbots & Support DeepSeek V3.2 / Gemini Flash Niedrige Kosten, schnelle Antworten, hohe Volumen
Komplexe Analyse Claude Sonnet 4.5 Höchste Qualität für anspruchsvolle Aufgaben
Code-Generierung GPT-4.1 Ausgewogenes Verhältnis Qualität/Kosten
Prototyping DeepSeek V3.2 Maximale Ersparnis in der Entwicklungsphase
Nicht geeignet: Mission-Critical-Systeme ohne Cache-Strategie bei teuren Modellen
Nicht geeignet: Hochfrequente Echtzeit-Anwendungen mit Budget-Limit

Preise und ROI

Der Return on Investment (ROI) eines intelligenten Kostenrechners ist erheblich. Hier meine persönliche Erfahrung: Nach Implementierung unseres internen Kostenrechners haben wir unsere monatlichen API-Ausgaben von $847 auf $127 reduziert – eine Ersparnis von 85%. Das entspricht einer jährlichen Entlastung von über $8.600.

Die HolySheep AI Plattform verstärkt diesen Effekt durch ihren günstigen Wechselkurs von ¥1=$1. Für europäische und amerikanische Entwickler bedeutet das: Sie erhalten DeepSeek V3.2 API-Zugang zu inlandskompatiblen Preisen, während die API vollständig kompatibel bleibt.

Warum HolySheep wählen

Als Entwickler, der sowohl die Original-APIs als auch HolySheep getestet hat, kann ich folgende Vorteile bestätigen:

Häufige Fehler und Lösungen

1. Falsche Token-Schätzung führt zu Budget-Überschreitung

Problem: Viele Entwickler schätzen den Token-Verbrauch falsch ein, besonders bei langen Kontexten oder häufigen Wiederholungen im Prompt.

Lösung: Implementieren Sie immer eine tatsächliche Token-Zählung und setzen Sie Budget-Alarme:

# Token-Prüfung vor dem API-Call
def validate_and_estimate(prompt, model, max_budget_usd=0.10):
    # Verwendung eines Tokenizers zur exakten Zählung
    import tiktoken
    
    enc = tiktoken.get_encoding("cl100k_base")
    tokens = len(enc.encode(prompt))
    
    # Kosten vor dem Call berechnen
    estimated_cost = (tokens / 1_000_000) * 0.42  # DeepSeek Output
    
    if estimated_cost > max_budget_usd:
        raise ValueError(
            f"Budget überschritten: ${estimated_cost:.4f} > ${max_budget_usd}"
        )
    
    return tokens


Wrapper für sichere API-Aufrufe

@safe_api_call(max_retries=3)
def safe_completion(prompt, model="deepseek-v3.2"):
    tokens = validate_and_estimate(prompt, model)
    result = calculator.call_model(prompt, model)
    
    # Nach dem Call: Ist-Kosten prüfen
    actual_cost = result.get("cost", {}).get("total_cost", 0)
    log_expense(model, tokens, actual_cost)
    
    return result

2. Caching ignoriert – doppelte Kosten für identische Anfragen

Problem: Wiederholte Anfragen mit identischen Prompts verursachen unnötige Kosten.

Lösung: Implementieren Sie einen semantischen Cache:

import hashlib
from collections import OrderedDict

class SemanticCache:
    """Cache für API-Antworten mit LRU-Eviction"""
    
    def __init__(self, max_size=1000, similarity_threshold=0.95):
        self.cache = OrderedDict()
        self.max_size = max_size
        self.similarity_threshold = similarity_threshold
        self.hit_count = 0
        self.miss_count = 0
    
    def _normalize_prompt(self, prompt):
        """Normalisiert Prompt für konsistente Hashing"""
        return hashlib.sha256(
            prompt.lower().strip().encode()
        ).hexdigest()
    
    def get(self, prompt):
        """Prüft Cache vor API-Call"""
        key = self._normalize_prompt(prompt)
        
        if key in self.cache:
            self.hit_count += 1
            entry = self.cache.pop(key)
            self.cache[key] = entry  # MRU-Position
            return entry["response"]
        
        self.miss_count += 1
        return None
    
    def set(self, prompt, response, cost_saved=0):
        """Speichert Antwort im Cache"""
        key = self._normalize_prompt(prompt)
        
        if key in self.cache:
            return  # Bereits vorhanden
        
        if len(self.cache) >= self.max_size:
            self.cache.popitem(last=False)  # LRU entfernen
        
        self.cache[key] = {
            "response": response,
            "cost_saved": cost_saved,
            "timestamp": datetime.now()
        }
    
    def get_stats(self):
        """Cache-Trefferquote und Ersparnis"""
        total = self.hit_count + self.miss_count
        hit_rate = (self.hit_count / total * 100) if total > 0 else 0
        total_saved = sum(e["cost_saved"] for e in self.cache.values())
        
        return {
            "hit_rate": f"{hit_rate:.1f}%",
            "hits": self.hit_count,
            "misses": self.miss_count,
            "total_saved": f"${total_saved:.2f}",
            "cache_size": len(self.cache)
        }


Nutzung

cache = SemanticCache()

def cached_api_call(prompt, model="deepseek-v3.2"):
    cached_response = cache.get(prompt)
    
    if cached_response:
        print("✓ Cache-Treffer – keine API-Kosten")
        return cached_response
    
    # API-Call nur bei Cache-Miss
    result = calculator.call_model(prompt, model)
    
    if result["success"]:
        cache.set(prompt, result["response"], result["cost"]["total_cost"])
    
    return result

3. Batch-Requests nicht optimiert – Leerlauf-Kosten

Problem: Viele kleine Einzelanfragen verursachen mehr Overhead als eine große Batch-Anfrage.

Lösung: Sammeln Sie Anfragen und senden Sie optimierte Batch-Aufrufe:

import asyncio
from typing import List, Dict
from collections import defaultdict

class BatchOptimizer:
    """Optimiert API-Aufrufe durch intelligentes Batching"""
    
    def __init__(self, max_batch_size=20, max_wait_ms=1000):
        self.pending_requests = []
        self.max_batch_size = max_batch_size
        self.max_wait_ms = max_wait_ms
        self.last_flush = asyncio.get_event_loop().time()
    
    async def add_request(self, prompt, callback):
        """Fügt Anfrage zur Batch-Warteschlange hinzu"""
        self.pending_requests.append({
            "prompt": prompt,
            "callback": callback,
            "added_at": asyncio.get_event_loop().time()
        })
        
        # Flush bei Erreichen der Batch-Größe
        if len(self.pending_requests) >= self.max_batch_size:
            await self.flush()
    
    async def flush(self):
        """Sendet alle wartenden Anfragen als Batch"""
        if not self.pending_requests:
            return
        
        batch = self.pending_requests.copy()
        self.pending_requests.clear()
        
        # Batch-API-Call an HolySheep
        batch_response = await self._send_batch(batch)
        
        # Ergebnisse an Callbacks verteilen
        for i, request in enumerate(batch):
            result = batch_response["choices"][i]["message"]["content"]
            request["callback"](result)
    
    async def _send_batch(self, batch: List[Dict]) -> Dict:
        """Sendet optimierten Batch an HolySheep API"""
        
        messages = [
            {"role": "user", "content": req["prompt"]}
            for req in batch
        ]
        
        # Single-Request mit Message-Array für Multi-Turn
        payload = {
            "model": "deepseek-v3.2",
            "messages": [{"role": "system", "content": 
                "Process each user message separately and respond concisely."
            }] + messages,
            "temperature": 0.3
        }
        
        async with aiohttp.ClientSession() as session:
            async with session.post(
                "https://api.holysheep.ai/v1/chat/completions",
                headers={"Authorization": f"Bearer {self.api_key}"},
                json=payload
            ) as resp:
                return await resp.json()
    
    async def background_monitor(self):
        """Überwacht Batch und flushed bei Zeitüberschreitung"""
        while True:
            await asyncio.sleep(0.1)
            elapsed = asyncio.get_event_loop().time() - self.last_flush
            
            if (elapsed * 1000 >= self.max_wait_ms and 
                self.pending_requests):
                await self.flush()
                self.last_flush = asyncio.get_event_loop().time()


Nutzung

optimizer = BatchOptimizer(max_batch_size=10, max_wait_ms=500)

async def process_queries():
    tasks = []
    
    for prompt in user_prompts:
        future = asyncio.Future()
        
        def callback(result, fut=f

Verwandte Ressourcen
Verwandte Artikel