Python OpenAI

openai est une puissante bibliothèque Python permettant d'interagir avec la suite de modèles et de services d'OpenAI.

openai encapsule tous les appels d'API RESTful, permettant aux développeurs d'intégrer facilement de puissantes capacités d'IA — telles que le traitement du langage naturel, la génération d'images et la reconnaissance vocale — dans leurs applications Python.

Fonctionnalités clés :

• Génération de texte : utilisez des modèles tels que GPT-4 ou GPT-5 pour générer des articles, du code, des résumés, des conversations, et plus encore.
• Génération d'images : créez des images à partir de descriptions textuelles en utilisant les modèles DALL-E.
• Embeddings : convertissez du texte en représentations vectorielles, couramment utilisées pour des tâches telles que la recherche sémantique, la classification de texte et le clustering.
• Transcription audio : utilisez le modèle Whisper pour transcrire des fichiers audio en texte.
• Fine-tuning : Entraînez un modèle plus ciblé en fournissant votre propre jeu de données.
• API Assistants : Créez des applications complexes capables de comprendre le contexte, d’appeler des outils et de réaliser des interactions à long terme.

dépôt open source openai :https://github.com/openai/openai-python

Comment l’utiliser ?

Exigences :

• Version de Python : 3.9 ou supérieure.
• Dépendances : httpx (par défaut), aiohttp (en option), websockets (nécessaire pour l’API Realtime).

Tout d’abord, vous devez installer la bibliothèque openai avec pip :

pip install openai

ou 

pip3 install openai

Ensuite, rendez-vous sur le site officiel d’OpenAIhttps://platform.openai.com/ pour créer un compte et générer une clé API sur la page des clés API.

Vérifiez la version installée :

import openai
print(openai.__version__)  # 输出当前 SDK 版本

Description du paramètre :

Modèles tiers

Accéder à OpenAI depuis la Chine reste quelque peu compliqué. De nombreux fournisseurs chinois prennent également en charge la compatibilité OpenAI, comme DeepSeek, Qwen et GLM.

DeepSeek

L'API DeepSeek est entièrement compatible avec le format d'API d'OpenAI. Il vous suffit de modifier quelques paramètres de configuration pour utiliser directement le SDK OpenAI ou des outils compatibles afin d'accéder à l'API DeepSeek.

Utilisation

Ensuite, nous utilisons le SDK OpenAI pour accéder aux modèles Qwen sur le service Bailian.

Exemple d'appel non-streaming

L'exécution du code produit le résultat suivant :

I am Qwen, an ultra-large-scale language model independently developed by the Tongyi Laboratory under Alibaba Group. I can help you answer questions and create text, such as writing stories, official documents, emails, scripts, logical reasoning, programming, and more. I can also express opinions and play games. If you have any questions or need help, feel free to tell me at any time!

Exemple d'appel en streaming

L'exécution du code produit le résultat suivant :

I am Qwen, an ultra-large-scale language model independently developed by the Tongyi Laboratory under Alibaba Group. I can help you answer questions and create text, such as writing stories, official documents, emails, scripts, logical reasoning, programming, and more. I can also express opinions and play games. If you have any questions or need help, feel free to tell me at any time!

Fonctionnalités phares

Capacité de vision

Prend en charge l'entrée d'images (URL ou encodage Base64) pour permettre une interaction multimodale.

Entrée d'URL d'image :

Entrée d'image encodée en Base64 :

Utilisation asynchrone (usage asynchrone)

Remplacer OpenAI par AsyncOpenAI et appeler l'API avec await :

Exemple asynchrone de base :

Pour l'optimisation des scénarios asynchrones (backend aiohttp), installez la version étendue :

pip install openai[aiohttp]

Optimisation du backend aiohttp :

Réponses en streaming

Basé sur les événements côté serveur (SSE) pour obtenir des réponses en temps réel ; les interfaces synchrones et asynchrones sont cohérentes.

Exemple de streaming synchrone :

Exemple de streaming asynchrone :

API temps réel

Conversation multimodale à faible latence (texte / audio), implémentée via WebSocket, nécessite la bibliothèque websockets.

Exemple de base pour le texte :

Gestion des erreurs de l'API Realtime :

Manuel de référence

Le tableau suivant contient :

• Initialisation du cœur : pour une utilisation synchrone,OpenAIpour une utilisation asynchrone,AsyncOpenAIpour une utilisation avec Azure,AzureOpenAIil est recommandé de configurer la clé API via des variables d'environnement.
• Génération de texte : préférez la nouvelle version,responses.create()pour les scénarios classiques, utilisezchat.completions.create()la sortie en streaming nécessite de définirstream=True。
• Capacités avancées : prise en charge du multimodal (entrée d'image), API temps réel, téléversement de fichiers/fine-tuning ; la gestion des erreurs doit intercepterAPIErrorles sous-classes, et le délai d'attente/la nouvelle tentative peut être configuré de manière flexible.

Installation et import

Installez le SDK officiel :

pip install --upgrade openai

Importez les classes principales :

from openai import OpenAI, AsyncOpenAI, AzureOpenAI

Création d’un client

Créez un client OpenAI standard :

from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY")

Créez un client via des variables d’environnement :

import os
from openai import OpenAI

os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"
client = OpenAI()

Définissez le délai d’attente des requêtes et le nombre de tentatives :

client = OpenAI(
    timeout=30,
    max_retries=2
)

Génération de texte (API Responses)

La requête de génération de texte la plus basique :

response = client.responses.create(
    model="gpt-5.2",
    input="用一句话解释什么是 Python"
)

print(response.output_text)

Contraignez le comportement du modèle via des instructions :

response = client.responses.create(
    model="gpt-5.2",
    instructions="你是一个严谨的 Python 教程作者",
    input="解释什么是列表推导式"
)

print(response.output_text)

Conversation multi-tours

Utilisez le tableau input pour construire une conversation contextuelle :

response = client.responses.create(
    model="gpt-5.2",
    input=[
        {"role": "user", "content": "Python 是什么？"},
        {"role": "assistant", "content": "Python 是一门高级编程语言。"},
        {"role": "user", "content": "它适合做什么？"}
    ]
)

print(response.output_text)

Sortie structurée (JSON Schema)

Demandez au modèle de renvoyer des données JSON conformes au schéma :

response = client.responses.create(
    model="gpt-5.2",
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "tech_summary",
            "schema": {
                "type": "object",
                "properties": {
                    "title": {"type": "string"},
                    "summary": {"type": "string"}
                },
                "required": ["title", "summary"]
            }
        }
    },
    input="介绍 asyncio"
)

print(response.output_parsed)

Appel d'outils (Function Calling)

Définissez des outils et laissez le modèle décider automatiquement s’il doit les appeler :

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "获取城市天气",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string"}
                },
                "required": ["city"]
            }
        }
    }
]

response = client.responses.create(
    model="gpt-5.2",
    tools=tools,
    input="北京今天天气怎么样？"
)

print(response.output)

Sortie en streaming (Streaming)

Sortie de streaming synchrone :

with client.responses.stream(
    model="gpt-5.2",
    input="写一段 Python 示例代码"
) as stream:
    for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="")

Sortie de streaming asynchrone :

stream = await client.responses.create(
    model="gpt-5.2",
    input="解释什么是生成式 AI",
    stream=True
)

async for event in stream:
    print(event)

Appels asynchrones (AsyncOpenAI)

Utiliser le client asynchrone dans asyncio :

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI()

async def main():
    response = await client.responses.create(
        model="gpt-5.2",
        input="解释什么是事件循环"
    )
    print(response.output_text)

asyncio.run(main())

API Realtime (Realtime)

Utiliser WebSocket pour des conversations en temps réel à faible latence :

async with client.realtime.connect(model="gpt-realtime") as conn:
    await conn.session.update(
        session={"type": "realtime", "output_modalities": ["text"]}
    )

    await conn.conversation.item.create(
        item={
            "type": "message",
            "role": "user",
            "content": [{"type": "input_text", "text": "你好"}]
        }
    )

    async for event in conn:
        print(event)

Génération d'images

Générer une image à partir de texte :

image = client.images.generate(
    model="gpt-image-1",
    prompt="一只在写代码的猫",
    size="1024x1024"
)

print(image.data[0].url)

Génération d'embeddings

Générer des embeddings vectoriels de texte :

embedding = client.embeddings.create(
    model="text-embedding-3-small",
    input="Hello world"
)

print(embedding.data[0].embedding)

Reconnaissance vocale

Convertir un fichier audio en texte :

audio_file = open("speech.mp3", "rb")

transcript = client.audio.transcriptions.create(
    model="whisper-1",
    file=audio_file
)

print(transcript.text)

Synthèse vocale

Convertir du texte en fichier audio :

speech = client.audio.speech.create(
    model="gpt-4o-mini-tts",
    voice="alloy",
    input="你好，欢迎使用 OpenAI"
)

with open("output.mp3", "wb") as f:
    f.write(speech)

Gestion des fichiers (Files API)

Téléverser un fichier :

from pathlib import Path

client.files.create(
    file=Path("data.jsonl"),
    purpose="fine-tune"
)

Lister les fichiers :

files = client.files.list()
for f in files:
    print(f.id, f.filename)

Supprimer un fichier :

client.files.delete(file_id="file-xxx")

Affinage du modèle (Fine-tuning Jobs)

Créer une tâche d'affinage :

job = client.fine_tuning.jobs.create(
    training_file="file-xxx",
    model="gpt-3.5-turbo"
)

print(job.id, job.status)

Vérification du Webhook

Vérifier et analyser la requête Webhook :

event = client.webhooks.unwrap(request_body, request_headers)

Vérifier uniquement la signature :

client.webhooks.verify_signature(request_body, request_headers)

Gestion des erreurs

Intercepter les exceptions levées par le SDK :

import openai

try:
    client.responses.create(
        model="gpt-5.2",
        input="test"
    )
except openai.RateLimitError as e:
    print("触发速率限制：", e)
except openai.APIConnectionError as e:
    print("连接失败：", e)

Obtenir l'ID de requête d'une requête échouée :

try:
    client.responses.create(model="gpt-5.2", input="test")
except openai.APIStatusError as exc:
    print(exc.request_id)

Compatibilité avec Azure OpenAI

Initialiser le client Azure OpenAI :

from openai import AzureOpenAI

client = AzureOpenAI(
    api_version="2023-07-01-preview",
    azure_endpoint="https://xxx.openai.azure.com"
)

Versions et journal des modifications

Vérifier la version du SDK :

import openai
print(openai.__version__)

Activer la journalisation de débogage du SDK :

export OPENAI_LOG=debug

Plus de références API :https://github.com/openai/openai-python/blob/main/api.md