OpenAI API Python Tutorial

Dieses Tutorial behandelt die Nutzung der OpenAI API mit Python – von der Installation bis zu fortgeschrittenen Anwendungsfällen. Alle Beispiele funktionieren mit APIMaster.ai – ändern Sie einfach den api_key und die base_url.

Installation

pip install openai

Erfordert Python 3.8+. Das Paket openai ist das offizielle Python SDK von OpenAI (Version 1.x).

Ersteinrichtung

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_APIMASTER_KEY",
    base_url="https://apimaster.ai/v1",
)

Oder verwenden Sie Umgebungsvariablen (empfohlen):

export OPENAI_API_KEY="YOUR_APIMASTER_KEY"
export OPENAI_BASE_URL="https://apimaster.ai/v1"

from openai import OpenAI
client = OpenAI()  # liest Umgebungsvariablen automatisch

Grundlegende Chat-Antworten

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "system", "content": "You are a Python expert."},
        {"role": "user", "content": "What is a generator in Python?"},
    ],
)

print(response.choices[0].message.content)
print(f"Tokens used: {response.usage.total_tokens}")

Streaming-Antworten

stream = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{"role": "user", "content": "Write a binary search in Python."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)
print()

Mehrfachgespräche

messages = [
    {"role": "system", "content": "You are a helpful coding assistant."}
]

def send(user_text):
    messages.append({"role": "user", "content": user_text})
    resp = client.chat.completions.create(model="gpt-5.4", messages=messages)
    reply = resp.choices[0].message.content
    messages.append({"role": "assistant", "content": reply})
    return reply

print(send("Explain list comprehensions."))
print(send("Give me a harder example."))

Strukturierte Ausgabe (JSON-Modus)

Erzwingen Sie, dass das Modell gültiges JSON zurückgibt:

import json

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {
            "role": "user",
            "content": "Extract the name, email, and company from: 'Contact Jane Smith (jane@acme.com) at Acme Corp.'",
        }
    ],
    response_format={"type": "json_object"},
)

data = json.loads(response.choices[0].message.content)
print(data)  # {"name": "Jane Smith", "email": "jane@acme.com", "company": "Acme Corp"}

Funktionsaufruf (Tool-Nutzung)

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_stock_price",
            "description": "Get the current stock price for a ticker symbol",
            "parameters": {
                "type": "object",
                "properties": {
                    "ticker": {"type": "string", "description": "Stock ticker, e.g. AAPL"},
                },
                "required": ["ticker"],
            },
        },
    }
]

messages = [{"role": "user", "content": "What's the current price of Apple stock?"}]

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

# Process tool call
if response.choices[0].finish_reason == "tool_calls":
    tool_call = response.choices[0].message.tool_calls[0]
    args = json.loads(tool_call.function.arguments)
    print(f"Calling {tool_call.function.name} with {args}")
    
    # Simulate function result
    result = {"ticker": args["ticker"], "price": 189.50}
    
    # Send result back
    messages.append(response.choices[0].message)
    messages.append({
        "role": "tool",
        "tool_call_id": tool_call.id,
        "content": json.dumps(result),
    })
    
    final = client.chat.completions.create(model="gpt-5.4", messages=messages)
    print(final.choices[0].message.content)

Einbettungen

response = client.embeddings.create(
    model="text-embedding-3-small",
    input=["OpenAI API Python tutorial", "Machine learning basics"],
)

embeddings = [item.embedding for item in response.data]
print(f"Embedding dimensions: {len(embeddings[0])}")

Asynchrone Nutzung

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    api_key="YOUR_APIMASTER_KEY",
    base_url="https://apimaster.ai/v1",
)

async def generate(prompt: str) -> str:
    resp = await client.chat.completions.create(
        model="gpt-5.4",
        messages=[{"role": "user", "content": prompt}],
    )
    return resp.choices[0].message.content

async def main():
    # Run 5 requests concurrently
    prompts = [f"Explain concept #{i}" for i in range(5)]
    results = await asyncio.gather(*[generate(p) for p in prompts])
    for r in results:
        print(r[:100])

asyncio.run(main())

Fehlerbehandlung

from openai import OpenAI, AuthenticationError, RateLimitError, APIError
import time

def safe_call(client, **kwargs):
    for attempt in range(3):
        try:
            return client.chat.completions.create(**kwargs)
        except AuthenticationError:
            raise  # Don't retry auth errors
        except RateLimitError:
            time.sleep(2 ** attempt)
        except APIError as e:
            if e.status_code >= 500:
                time.sleep(1)
            else:
                raise
    raise RuntimeError("Max retries exceeded")

Modellauswahl-Leitfaden

Aufgabe	Modell	Grund
Zusammenfassung, Klassifikation	gpt-4o-mini	Niedrige Kosten
Allgemeines Programmieren, Schreiben	gpt-5.4	Beste Balance
Komplexes Denken	gpt-5.5 oder o3	Hohe Fähigkeit
Stapelverarbeitung	gpt-4o-mini oder gpt-5.4	Wählen Sie nach Qualität und Budget

Häufig gestellte Fragen

Wie installiere ich die OpenAI Python-Bibliothek? Führen Sie pip install openai aus. Für den APIMaster-Zugang ist kein zusätzliches Paket erforderlich – setzen Sie einfach base_url und api_key beim Initialisieren des Clients.

Welche Python-Version wird für die OpenAI-Bibliothek benötigt? Python 3.8 oder höher. Der asynchrone Client erfordert Python 3.10+ für beste Kompatibilität.

Wie gehe ich mit OpenAI API-Ratenbegrenzungen in Python um? Verwenden Sie exponentielles Backoff – fangen Sie RateLimitError ab und wiederholen Sie den Vorgang mit zunehmenden Verzögerungen. Die Bibliothek tenacity vereinfacht dies. Das Routing von APIMaster bietet zusätzliche Stabilität.

Kann ich die OpenAI Python-Bibliothek mit Claude-Modellen verwenden? Ja – über APIMaster. Setzen Sie base_url="https://apimaster.ai/v1" und verwenden Sie Modell-IDs wie claude-sonnet-4-6. Das Antwortformat ist identisch mit GPT-Antworten.

Wie verwende ich asynchrone OpenAI-Aufrufe in Python? Verwenden Sie AsyncOpenAI anstelle von OpenAI und await Sie die API-Aufrufe. Siehe das asynchrone Beispiel in der Anleitung oben.

OpenAI API-Zugang über APIMaster erhalten →