openai-api-python
title: Tutorial Python per l'API OpenAI 2026 | APIMaster.ai description: Tutorial Python completo per l'API OpenAI: installa l'SDK, esegui chat completions, risposte in streaming, usa function calling e crea app asincrone. Funziona con APIMaster.ai per accesso scontato.
Tutorial Python per l'API OpenAI
Questo tutorial copre l'uso dell'API OpenAI con Python dall'installazione fino ai casi d'uso avanzati. Tutti gli esempi funzionano con APIMaster.ai—basta cambiare api_key e base_url.
Installazione
pip install openai
Richiede Python 3.8+. Il pacchetto openai è l'SDK Python ufficiale di OpenAI (versione 1.x).
Configurazione Iniziale
from openai import OpenAI
client = OpenAI(
api_key="YOUR_APIMASTER_KEY",
base_url="https://apimaster.ai/v1",
)
Oppure usa le variabili d'ambiente (consigliato):
export OPENAI_API_KEY="YOUR_APIMASTER_KEY"
export OPENAI_BASE_URL="https://apimaster.ai/v1"
from openai import OpenAI
client = OpenAI() # legge automaticamente le variabili d'ambiente
Chat Completions di Base
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}")
Risposte in Streaming
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()
Conversazioni Multi-Turno
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."))
Output Strutturato (Modalità JSON)
Forza il modello a restituire JSON valido:
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"}
Chiamata a Funzioni (Uso di Strumenti)
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)
Embeddings
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])}")
Utilizzo Asincrono
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())
Gestione degli Errori
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")
Guida alla Selezione dei Modelli
| Attività | Modello | Motivo |
|---|---|---|
| Riassunto, classificazione | gpt-4o-mini | Basso costo |
| Codifica generica, scrittura | gpt-5.4 | Miglior equilibrio |
| Ragionamento complesso | gpt-5.5 o o3 | Alta capacità |
| Elaborazione batch | gpt-4o-mini o gpt-5.4 | Scegli in base a qualità e budget |
Domande Frequenti
Come installo la libreria Python di OpenAI?
Esegui pip install openai. Per l'accesso tramite APIMaster, non è necessario alcun pacchetto aggiuntivo—basta impostare base_url e api_key durante l'inizializzazione del client.
Quale versione di Python è richiesta per la libreria OpenAI?
Python 3.8 o successiva. Il client asincrono richiede Python 3.10+ per la migliore compatibilità.
Come gestisco i limiti di frequenza dell'API OpenAI in Python?
Usa il backoff esponenziale—cattura RateLimitError e riprova con ritardi crescenti. La libreria tenacity semplifica questa operazione. Il routing di APIMaster fornisce una stabilità aggiuntiva.
Posso usare la libreria Python di OpenAI con i modelli Claude?
Sì—tramite APIMaster. Imposta base_url="https://apimaster.ai/v1" e usa ID modello come claude-sonnet-4-6. Il formato della risposta è identico a quello delle risposte GPT.
Come si usano le chiamate asincrone di OpenAI in Python?
Usa AsyncOpenAI invece di OpenAI e await le chiamate API. Vedi l'esempio asincrono nella guida sopra.