Bestes LLM für Python-Programmierung: So wählst und testest du es
Es gibt kein einzelnes bestes LLM für Python, da die Antwort von deinen Aufgaben, der Kontextgröße und dem Preis pro Anfrage abhängt. Dieser Artikel liefert dir die Kriterien, funktionierenden Code für drei Programmier-Workflows und eine kleine Testumgebung, um Modelle an deiner eigenen Arbeit zu vergleichen.
Aktualisiert

Wichtige Punkte
- Öffentliche Ranglisten sind ein Ausgangspunkt. Ein 50-Aufgaben-Test an deiner eigenen Codebasis sagt dir mehr.
- Prüfe für API-Nutzung Kontextgröße, Function Calling, JSON-Modus, deterministische Einstellungen und Preis pro Anfrage.
- Diese API bedient ein Open-Weight-Modell mit einem 100.000-Token-Fenster, Function Calling und JSON-Modus zu $0,15 und $0,50 pro 1 Mio. Token.
- Eine Evaluierungsausführung mit 150 Aufrufen kostet etwa 5 Cent, also ist Messen günstiger als Raten.
Auf dieser Seite
- Warum kein Modell für alle das Beste ist
- Die Kriterien, die für eine API wichtig sind
- Workflow 1: Funktion mit einem strikten Prompt generieren
- Workflow 2: das Modell ausführen und seinen eigenen Code korrigieren
- Workflow 3: Strukturierte Code-Überprüfung mit JSON-Modus
- Modelle an deinen eigenen Aufgaben testen
- Was Coding-Arbeit kostet
- Wann eine andere Wahl besser ist
- Weitere Anleitungen
Warum kein Modell für alle das Beste ist
Python-Programmierung umfasst sehr unterschiedliche Aufgaben. Das Schreiben eines zehn Zeilen langen Hilfsprogramms, das Refaktorisieren eines 2.000-Zeilen-Moduls, das Lesen einer Stack-Ablaufverfolgung, das Generieren von Tests, das Übersetzen eines Shell-Skripts in Python und das Erstellen eines Tools, das Dateien bearbeitet, sind alles Programmieraufgaben, und ein Modell kann in einem Bereich stark und in einem anderen mittelmäßig sein. Leaderboards mitteln über viele Aufgaben und viele Sprachen hinweg. Dein Repository, deine Stilregeln und deine Bibliotheken sind nur ein schmaler Ausschnitt davon.
Die praktische Antwort auf die Frage ist also ein Verfahren. Entscheide, was du brauchst, kürze die Auswahl auf zwei oder drei Modelle, die die technischen Anforderungen erfüllen, führe dieselben Aufgaben durch jedes hindurch und zähle, wie viele deine eigenen Tests bestehen. Der Rest dieses Artikels behandelt die Anforderungen und zeigt dann, wie du die Tests gegen diese API durchführst.
Ein weiterer Punkt vor den Details. Der Dienst hinter dieser Website betreibt ein Open-Weight-Modell, das von einem unabhängigen Anbieter betrieben wird und darauf abgestimmt ist, ohne Inhaltsablehnungen für die rechtmäßige Nutzung durch Erwachsene zu antworten. Es ist nicht die offizielle API eines Modellherstellers, und es gibt hier keine Benchmark-Ansprüche. Betrachte es als einen Kandidaten für deine Shortlist und bewerte es wie jedes andere.
Die Kriterien, die für eine API wichtig sind
Wenn du ein Modell aus Code aufrufst, anstatt damit in einem Editor zu chatten, entscheiden einige technische Eigenschaften darüber, ob es passt.
| Kriterium | Warum es für Python-Aufgaben wichtig ist | Diese API |
|---|---|---|
| Kontextfenster | Ganze Module, lange Tracebacks und Testausgaben müssen mit Platz für die Antwort passen | 100.000 Token, Prompt plus Vervollständigung |
| Function Calling | Ermöglicht dem Modell, Code, Tests und Linter auszuführen und dann auf die Ausgabe zu reagieren | Ja: Tools, tool_choice, gestreamte tool_calls |
| JSON-Modus | Maschinenlesbare Überprüfungen, Linter-Berichte und Refaktorierungspläne | Ja: response_format json_object |
| Reproduzierbarkeit | Niedrigere Temperatur und ein fester Seed machen Testausführungen vergleichbar | Temperatur, top_p, Stop, Seed und Strafen werden durchgereicht |
| Streaming | Responsive Tools und lange Generierungen | SSE mit Nutzungsinformationen am Ende |
| Preis | Agent-Schleifen senden Kontext viele Male erneut | $0,15 Input und $0,50 Output pro 1 Mio. Token |
| Ablehnungen | Security-Tooling, Scraper und Red-Team-Skripte für Systeme, die du besitzt, sind rechtmäßig, werden aber oft abgelehnt | Abgestimmt darauf, ohne Inhaltsablehnungen für legale Erwachsenennutzung zu antworten |
Die Tabelle sagt nichts über die Codequalität aus, da die oben genannten Eigenschaften Fakten sind und Qualität etwas, das du testest. Qualität ändert sich auch mit dem Prompt. Eine Systemnachricht, die die Python-Version, die erlaubten Bibliotheken und das Antwortformat fixiert, ist oft genauso wichtig wie das Modell.
Diese API ist nur Text. Du sendest Code als Text im Prompt und erhältst Text zurück. Es gibt keine Bild-, Audio- oder Videogenerierung, keine Embeddings und kein Fine-Tuning, also muss ein Codesuchsystem, das Embeddings benötigt, diese woanders beziehen.
Workflow 1: Funktion mit einem strikten Prompt generieren
Beginne mit dem einfachsten Fall: Bitte um eine Funktion und extrahiere den Codeblock. Niedrige Temperatur liefert stabile Ausgaben. Die Systemnachricht fixiert die Sprachversion und das Antwortformat, was die Extraktion zu einer einzeiligen Regex macht. Hol dir einen Schlüssel von der Schlüsselseite und exportiere ihn als LLM_API_KEY.
import os
import re
from openai import OpenAI
client = OpenAI(
base_url="https://api.visionllmapi.com/v1",
api_key=os.environ["LLM_API_KEY"],
)
def ask_for_code(task):
resp = client.chat.completions.create(
model="uncensored",
temperature=0.2,
messages=[
{
"role": "system",
"content": (
"You are a senior Python developer. Use Python 3.11, the standard "
"library only unless told otherwise, and type hints. Reply with one "
"fenced python block and at most three sentences of explanation."
),
},
{"role": "user", "content": task},
],
)
text = resp.choices[0].message.content
match = re.search(r"```(?:python)?\n(.*?)```", text, re.S)
return match.group(1) if match else text
print(ask_for_code("Write parse_duration(s) that turns '1h30m' or '45s' into seconds."))
Drei Prompt-Gewohnheiten helfen hier. Nenne die Python-Version, damit das Modell nicht auf Syntax zurückgreift, die du nicht ausführen kannst. Sage „nur Standardbibliothek“, es sei denn, du willst wirklich Pakete von Drittanbietern. Und bitte um eine kurze Antwort, da lange Erklärungen Output-Token kosten und den Code selten verändern. Wenn das Modell nach dem Block weiterhin Text hinzufügt, übergebe eine stop-Sequenz oder entferne alles außerhalb des Blocks, wie es die Regex tut.
Workflow 2: Das Modell ausführen und seinen eigenen Code korrigieren lassen
Der größte Sprung in der Zuverlässigkeit kommt normalerweise vom Tool Calling. Statt nach Code zu fragen und zu hoffen, gibst du dem Modell eine Funktion, die ein Skript ausführt und die Ausgabe zurückgibt. Es schreibt Code, führt ihn aus, liest den Traceback und korrigiert sich selbst. Tool-Ergebnisse gehen als Nachrichten mit role: "tool" zurück, abgeglichen über tool_call_id.
import json
import os
import subprocess
import sys
import tempfile
from openai import OpenAI
client = OpenAI(
base_url="https://api.visionllmapi.com/v1",
api_key=os.environ["LLM_API_KEY"],
)
def run_python(code):
with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as f:
f.write(code)
try:
r = subprocess.run([sys.executable, f.name], capture_output=True, text=True, timeout=10)
return (r.stdout + r.stderr)[-3000:] or "(no output)"
except subprocess.TimeoutExpired:
return "timeout after 10 seconds"
tools = [{
"type": "function",
"function": {
"name": "run_python",
"description": "Run a Python script and return stdout and stderr.",
"parameters": {
"type": "object",
"properties": {"code": {"type": "string"}},
"required": ["code"],
},
},
}]
messages = [
{"role": "system", "content": "You write Python 3. Test your code with run_python before the final answer."},
{"role": "user", "content": "Write parse_duration(s) for strings like '1h30m' or '45s'. Include asserts."},
]
for _ in range(5):
resp = client.chat.completions.create(
model="uncensored",
messages=messages,
tools=tools,
tool_choice="auto",
temperature=0.2,
)
msg = resp.choices[0].message
messages.append(msg.model_dump(exclude_none=True))
if not msg.tool_calls:
print(msg.content)
break
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": run_python(args["code"]),
})
Behandle die run_python-Funktion mit Sorgfalt. Sie führt Code aus, den das Modell geschrieben hat, auf deinem Rechner, mit deinen Berechtigungen. Für alles, was über ein Wegwerfexperiment hinausgeht, führe es in einem Container oder einer Disposable VM aus, ohne Netzwerk, mit einer Zeitbegrenzung und ohne Zugriff auf deine Anmeldeinformationen. Die zehn Sekunden Timeout und die beschnittene Ausgabe im Beispiel sind das Minimum.
Die Schleife ist auf fünf Runden begrenzt, damit ein verwirrtes Modell nicht endlos dreht. In der Praxis benötigen die meisten einfachen Funktionen ein oder zwei Durchläufe. Wenn du siehst, dass das Modell denselben fehlgeschlagenen Aufruf wiederholt, füge den Traceback in Worten zur nächsten Benutzernachricht hinzu oder senke die Temperatur. Beachte, dass eine gestreamte Function-Calling-Anfrage ihren Concurrency-Slot hält, bis der Stream endet, und ein vollständiger Schlüssel 8 gleichzeitige Anfragen erlaubt, also sollte ein Team, das einen Schlüssel teilt, Agent-Ausführungen in eine Warteschlange stellen.
Workflow 3: Strukturierte Code-Überprüfung mit JSON-Modus
Überprüfungen sind nützlich, wenn ein Skript sie lesen kann. JSON-Modus erzwingt gültiges JSON, und die Systemnachricht definiert die Form. Mit temperature 0 und einem festen seed erzeugt dieselbe Datei bei wiederholten Durchläufen dieselbe Überprüfung, was Diffs zwischen Durchläufen sinnvoll macht.
import json
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.visionllmapi.com/v1",
api_key=os.environ["LLM_API_KEY"],
)
source = open("service.py").read()
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
temperature=0,
seed=7,
messages=[
{
"role": "system",
"content": (
"Review the Python file. Reply with a JSON object with the key issues, "
"a list of objects with keys line, severity (low, medium or high), "
"problem and fix. Return an empty list if you find nothing."
),
},
{"role": "user", "content": source},
],
)
for issue in json.loads(resp.choices[0].message.content)["issues"]:
print(issue["severity"], issue["line"], issue["problem"])
Verwende dies aus einem Pre-Commit-Hook oder einem CI-Schritt und gib das Ergebnis als Annotationen aus. Erwarte falsch positive und falsch negative Ergebnisse. Ein Modellprüfer ist ein zweites Paar Augen, das schnell und nie müde ist, aber es ersetzt keine Tests, einen Typenprüfer oder einen Linter. Führe diese zuerst aus und nutze das Modell für das, was sie nicht sehen können, wie unklare Benennungen, fehlende Randfälle und Fehlerbehandlung, die Ausnahmen verschluckt.
Das Fenster von 100.000 Token ermöglicht ganze Dateien und manchmal kleine Pakete in einer einzigen Anfrage. Die Körpergrenze beträgt 8 MB, was du mit Quellcode nicht erreichen wirst. Wenn eine Überprüfung abgeschnitten wird, prüfe, ob du max_tokens zu niedrig gesetzt hast; der Parameter ist optional und eine Vervollständigung kann den Rest des Fensters nutzen.
Modelle an deinen eigenen Aufgaben testen
Hier ist ein kleines Test-Setup, das das macht, was ein Leaderboard nicht kann: Es führt deine Aufgaben gegen deine Tests aus. Jede Aufgabe enthält einen Prompt und einen Test-Snippet. Das Skript fragt das Modell mehrmals nach Code, hängt den Test an den Code an, führt das Ergebnis aus und zählt die Erfolge. Ändere die Base URL und den Modellnamen, um einen anderen Anbieter auf die gleiche Weise zu vergleichen.
import os
import re
import subprocess
import sys
import tempfile
from openai import OpenAI
client = OpenAI(
base_url="https://api.visionllmapi.com/v1",
api_key=os.environ["LLM_API_KEY"],
)
TASKS = [
{
"prompt": "Write is_palindrome(s) that ignores case and non-alphanumeric characters.",
"test": "assert is_palindrome('A man, a plan, a canal: Panama')\nassert not is_palindrome('abc')",
},
{
"prompt": "Write chunk(items, n) that yields lists of at most n items.",
"test": "assert list(chunk([1,2,3,4,5], 2)) == [[1,2],[3,4],[5]]",
},
]
SAMPLES = 3
def extract(text):
m = re.search(r"```(?:python)?\n(.*?)```", text, re.S)
return m.group(1) if m else text
def passes(code, test):
with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as f:
f.write(code + "\n\n" + test + "\n")
try:
r = subprocess.run([sys.executable, f.name], capture_output=True, timeout=10)
return r.returncode == 0
except subprocess.TimeoutExpired:
return False
total = ok = 0
for task in TASKS:
for _ in range(SAMPLES):
resp = client.chat.completions.create(
model="uncensored",
temperature=0.4,
messages=[
{"role": "system", "content": "Reply with one fenced python block and nothing else."},
{"role": "user", "content": task["prompt"]},
],
)
total += 1
ok += passes(extract(resp.choices[0].message.content), task["test"])
print(f"{ok}/{total} passed")
Erweitere die Aufgabenliste auf 30 oder 50 Einträge aus der echten Arbeit: einen Bug, den du letzten Monat behoben hast, einen Parser, den du geschrieben hast, eine Funktion mit einem sperrigen Sonderfall. Füge Aufgaben hinzu, bei denen andere Tools abgelehnt oder gezögert haben. Führe jede Aufgabe drei bis fünf Mal aus, denn eine einzelne Probe sagt wenig aus. Notiere die Erfolgsquote, die durchschnittliche Ausgabelänge und die Kosten pro Aufgabe, und bewahre die Ergebnisse in einer Datei auf, damit du sie nach Änderungen an den Prompts erneut ausführen kannst. Führe generierten Code in einer Sandbox aus, wie oben erwähnt.
Schau dir die Fehler an, nicht nur den Prozentsatz. Wenn die meisten Fehler von einer Bibliothek stammen, füge einen Hinweis in die Systemnachricht ein. Wenn sie vom Modell erdachte Funktionsnamen stammen, gib ihm die relevanten Signaturen im Prompt. Wenn sie von langen Eingaben stammen, teste einen kürzeren Prompt, bevor du das Modell beschuldigst.
Was Coding-Arbeit kostet
Die Preise betragen $0,15 pro 1 Mio. Input-Token und $0,50 pro 1 Mio. Output-Token, und fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet. Drei Beispiele mit der Mathematik:
- Evaluierungsausführung. 50 Aufgaben x 3 Stichproben sind 150 Aufrufe. Bei 400 Input und 600 Output Token pro Aufruf sind Input 60.000 Token ($0,009) und Output 90.000 Token ($0,045). Gesamt: $0,054.
- Dateiüberprüfung. Eine Datei mit etwa 600 Zeilen ist ungefähr 8.000 Token, mit einer 1.200-Token-Überprüfung. Input kostet $0,0012, Output kostet $0,0006, insgesamt $0,0018. Fünfhundert Überprüfungen kosten $0,90.
- Agent-Schleife. Eine Fixierung mit sechs Runden, die insgesamt 18.000 Input-Token sendet und 1.500 Output-Token empfängt, kostet $0,0027 plus $0,00075, also $0,00345.
Agent-Schleifen dominieren, weil jede Runde die wachsende Konversation erneut sendet. Schneide Tool-Ausgaben zurück, wie das Beispiel zeigt, und du kontrollierst den Großteil der Rechnung. Aufladungen sind in jedem ganzen Betrag von $20 bis $500 möglich, mit +5% ab $50, +10% ab $100 und +15% ab $200, bezahlt in USDT auf TRC20 oder USDC auf Base, wobei das Guthaben nie verfällt. Siehe Preise. Neue Konten können auch $0,50 an kostenlosem Testguthaben mit einem Klick beanspruchen, das ein paar Evaluierungsläufe finanziert. Ein Test-Schlüssel erlaubt 2 parallele Anfragen und 60 pro Minute.
Wenn eine andere Wahl besser ist
Sei ehrlich bezüglich der Grenzen eines einzelnen Endpunkts. Wenn du ein Editor-Plugin mit Inline-Vervollständigung, einen von einem Anbieter entwickelten Coding-Agenten oder eine enge Integration mit den Tools einer bestimmten Cloud möchtest, könnte ein dafür entwickeltes Produkt besser zu dir passen, und du solltest deren aktuelle Preise und Nutzungsbedingungen prüfen. Wenn dein Code niemals eine Ablehnung auslöst, bietet dir das Ablehnungsverhalten dieses Modells keinen Vorteil, und deine Testergebnisse sollten entscheiden. Wenn du Embeddings oder Bild-Eingaben benötigst, brauchst du für diese Teile einen anderen Dienst. Diese API ist eine gute Wahl, wenn du einen einfachen OpenAI-kompatiblen Endpunkt möchtest, den du aus Skripten und Tools heraus aufrufen kannst, mit einem großen Kontextfenster, Function Calling und einem niedrigen Preis. Die API-Dokumentation listet den vollständigen Parametersatz auf.
Weitere Anleitungen
Fragen und Antworten
Ist dies das richtige Modell für Python-Entwicklung?
Kein einzelnes Modell ist für jede Aufgabe am besten. Diese API bietet ein Open-Weight-Modell mit Function Calling, JSON-Modus und einem 100.000-Token-Kontextfenster, und das obige Framework ermöglicht es dir, es gegen deine eigenen Tests zu messen.
Kann das Modell meinen Python-Code ausführen?
Nicht von selbst. Du definierst ein Tool, z. B. run_python, und dein Code führt es aus und gibt die Ausgabe als Tool-Nachricht zurück. Führe es in einer Sandbox aus.
Wie groß ist ein Codebase, das in eine Anfrage passt?
Das Kontextfenster umfasst 100.000 Token für Prompt plus Antwort. Das deckt viele Dateien gleichzeitig ab, aber nicht ein gesamtes großes Repository.
Funktioniert es mit dem OpenAI Python-Paket?
Ja. Setze base_url auf die API-URL, übergebe deinen Schlüssel und verwende die Modell-ID uncensored.
Wie viel kostet ein Testlauf?
Ein Lauf mit 150 Coding-Aufrufen zu je 400 Input- und 600 Output-Token kostet etwa $0,054.
Dein Schlüssel ist nur ein Formular entfernt
Erstelle ein Konto, kopiere den Schlüssel, ändere die Basis-URL. Das ist die gesamte Einrichtung.
Basis-URLhttps://api.visionllmapi.com/v1