Samouczek API OpenAI w Pythonie

Ten samouczek obejmuje korzystanie z API OpenAI w Pythonie od instalacji po zaawansowane przypadki użycia. Wszystkie przykłady działają z APIMaster.ai — wystarczy zmienić api_key i base_url.

Instalacja

pip install openai

Wymaga Pythona 3.8+. Pakiet openai to oficjalny SDK OpenAI dla Pythona (wersja 1.x).

Podstawowa konfiguracja

from openai import OpenAI

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

Lub użyj zmiennych środowiskowych (zalecane):

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

from openai import OpenAI
client = OpenAI()  # automatycznie odczytuje zmienne środowiskowe

Podstawowe odpowiedzi czatu

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "system", "content": "Jesteś ekspertem Pythona."},
        {"role": "user", "content": "Czym jest generator w Pythonie?"},
    ],
)

print(response.choices[0].message.content)
print(f"Użyto tokenów: {response.usage.total_tokens}")

Strumieniowanie odpowiedzi

stream = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{"role": "user", "content": "Napisz wyszukiwanie binarne w Pythonie."}],
    stream=True,
)

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

Rozmowy wieloetapowe

messages = [
    {"role": "system", "content": "Jesteś pomocnym asystentem kodowania."}
]

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("Wyjaśnij listy składane."))
print(send("Podaj trudniejszy przykład."))

Ustrukturyzowane wyjście (tryb JSON)

Wymuś zwrócenie prawidłowego JSON przez model:

import json

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {
            "role": "user",
            "content": "Wyodrębnij nazwę, email i firmę z: 'Kontakt: Jan Kowalski (jan@firma.pl) w Firmie XYZ.'",
        }
    ],
    response_format={"type": "json_object"},
)

data = json.loads(response.choices[0].message.content)
print(data)  # {"name": "Jan Kowalski", "email": "jan@firma.pl", "company": "Firma XYZ"}

Wywoływanie funkcji (użycie narzędzi)

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_stock_price",
            "description": "Pobierz bieżącą cenę akcji dla symbolu giełdowego",
            "parameters": {
                "type": "object",
                "properties": {
                    "ticker": {"type": "string", "description": "Symbol giełdowy, np. AAPL"},
                },
                "required": ["ticker"],
            },
        },
    }
]

messages = [{"role": "user", "content": "Jaka jest obecna cena akcji Apple?"}]

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

# Przetwarzanie wywołania narzędzia
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"Wywołanie {tool_call.function.name} z {args}")
    
    # Symulacja wyniku funkcji
    result = {"ticker": args["ticker"], "price": 189.50}
    
    # Wysłanie wyniku z powrotem
    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)

Embeddingi

response = client.embeddings.create(
    model="text-embedding-3-small",
    input=["Samouczek API OpenAI w Pythonie", "Podstawy uczenia maszynowego"],
)

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

Użycie asynchroniczne

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    api_key="TWOJ_KLUCZ_APIMASTER",
    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():
    # Uruchom 5 zapytań jednocześnie
    prompts = [f"Wyjaśnij koncept #{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())

Obsługa błędów

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  # Nie ponawiaj prób dla błędów uwierzytelniania
        except RateLimitError:
            time.sleep(2 ** attempt)
        except APIError as e:
            if e.status_code >= 500:
                time.sleep(1)
            else:
                raise
    raise RuntimeError("Przekroczono maksymalną liczbę prób")

Przewodnik wyboru modelu

Zadanie	Model	Dlaczego
Podsumowywanie, klasyfikacja	gpt-4o-mini	Niski koszt
Ogólne kodowanie, pisanie	gpt-5.4	Najlepszy balans
Złożone rozumowanie	gpt-5.5 lub o3	Wysoka wydajność
Przetwarzanie wsadowe	gpt-4o-mini lub gpt-5.4	Wybór według jakości i budżetu

Często zadawane pytania

Jak zainstalować bibliotekę OpenAI w Pythonie? Uruchom pip install openai. Dla dostępu przez APIMaster nie jest wymagany dodatkowy pakiet — wystarczy ustawić base_url i api_key podczas inicjalizacji klienta.

Jaka wersja Pythona jest wymagana dla biblioteki OpenAI? Python 3.8 lub nowszy. Klient asynchroniczny wymaga Pythona 3.10+ dla najlepszej kompatybilności.

Jak obsługiwać limity szybkości API OpenAI w Pythonie? Użyj wykładniczego wycofywania — przechwyć RateLimitError i ponawiaj próby z rosnącymi opóźnieniami. Biblioteka tenacity upraszcza to. Routing APIMaster zapewnia dodatkową stabilność.

Czy mogę używać biblioteki OpenAI w Pythonie z modelami Claude? Tak — przez APIMaster. Ustaw base_url="https://apimaster.ai/v1" i użyj identyfikatorów modeli takich jak claude-sonnet-4-6. Format odpowiedzi jest identyczny jak w przypadku GPT.

Jak używać asynchronicznych wywołań OpenAI w Pythonie? Użyj AsyncOpenAI zamiast OpenAI i await dla wywołań API. Zobacz przykład asynchroniczny w przewodniku powyżej.

Uzyskaj dostęp do API OpenAI przez APIMaster →