Tutoriel Python pour l'API OpenAI

Ce tutoriel couvre l'utilisation de l'API OpenAI avec Python, de l'installation aux cas d'utilisation avancés. Tous les exemples fonctionnent avec APIMaster.ai — il suffit de modifier api_key et base_url.

Installation

pip install openai

Nécessite Python 3.8+. Le package openai est le SDK Python officiel d'OpenAI (version 1.x).

Configuration initiale

from openai import OpenAI

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

Ou utilisez des variables d'environnement (recommandé) :

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

from openai import OpenAI
client = OpenAI()  # lit automatiquement les variables d'environnement

Complétions de chat de base

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "system", "content": "Vous êtes un expert Python."},
        {"role": "user", "content": "Qu'est-ce qu'un générateur en Python ?"},
    ],
)

print(response.choices[0].message.content)
print(f"Jetons utilisés : {response.usage.total_tokens}")

Diffusion des réponses

stream = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{"role": "user", "content": "Écris une recherche binaire en Python."}],
    stream=True,
)

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

Conversations à plusieurs tours

messages = [
    {"role": "system", "content": "Vous êtes un assistant de codage utile."}
]

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

print(envoyer("Explique les listes en compréhension."))
print(envoyer("Donne-moi un exemple plus difficile."))

Sortie structurée (Mode JSON)

Forcer le modèle à renvoyer du JSON valide :

import json

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {
            "role": "user",
            "content": "Extrais le nom, l'email et l'entreprise de : 'Contactez Jane Smith (jane@acme.com) chez 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"}

Appel de fonctions (Utilisation d'outils)

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "obtenir_cours_action",
            "description": "Obtenir le cours actuel d'une action pour un symbole boursier",
            "parameters": {
                "type": "object",
                "properties": {
                    "ticker": {"type": "string", "description": "Symbole boursier, ex. AAPL"},
                },
                "required": ["ticker"],
            },
        },
    }
]

messages = [{"role": "user", "content": "Quel est le cours actuel de l'action Apple ?"}]

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

# Traiter l'appel d'outil
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"Appel de {tool_call.function.name} avec {args}")
    
    # Simuler le résultat de la fonction
    result = {"ticker": args["ticker"], "price": 189.50}
    
    # Renvoyer le résultat
    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)

Embeddings

response = client.embeddings.create(
    model="text-embedding-3-small",
    input=["Tutoriel Python API OpenAI", "Bases du machine learning"],
)

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

Utilisation asynchrone

import asyncio
from openai import AsyncOpenAI

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

async def generer(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():
    # Exécuter 5 requêtes simultanément
    prompts = [f"Explique le concept #{i}" for i in range(5)]
    results = await asyncio.gather(*[generer(p) for p in prompts])
    for r in results:
        print(r[:100])

asyncio.run(main())

Gestion des erreurs

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

def appel_securise(client, **kwargs):
    for tentative in range(3):
        try:
            return client.chat.completions.create(**kwargs)
        except AuthenticationError:
            raise  # Ne pas réessayer les erreurs d'authentification
        except RateLimitError:
            time.sleep(2 ** tentative)
        except APIError as e:
            if e.status_code >= 500:
                time.sleep(1)
            else:
                raise
    raise RuntimeError("Nombre maximal de tentatives dépassé")

Guide de sélection des modèles

Tâche	Modèle	Pourquoi
Résumé, classification	gpt-4o-mini	Faible coût
Codage général, rédaction	gpt-5.4	Meilleur équilibre
Raisonnement complexe	gpt-5.5 ou o3	Haute capacité
Traitement par lots	gpt-4o-mini ou gpt-5.4	Choisir selon la qualité et le budget

Foire aux questions

Comment installer la bibliothèque Python OpenAI ? Exécutez pip install openai. Pour l'accès APIMaster, aucun package supplémentaire n'est nécessaire — définissez simplement base_url et api_key lors de l'initialisation du client.

Quelle version de Python est requise pour la bibliothèque OpenAI ? Python 3.8 ou ultérieur. Le client asynchrone nécessite Python 3.10+ pour une meilleure compatibilité.

Comment gérer les limites de débit de l'API OpenAI en Python ? Utilisez le backoff exponentiel — interceptez RateLimitError et réessayez avec des délais croissants. La bibliothèque tenacity simplifie cela. Le routage d'APIMaster offre une stabilité supplémentaire.

Puis-je utiliser la bibliothèque Python OpenAI avec les modèles Claude ? Oui — via APIMaster. Définissez base_url="https://apimaster.ai/v1" et utilisez des identifiants de modèle comme claude-sonnet-4-6. Le format de réponse est identique à celui des réponses GPT.

Comment utiliser les appels asynchrones OpenAI en Python ? Utilisez AsyncOpenAI au lieu de OpenAI, et await les appels API. Voir l'exemple asynchrone dans le guide ci-dessus.

Obtenez un accès à l'API OpenAI via APIMaster →