Python
Das ChatGPT-API meistern: Ein Leitfaden für Python-Anfänger

Das ChatGPT-API meistern: Ein Leitfaden für Python-Anfänger

MoeNagy Dev

Verständnis des ChatGPT-API

Was ist die ChatGPT-API?

Die ChatGPT-API ist ein leistungsfähiges Natural Language Processing (NLP)-Tool, das von Anthropic, einem führenden AI-Forschungsunternehmen, entwickelt wurde. Sie basiert auf dem GPT (Generative Pre-trained Transformer) Sprachmodell, das auf einer großen Menge an Textdaten trainiert wurde, um menschenähnliche Antworten auf eine Vielzahl von Anfragen zu generieren.

Die ChatGPT-API ermöglicht Entwicklern, die Fähigkeiten des ChatGPT-Modells in ihre eigenen Anwendungen zu integrieren, so dass sie intelligente Chatbots, Content-Generierungstools und andere NLP-gesteuerte Funktionen entwickeln können.

Hauptmerkmale und Fähigkeiten der API

Die ChatGPT-API bietet eine Reihe leistungsstarker Funktionen und Fähigkeiten, darunter:

  • Textgenerierung: Generieren von kohärentem, kontextbewusstem Text auf Basis von Benutzeranfragen, um Anwendungen wie Chatbots, Content-Erstellungstools und Sprachassistenten zu ermöglichen.
  • Konversationsverwaltung: Beibehaltung des Kontexts und Zustands über mehrere Nachrichten hinweg für natürlichere und ansprechendere Konversationen.
  • Anpassbare Modelle: Anpassung der Modellparameter wie Temperatur und Ausgabelänge, um den generierten Text an Ihre spezifischen Bedürfnisse anzupassen.
  • Mehrsprachige Unterstützung: Die API unterstützt eine Vielzahl von Sprachen, so dass Sie Anwendungen erstellen können, die in mehreren Sprachen kommunizieren können.
  • Skalierbarkeit: Die API ist darauf ausgelegt, hohe Anfragevolumina zu bewältigen, so dass sie für Anwendungen und Bereitstellungen im großen Maßstab geeignet ist.

Registrierung für einen Anthropic-API-Schlüssel

Um die ChatGPT-API nutzen zu können, müssen Sie sich für einen Anthropic-API-Schlüssel registrieren. Hier ist, wie Sie das tun können:

  1. Gehen Sie zur Anthropic-Website (https://www.anthropic.com/ (opens in a new tab)) und klicken Sie auf die Schaltfläche "API-Schlüssel erhalten".
  2. Folgen Sie den Anweisungen, um ein Anthropic-Konto zu erstellen, falls Sie noch keines haben.
  3. Sobald Sie ein Konto erstellt haben, können Sie Ihren API-Schlüssel generieren, indem Sie zum Abschnitt "API-Schlüssel" der Anthropic-Konsole navigieren.
  4. Kopieren Sie den API-Schlüssel und speichern Sie ihn sicher, da Sie ihn benötigen, um Ihre API-Anfragen zu authentifizieren.

Einrichten Ihrer Python-Umgebung

Installation der erforderlichen Python-Bibliotheken

Um mit der ChatGPT-API mit Python zu interagieren, müssen Sie die folgenden Bibliotheken installieren:

  • "requests": Eine beliebte Bibliothek zum Senden von HTTP-Anfragen in Python.
  • "openai": Eine Python-Clientbibliothek für die OpenAI-API, die auch die ChatGPT-API unterstützt.

Sie können diese Bibliotheken mit pip, dem Python-Paketmanager, installieren. Öffnen Sie Ihr Terminal oder die Kommandozeile und führen Sie die folgenden Befehle aus:

pip install requests
pip install openai

Konfigurieren Ihres API-Schlüssels

Sobald Sie Ihren Anthropic-API-Schlüssel haben, müssen Sie ihn in Ihrer Python-Umgebung konfigurieren. Hier ist, wie Sie das tun können:

  1. Öffnen Sie eine neue Python-Datei in Ihrem bevorzugten Code-Editor.
  2. Importieren Sie die Bibliothek "openai":
import openai
  1. Setzen Sie Ihren API-Schlüssel mit dem Attribut "openai.api_key":
openai.api_key = "your_api_key_here"

Ersetzen Sie "your_api_key_here" durch den tatsächlichen API-Schlüssel, den Sie aus der Anthropic-Konsole erhalten haben.

Jetzt ist Ihre Python-Umgebung eingerichtet und bereit, mit der ChatGPT-API zu interagieren.

Senden von Anfragen an die ChatGPT-API

Erstellen der API-Anfrage

Um eine Anfrage an die ChatGPT-API zu senden, verwenden Sie die Funktion "openai.Completion.create()", die von der Bibliothek "openai" bereitgestellt wird. Hier ist ein Beispiel:

import openai
 
openai.api_key = "your_api_key_here"
 
prompt = "What is the capital of France?"
response = openai.Completion.create(
    engine="text-davinci-003",
    prompt=prompt,
    max_tokens=50,
    n=1,
    stop=None,
    temperature=0.7,
)

In diesem Beispiel:

  1. Wird der API-Schlüssel gesetzt.
  2. Wird der Prompt definiert, der den Text enthält, für den die API eine Antwort generieren soll.
  3. Wird die Funktion "openai.Completion.create()" aufgerufen und die folgenden Parameter übergeben:
    • "engine": Das spezifische Modell, das für die Textgenerierung verwendet werden soll (in diesem Fall "text-davinci-003").
    • "prompt": Der Eingabetext, für den das Modell eine Antwort generieren soll.
    • "max_tokens": Die maximale Anzahl von Tokens (Wörter), die in der Antwort generiert werden sollen.
    • "n": Die Anzahl der zu generierenden Ergänzungen.
    • "stop": Die Abbruchsequenz (falls vorhanden), mit der der generierte Text beendet werden soll.
    • "temperature": Ein Wert zwischen 0 und 1, der die "Kreativität" des generierten Textes steuert, wobei niedrigere Werte zu konservativerem, vorhersehbarem Text führen.

Verarbeiten der API-Antwort

Die Funktion "openai.Completion.create()" gibt ein objektähnliches Dictionary-Objekt zurück, das den generierten Text und andere Metadaten enthält. Sie können auf den generierten Text wie folgt zugreifen:

generated_text = response.choices[0].text.strip()
print(generated_text)

Dies gibt den generierten Text aus, der in diesem Fall "Die Hauptstadt von Frankreich ist Paris." sein sollte.

Verarbeiten der API-Antwortdaten

Das Antwortobjekt der Funktion "openai.Completion.create()" enthält zusätzliche Informationen, die Sie verwenden können, wie z.B. das verwendete Modell, die Anzahl der generierten Token und die Bearbeitungszeit. Hier ist ein Beispiel, wie Sie auf diese Daten zugreifen können:

print(f"Modell: {response.model}")
print(f"Generierte Tokens: {response.usage.total_tokens}")
print(f"Ausführungsdauer: {response.response_time:.2f} Sekunden")

Dies gibt etwas ähnliches wie folgt aus:

Modell: text-davinci-003
Generierte Tokens: 14
Ausführungsdauer: 0.45 Sekunden

Textgenerierung mit der ChatGPT-API

Festlegen des Prompts für die Textgenerierung

Das ist die Eingabetext, den die ChatGPT-API verwendet, um den Ausgabetext zu generieren. Die Eingabe kann eine Frage, eine Aussage oder eine andere Form von Text sein, auf die Sie möchten, dass die API antwortet. Hier ist ein Beispiel für eine komplexere Eingabe:

prompt = """
Schreibe eine kurze Geschichte über einen Zeitreisenden, der in der Vergangenheit gestrandet ist. Die Geschichte sollte etwa 100 Wörter lang sein und einen überraschenden Schluss haben.
"""
 
antwort = openai.Completion.create(
    engine="text-davinci-003",
    prompt=prompt,
    max_tokens=100,
    n=1,
    stop=None,
    temperature=0.7,
)
 
generierter_text = antwort.choices[0].text.strip()
print(generierter_text)

Diese Eingabe fordert die ChatGPT-API auf, eine kurze Geschichte mit einer bestimmten Länge und einem überraschenden Schluss zu generieren. Der generierte Text sollte etwa 100 Wörter lang sein.

Steuerung der Ausgabelänge und Temperatur

Sie können die Länge und Kreativität des generierten Textes steuern, indem Sie die Parameter max_tokens und temperature in der Funktion openai.Completion.create() anpassen.

  • max_tokens: Dieser Parameter legt die maximale Anzahl der zu generierenden Tokens (Wörter) in der Antwort fest. Eine Erhöhung dieses Werts führt zu längeren Antworten, eine Verringerung führt zu kürzeren Antworten.
  • temperature: Dieser Parameter steuert die "Kreativität" des generierten Textes. Eine niedrigere Temperatur (z. B. 0,5) führt zu konservativerem, vorhersehbarem Text, während eine höhere Temperatur (z. B. 1,0) zu vielfältigerem und kreativerem Text führt.

Hier ist ein Beispiel, wie Sie diese Parameter anpassen können:

# Generiere eine längere Antwort mit kreativerem Text
antwort = openai.Completion.create(
    engine="text-davinci-003",
    prompt=prompt,
    max_tokens=200,
    n=1,
    stop=None,
    temperature=0.9,
)
 
# Generiere eine kürzere Antwort mit konservativerem Text
antwort = openai.Completion.create(
    engine="text-davinci-003",
    prompt=prompt,
    max_tokens=50,
    n=1,
    stop=None,
    temperature=0.5,
)

Verarbeiten des generierten Textes

Sobald Sie den generierten Text haben, können Sie ihn nach Bedarf in Ihrer Anwendung verwenden. Sie könnten den Text zum Beispiel in einer Chatbot-Oberfläche anzeigen, ihn zur Generierung von Inhalten für eine Website oder einen Blog verwenden oder ihn in eine größere Textverarbeitungspipeline einbinden.

Hier ist ein Beispiel, wie Sie den generierten Text verarbeiten können:

generierter_text = antwort.choices[0].text.strip()
print(f"Generierter Text:\n{generierter_text}")

Dies druckt den generierten Text in der Konsole aus. Sie können auch zusätzliche Verarbeitung am Text durchführen, z. B. Bereinigen, Sentiment-Analyse oder Extrahieren bestimmter Informationen aus dem Text.

Variablen und Datentypen

Variablen

Variablen werden verwendet, um Daten in Python zu speichern. Es sind benannte Container, die Werte enthalten. Sie können einer Variablen mit dem Zuweisungsoperator = einen Wert zuweisen. Hier ist ein Beispiel:

name = "John Doe"
alter = 35

In obigem Beispiel haben wir zwei Variablen erstellt: name und alter. Die Variable name wird der Zeichenkette "John Doe" zugewiesen und die Variable alter wird dem Ganzzahlwert 35 zugewiesen.

Sie können auch denselben Wert gleichzeitig mehreren Variablen zuweisen:

x = y = z = 42

In diesem Fall werden alle drei Variablen x, y und z derselbe Wert 42 zugewiesen.

Datentypen

Python hat mehrere integrierte Datentypen, einschließlich:

  1. Numerische Typen: int (ganze Zahlen), float (Fließkommazahlen), complex (komplexe Zahlen)
  2. Texttyp: str (Zeichenketten)
  3. Boolescher Typ: bool (Wahr oder Falsch)
  4. Sequenztypen: list, tuple, range
  5. Mapping Typ: dict (Wörterbücher)
  6. Mengentypen: set, frozenset

Sie können den Datentyp einer Variable mit der Funktion type() überprüfen:

print(type(42))       # Ausgabe: <class 'int'>
print(type(3.14))     # Ausgabe: <class 'float'>
print(type("Hallo"))  # Ausgabe: <class 'str'>
print(type(True))     # Ausgabe: <class 'bool'>

Typumwandlung

Sie können zwischen verschiedenen Datentypen mit Typumwandlungsfunktionen konvertieren:

# Umwandlung in ganzzahligen Wert
x = int(3.14)    # x ist jetzt 3
 
# Umwandlung in Fließkommazahl
y = float(42)    # y ist jetzt 42.0
 
# Umwandlung in Zeichenkette
z = str(True)    # z ist jetzt "True"

Zeichenketten

Zeichenketten in Python sind Sequenzen von Zeichen. Sie können Zeichenketten mit einfachen Anführungszeichen ', doppelten Anführungszeichen " oder dreifachen Anführungszeichen ''' oder """ erstellen. Hier sind einige Beispiele:

nachricht = "Hallo Welt!"
name = 'John Doe'
mehrzeilige_zeichenkette = """Dies ist eine
mehrzeilige
Zeichenkette."""

Sie können auf einzelne Zeichen in einer Zeichenkette mit Indexierung zugreifen. Die Indizierung beginnt bei 0 für das erste Zeichen.

print(nachricht[0])    # Ausgabe: H
print(name[-1])      # Ausgabe: e

Zeichenketten unterstützen eine Vielzahl von Operationen und Methoden wie Konkatenation, Slicing und Formatierung.

vollständiger_name = name + " Jr."
gruß = f"Hallo, {name}!"
upper_name = name.upper()

Zahlen

Python unterstützt drei numerische Datentypen: int, float und complex. Hier sind einige Beispiele:

# Ganzzahlen
alter = 35
bevölkerung = 7_900_000_000
 
# Fließkommazahlen
pi = 3.14159
temperatur = -4.5
 
# Komplexe Zahlen
komplexe_num = 2 + 3j

Sie können verschiedene arithmetische Operationen mit Zahlen durchführen, wie Addition, Subtraktion, Multiplikation, Division und mehr.

ergebnis = 10 + 5    # Addition
differenz = 20 - 8    # Subtraktion
produkt = 4 * 6    # Multiplikation
quotient = 15 / 3    # Division

Boolesche Werte

Der Datentyp bool stellt boolesche Werte dar, die entweder True oder False sein können. Booleans werden häufig in bedingten Anweisungen und logischen Operationen verwendet.

ist_student = True
hat_abschluss = False
 
if ist_student and not hat_abschluss:
    print("Die Person ist ein Student.")
else:
    print("Die Person ist kein Student.")

Steuerfluss

Bedingte Anweisungen

Bedingte Anweisungen in Python ermöglichen es Ihnen, verschiedene Codeblöcke basierend auf bestimmten Bedingungen auszuführen. Die häufigste bedingte Anweisung ist die if-elif-else Anweisung.

age = 25
if age < 18:
    print("Du bist minderjährig.")
elif age >= 18 and age < 65:
    print("Du bist erwachsen.")
else:
    print("Du bist Senior.")

Sie können auch den ternären Operator verwenden, der eine verkürzte Schreibweise einer einfachen if-else Anweisung ist.

score = 85
result = "Bestanden" if score >= 60 else "Durchgefallen"
print(result)  # Ausgabe: Bestanden

Schleifen

Schleifen in Python ermöglichen es Ihnen, einen Codeblock wiederholt auszuführen. Die beiden häufigsten Schleifentypen sind for Schleifen und while Schleifen.

# For-Schleife
fruits = ["Apfel", "Banane", "Kirsche"]
for fruit in fruits:
    print(fruit)
 
# While-Schleife
count = 0
while count < 5:
    print(count)
    count += 1

Sie können auch die Anweisungen break und continue verwenden, um den Ablauf von Schleifen zu steuern.

# Mit break
for number in range(1, 11):
    if number == 5:
        break
    print(number)
 
# Mit continue
for number in range(1, 11):
    if number % 2 == 0:
        continue
    print(number)

Funktionen

Funktionen in Python sind wiederverwendbare Codeblöcke, die eine bestimmte Aufgabe ausführen. Sie können eigene Funktionen mit dem Schlüsselwort def definieren.

def greet(name):
    """Gibt eine Begrüßungsnachricht aus."""
    print(f"Hallo, {name}!")
 
greet("John")  # Ausgabe: Hallo, John!

Funktionen können auch Werte mit dem return-Schlüsselwort zurückgeben.

def add_numbers(a, b):
    """Gibt die Summe zweier Zahlen zurück."""
    return a + b
 
result = add_numbers(5, 3)
print(result)  # Ausgabe: 8

Sie können auch Standardparameterwerte definieren und variable Argumente verwenden.

def print_info(name, age=30):
    """Gibt Name und Alter aus."""
    print(f"{name} ist {age} Jahre alt.")
 
print_info("Alice")  # Ausgabe: Alice ist 30 Jahre alt.
print_info("Bob", 25)  # Ausgabe: Bob ist 25 Jahre alt.

Module und Pakete

Module

Module in Python sind Dateien, die Python-Code enthalten, einschließlich Variablen, Funktionen und Klassen. Sie können Module mit der import Anweisung importieren.

import math
print(math.pi)  # Ausgabe: 3.141592653589793

Sie können auch bestimmte Elemente aus einem Modul mit dem from Schlüsselwort importieren.

from math import sqrt
print(sqrt(16))  # Ausgabe: 4.0

Pakete

Pakete in Python sind Sammlungen von Modulen. Sie sind in einer hierarchischen Struktur organisiert, wobei jedes Paket ein oder mehrere Module enthält.

import os.path
print(os.path.join("documents", "file.txt"))  # Ausgabe: documents/file.txt

Sie können auch bestimmte Elemente aus einem Paket mit dem from Schlüsselwort importieren.

from os.path import join
print(join("documents", "file.txt"))  # Ausgabe: documents/file.txt

Fazit

In diesem Tutorial haben wir eine Vielzahl von Themen in Python behandelt, einschließlich Variablen und Datentypen, Kontrollstrukturen, Funktionen sowie Module und Pakete. Wir haben zahlreiche Beispiele und Code-Snippets bereitgestellt, um Ihnen die Konzepte besser zu erklären.

Python ist eine vielseitige und leistungsstarke Programmiersprache, die für eine Vielzahl von Aufgaben verwendet werden kann, von der Webentwicklung über die Datenanalyse bis hin zum maschinellen Lernen. Mit der Beherrschung der in diesem Tutorial behandelten Grundlagen sind Sie auf dem besten Weg, ein versierter Python-Programmierer zu werden.

Denken Sie daran, dass der beste Weg, Ihre Python-Kenntnisse zu verbessern, darin besteht, zu üben, zu experimentieren und weiter zu lernen. Es gibt viele Online-Ressourcen, Tutorials und Communitys, die Ihnen auf Ihrem Weg helfen können. Viel Spaß beim Programmieren!

MoeNagy Dev