Gemini 2.5 Flash Image (auch Nano Banana genannt) ist jetzt in der Gemini API verfügbar. Weitere Informationen

Diese Seite wurde von der Cloud Translation API übersetzt.

Codeausführung

Die Gemini API bietet ein Tool zur Codeausführung, mit dem das Modell Python-Code generieren und ausführen kann. Das Modell kann dann iterativ aus den Ergebnissen der Codeausführung lernen, bis es eine endgültige Ausgabe erstellt hat. Sie können die Codeausführung verwenden, um Anwendungen zu erstellen, die von codebasierten Schlussfolgerungen profitieren. Sie können die Codeausführung beispielsweise verwenden, um Gleichungen zu lösen oder Text zu verarbeiten. Sie können auch die Bibliotheken verwenden, die in der Codeausführungsumgebung enthalten sind, um speziellere Aufgaben auszuführen.

Gemini kann Code nur in Python ausführen. Sie können Gemini weiterhin bitten, Code in einer anderen Sprache zu generieren, aber das Modell kann das Tool zur Codeausführung nicht verwenden, um ihn auszuführen.

Codeausführung aktivieren

Um die Codeausführung zu aktivieren, müssen Sie das Tool für die Codeausführung für das Modell konfigurieren. So kann das Modell Code generieren und ausführen.

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);
  }
});

Ok

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."
        }
    },
}'

Die Ausgabe könnte in etwa so aussehen (zur besseren Lesbarkeit formatiert):

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.

Diese Ausgabe kombiniert mehrere Inhaltsteile, die das Modell bei der Codeausführung zurückgibt:

text: Inline-Text, der vom Modell generiert wurde
executableCode: Vom Modell generierter Code, der ausgeführt werden soll
codeExecutionResult: Ergebnis des ausführbaren Codes

Die Namenskonventionen für diese Teile variieren je nach Programmiersprache.

Codeausführung in Chats verwenden

Sie können die Codeausführung auch im Rahmen eines Chats verwenden.

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);

Ok

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."
            }]
        }
    ]
}'

Eingabe/Ausgabe (E/A)

Ab Gemini 2.0 Flash werden bei der Codeausführung Dateieingaben und Grafikausgaben unterstützt. Mit diesen Ein- und Ausgabefunktionen können Sie CSV- und Textdateien hochladen, Fragen zu den Dateien stellen und Matplotlib-Diagramme als Teil der Antwort generieren lassen. Die Ausgabedateien werden als Inlinebilder in der Antwort zurückgegeben.

I/O-Preise

Bei der Verwendung von Code-Ausführung I/O werden Ihnen Eingabe- und Ausgabetokens in Rechnung gestellt:

Eingabetokens:

Nutzer-Prompt

Ausgabetokens:

Vom Modell generierter Code
Ausgabe der Codeausführung in der Codeumgebung
Tokens für Denkprozesse
Vom Modell generierte Zusammenfassung

E/A-Details

Beachten Sie bei der Arbeit mit der Ein-/Ausgabe der Codeausführung die folgenden technischen Details:

Die maximale Laufzeit der Codeumgebung beträgt 30 Sekunden.
Wenn in der Codeumgebung ein Fehler auftritt, kann das Modell die Codeausgabe neu generieren. Das kann bis zu fünfmal passieren.
Die maximale Dateieingabegröße ist durch das Tokenfenster des Modells begrenzt. In AI Studio mit Gemini Flash 2.0 beträgt die maximale Eingabedateigröße 1 Million Tokens (ungefähr 2 MB für Textdateien der unterstützten Eingabetypen). Wenn Sie eine zu große Datei hochladen, können Sie sie in AI Studio nicht senden.
Die Codeausführung funktioniert am besten mit Text- und CSV-Dateien.
Die Eingabedatei kann in part.inlineData oder part.fileData übergeben werden (über die Files API hochgeladen). Die Ausgabedatei wird immer als part.inlineData zurückgegeben.

	Single-Turn	Bidirektional (Multimodal Live API)
Unterstützte Modelle	Alle Gemini 2.0- und 2.5-Modelle	Nur experimentelle Flash-Modelle
Unterstützte Dateieingabetypen	PNG, JPEG, CSV, XML, CPP, JAVA, PY, JS, TS	PNG, JPEG, CSV, XML, CPP, JAVA, PY, JS, TS
Unterstützte Bibliotheken für die Erstellung von Diagrammen	Matplotlib, seaborn	Matplotlib, seaborn
Verwendung mehrerer Tools	Ja (nur Codeausführung + Fundierung)	Ja

Abrechnung

Für die Aktivierung der Codeausführung über die Gemini API fallen keine zusätzlichen Kosten an. Die Abrechnung erfolgt zum aktuellen Preis für Eingabe- und Ausgabetokens basierend auf dem verwendeten Gemini-Modell.

Weitere Informationen zur Abrechnung der Codeausführung:

Sie werden nur einmal für die Eingabetokens in Rechnung gestellt, die Sie an das Modell übergeben, und für die endgültigen Ausgabetokens, die vom Modell an Sie zurückgegeben werden.
Tokens, die generierten Code darstellen, werden als Ausgabetokens gezählt. Generierter Code kann Text und multimodale Ausgaben wie Bilder enthalten.
Die Ergebnisse der Codeausführung werden ebenfalls als Ausgabetokens gezählt.

Das Abrechnungsmodell ist im folgenden Diagramm dargestellt:

Abrechnungsmodell für die Codeausführung

Die Abrechnung erfolgt zum aktuellen Preis für Eingabe- und Ausgabetokens basierend auf dem verwendeten Gemini-Modell.
Wenn Gemini die Codeausführung zum Generieren Ihrer Antwort verwendet, werden der ursprüngliche Prompt, der generierte Code und das Ergebnis des ausgeführten Codes als Zwischentokens gekennzeichnet und als Eingabetokens abgerechnet.
Gemini generiert dann eine Zusammenfassung und gibt den generierten Code, das Ergebnis des ausgeführten Codes und die endgültige Zusammenfassung zurück. Diese werden als Ausgabe-Tokens abgerechnet.
Die Gemini API enthält eine Zwischenanzahl von Tokens in der API-Antwort, damit Sie wissen, warum Sie zusätzliche Eingabetokens über Ihren ursprünglichen Prompt hinaus erhalten.

Beschränkungen

Das Modell kann nur Code generieren und ausführen. Andere Artefakte wie Mediendateien können nicht zurückgegeben werden.
In einigen Fällen kann die Aktivierung der Codeausführung zu Regressionen in anderen Bereichen der Modellausgabe führen, z. B. beim Schreiben einer Geschichte.
Die Fähigkeit der verschiedenen Modelle, die Codeausführung erfolgreich zu nutzen, variiert.

Unterstützte Bibliotheken

Die Codeausführungsumgebung umfasst die folgenden Bibliotheken:

attrs
Schach
contourpy
fpdf
geopandas
imageio
jinja2
joblib
jsonschema
jsonschema-specifications
lxml
matplotlib
mpmath
numpy
opencv-python
openpyxl
Paketerstellung
pandas
Kissen
protobuf
pylatex
pyparsing
PyPDF2
python-dateutil
python-docx
python-pptx
reportlab
scikit-learn
scipy
seaborn
six
striprtf
sympy
tabellarisch darstellen
tensorflow
toolz
xlrd

Sie können keine eigenen Bibliotheken installieren.

Nächste Schritte

Colab zur Codeausführung testen.
Weitere Informationen zu anderen Gemini API-Tools:
- Funktionsaufrufe
- Fundierung mit der Google Suche