Esecuzione di codice

L'API Gemini fornisce uno strumento di esecuzione del codice che consente al modello di generare ed eseguire codice Python. Il modello può quindi apprendere in modo iterativo dai risultati dell'esecuzione del codice fino a ottenere un output finale. Puoi utilizzare l'esecuzione di codice per creare applicazioni che sfruttano il ragionamento basato sul codice. Ad esempio, puoi utilizzare l'esecuzione del codice per risolvere equazioni o elaborare testo. Puoi anche utilizzare le librerie incluse nell'ambiente di esecuzione del codice per eseguire attività più specializzate.

Gemini è in grado di eseguire codice solo in Python. Puoi comunque chiedere a Gemini di generare codice in un'altra lingua, ma il modello non può utilizzare lo strumento di esecuzione del codice per eseguirlo.

Attivare l'esecuzione del codice

Per attivare l'esecuzione del codice, configura lo strumento di esecuzione del codice sul modello. Ciò consente al modello di generare ed eseguire codice.

Python

from google import genai from google.genai import types  client = genai.Client()  response = client.models.generate_content(     model="gemini-2.5-flash",     contents="What is the sum of the first 50 prime numbers? "     "Generate and run code for the calculation, and make sure you get all 50.",     config=types.GenerateContentConfig(         tools=[types.Tool(code_execution=types.ToolCodeExecution)]     ), )  for part in response.candidates[0].content.parts:     if part.text is not None:         print(part.text)     if part.executable_code is not None:         print(part.executable_code.code)     if part.code_execution_result is not None:         print(part.code_execution_result.output) 

JavaScript

import { GoogleGenAI } from "@google/genai";  const ai = new GoogleGenAI({});  let response = await ai.models.generateContent({   model: "gemini-2.5-flash",   contents: [     "What is the sum of the first 50 prime numbers? " +       "Generate and run code for the calculation, and make sure you get all 50.",   ],   config: {     tools: [{ codeExecution: {} }],   }, });  const parts = response?.candidates?.[0]?.content?.parts || []; parts.forEach((part) => {   if (part.text) {     console.log(part.text);   }    if (part.executableCode && part.executableCode.code) {     console.log(part.executableCode.code);   }    if (part.codeExecutionResult && part.codeExecutionResult.output) {     console.log(part.codeExecutionResult.output);   } }); 

Vai

package main  import (     "context"     "fmt"     "os"     "google.golang.org/genai" )  func main() {      ctx := context.Background()     client, err := genai.NewClient(ctx, nil)     if err != nil {         log.Fatal(err)     }      config := &genai.GenerateContentConfig{         Tools: []*genai.Tool{             {CodeExecution: &genai.ToolCodeExecution{}},         },     }      result, _ := client.Models.GenerateContent(         ctx,         "gemini-2.5-flash",         genai.Text("What is the sum of the first 50 prime numbers? " +                   "Generate and run code for the calculation, and make sure you get all 50."),         config,     )      fmt.Println(result.Text())     fmt.Println(result.ExecutableCode())     fmt.Println(result.CodeExecutionResult()) } 

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent" \ -H "x-goog-api-key: $GEMINI_API_KEY" \ -H 'Content-Type: application/json' \ -d ' {"tools": [{"code_execution": {}}],     "contents": {       "parts":         {             "text": "What is the sum of the first 50 prime numbers? Generate and run code for the calculation, and make sure you get all 50."         }     }, }' 

L'output potrebbe essere simile al seguente, formattato per una maggiore leggibilità:

Okay, I need to calculate the sum of the first 50 prime numbers. Here's how I'll approach this:  1.  **Generate Prime Numbers:** I'll use an iterative method to find prime     numbers. I'll start with 2 and check if each subsequent number is divisible     by any number between 2 and its square root. If not, it's a prime. 2.  **Store Primes:** I'll store the prime numbers in a list until I have 50 of     them. 3.  **Calculate the Sum:**  Finally, I'll sum the prime numbers in the list.  Here's the Python code to do this:  def is_prime(n):   """Efficiently checks if a number is prime."""   if n <= 1:     return False   if n <= 3:     return True   if n % 2 == 0 or n % 3 == 0:     return False   i = 5   while i * i <= n:     if n % i == 0 or n % (i + 2) == 0:       return False     i += 6   return True  primes = [] num = 2 while len(primes) < 50:   if is_prime(num):     primes.append(num)   num += 1  sum_of_primes = sum(primes) print(f'{primes=}') print(f'{sum_of_primes=}')  primes=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229] sum_of_primes=5117  The sum of the first 50 prime numbers is 5117. 

Questo output combina diverse parti di contenuti restituite dal modello quando si utilizza l'esecuzione di codice:

  • text: Testo in linea generato dal modello
  • executableCode: il codice generato dal modello che deve essere eseguito
  • codeExecutionResult: Risultato del codice eseguibile

Le convenzioni di denominazione per queste parti variano in base al linguaggio di programmazione.

Utilizzare l'esecuzione di codice in chat

Puoi anche utilizzare l'esecuzione di codice nell'ambito di una chat.

Python

from google import genai from google.genai import types  client = genai.Client()  chat = client.chats.create(     model="gemini-2.5-flash",     config=types.GenerateContentConfig(         tools=[types.Tool(code_execution=types.ToolCodeExecution)]     ), )  response = chat.send_message("I have a math question for you.") print(response.text)  response = chat.send_message(     "What is the sum of the first 50 prime numbers? "     "Generate and run code for the calculation, and make sure you get all 50." )  for part in response.candidates[0].content.parts:     if part.text is not None:         print(part.text)     if part.executable_code is not None:         print(part.executable_code.code)     if part.code_execution_result is not None:         print(part.code_execution_result.output) 

JavaScript

import {GoogleGenAI} from "@google/genai";  const ai = new GoogleGenAI({});  const chat = ai.chats.create({   model: "gemini-2.5-flash",   history: [     {       role: "user",       parts: [{ text: "I have a math question for you:" }],     },     {       role: "model",       parts: [{ text: "Great! I'm ready for your math question. Please ask away." }],     },   ],   config: {     tools: [{codeExecution:{}}],   } });  const response = await chat.sendMessage({   message: "What is the sum of the first 50 prime numbers? " +             "Generate and run code for the calculation, and make sure you get all 50." }); console.log("Chat response:", response.text); 

Vai

package main  import (     "context"     "fmt"     "os"     "google.golang.org/genai" )  func main() {      ctx := context.Background()     client, err := genai.NewClient(ctx, nil)     if err != nil {         log.Fatal(err)     }      config := &genai.GenerateContentConfig{         Tools: []*genai.Tool{             {CodeExecution: &genai.ToolCodeExecution{}},         },     }      chat, _ := client.Chats.Create(         ctx,         "gemini-2.5-flash",         config,         nil,     )      result, _ := chat.SendMessage(                     ctx,                     genai.Part{Text: "What is the sum of the first 50 prime numbers? " +                                           "Generate and run code for the calculation, and " +                                           "make sure you get all 50.",                               },                 )      fmt.Println(result.Text())     fmt.Println(result.ExecutableCode())     fmt.Println(result.CodeExecutionResult()) } 

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent" \ -H "x-goog-api-key: $GEMINI_API_KEY" \ -H 'Content-Type: application/json' \ -d '{"tools": [{"code_execution": {}}],     "contents": [         {             "role": "user",             "parts": [{                 "text": "Can you print \"Hello world!\"?"             }]         },{             "role": "model",             "parts": [               {                 "text": ""               },               {                 "executable_code": {                   "language": "PYTHON",                   "code": "\nprint(\"hello world!\")\n"                 }               },               {                 "code_execution_result": {                   "outcome": "OUTCOME_OK",                   "output": "hello world!\n"                 }               },               {                 "text": "I have printed \"hello world!\" using the provided python code block. \n"               }             ],         },{             "role": "user",             "parts": [{                 "text": "What is the sum of the first 50 prime numbers? Generate and run code for the calculation, and make sure you get all 50."             }]         }     ] }' 

Input/output (I/O)

A partire da Gemini 2.0 Flash, l'esecuzione di codice supporta l'input di file e l'output di grafici. Utilizzando queste funzionalità di input e output, puoi caricare file CSV e di testo, porre domande sui file e generare grafici Matplotlib come parte della risposta. I file di output vengono restituiti come immagini in linea nella risposta.

Prezzi I/O

Quando utilizzi l'I/O di esecuzione del codice, ti vengono addebitati i token di input e di output:

Token di input:

  • Prompt dell'utente

Token di output:

  • Codice generato dal modello
  • Output dell'esecuzione del codice nell'ambiente di codice
  • Token di pensiero
  • Riepilogo generato dal modello

Dettagli I/O

Quando lavori con l'I/O di esecuzione del codice, tieni presente i seguenti dettagli tecnici:

  • Il tempo di esecuzione massimo dell'ambiente di codice è di 30 secondi.
  • Se l'ambiente di codice genera un errore, il modello potrebbe decidere di rigenerare l'output del codice. Questa operazione può essere eseguita fino a 5 volte.
  • La dimensione massima dell'input del file è limitata dalla finestra dei token del modello. In AI Studio, utilizzando Gemini Flash 2.0, la dimensione massima del file di input è 1 milione di token (circa 2 MB per i file di testo dei tipi di input supportati). Se carichi un file troppo grande, AI Studio non ti consentirà di inviarlo.
  • L'esecuzione del codice funziona meglio con file di testo e CSV.
  • Il file di input può essere passato in part.inlineData o part.fileData (caricato tramite l'API Files) e il file di output viene sempre restituito come part.inlineData.
A turno singolo Bidirezionale (API Multimodal Live)
Modelli supportati Tutti i modelli Gemini 2.0 e 2.5 Solo modelli sperimentali Flash
Tipi di input dei file supportati .png, .jpeg, .csv, .xml, .cpp, .java, .py, .js, .ts .png, .jpeg, .csv, .xml, .cpp, .java, .py, .js, .ts
Librerie di tracciamento supportate Matplotlib, seaborn Matplotlib, seaborn
Utilizzo di più strumenti Sì (solo esecuzione del codice + grounding)

Fatturazione

Non sono previsti costi aggiuntivi per l'abilitazione dell'esecuzione del codice dall'API Gemini. Ti verrà addebitata la tariffa attuale dei token di input e output in base al modello Gemini che utilizzi.

Ecco alcune altre informazioni da sapere sulla fatturazione per l'esecuzione del codice:

  • Ti viene addebitato un costo una sola volta per i token di input che passi al modello e ti viene addebitato un costo per i token di output finali restituiti dal modello.
  • I token che rappresentano il codice generato vengono conteggiati come token di output. Il codice generato può includere testo e output multimodali come immagini.
  • Anche i risultati dell'esecuzione del codice vengono conteggiati come token di output.

Il modello di fatturazione è mostrato nel seguente diagramma:

modello di fatturazione dell&#39;esecuzione del codice

  • Ti viene addebitata la tariffa attuale dei token di input e output in base al modello Gemini che utilizzi.
  • Se Gemini utilizza l'esecuzione del codice durante la generazione della risposta, il prompt originale, il codice generato e il risultato del codice eseguito vengono etichettati come token intermedi e vengono fatturati come token di input.
  • Gemini genera quindi un riepilogo e restituisce il codice generato, il risultato del codice eseguito e il riepilogo finale. Questi vengono fatturati come token di output.
  • L'API Gemini include un conteggio dei token intermedi nella risposta dell'API, in modo da sapere perché ricevi token di input aggiuntivi oltre al prompt iniziale.

Limitazioni

  • Il modello può solo generare ed eseguire codice. Non può restituire altri artefatti come i file multimediali.
  • In alcuni casi, l'attivazione dell'esecuzione del codice può portare a regressioni in altre aree dell'output del modello (ad esempio, la scrittura di una storia).
  • Esiste una certa variazione nella capacità dei diversi modelli di utilizzare l'esecuzione del codice.

Librerie supportate

L'ambiente di esecuzione del codice include le seguenti librerie:

  • attrs
  • scacchi
  • contourpy
  • fpdf
  • geopandas
  • imageio
  • jinja2
  • joblib
  • jsonschema
  • jsonschema-specifications
  • lxml
  • matplotlib
  • mpmath
  • numpy
  • opencv-python
  • openpyxl
  • pacchettizzazione
  • panda
  • cuscino
  • protobuf
  • pylatex
  • pyparsing
  • PyPDF2
  • python-dateutil
  • python-docx
  • python-pptx
  • reportlab
  • scikit-learn
  • scipy
  • seaborn
  • sei
  • striprtf
  • sympy
  • tabulare
  • tensorflow
  • toolz
  • xlrd

Non puoi installare le tue librerie.

Passaggi successivi