Die Erstellung von Agenten ist einfacher als je zuvor, aber haben Sie jemals darüber nachgedacht, wie wir sie leistungsfähiger machen können, als sie bereits sind? Kürzlich habe ich über einen möglichen Weg nachgedacht: Was wäre, wenn sie Echtzeitinformationen über bestimmte Kategorien wie Finanzen und Filme hätten? Das wäre wirklich cool, oder? Als ich diese Possibility untersuchte, fand ich RapidAPI als Drehscheibe APIs Dies kann KI-Agenten mit einem einfachen API-Aufruf Zugriff auf Echtzeitinformationen ermöglichen. Ich habe dann beschlossen, ein paar Agenten zu entwickeln, die diese APIs nutzen können, um bessere Rollenspielagenten zu entwickeln.

In diesem Artikel teile ich den gesamten Prozess, damit Sie ihn leicht verfolgen und die Ergebnisse für Ihren eigenen Gebrauch reproduzieren können. Beginnen wir mit einigen grundlegenden Informationen –

Was ist RapidAPI?

RapidAPI ist eigentlich der ältere Title und wurde nach der Übernahme kürzlich zu Nokia API Hub. Es verfügt über einen API-Katalog, in dem wir APIs verwenden oder veröffentlichen können. Es deckt verschiedene Kategorien ab CybersicherheitFilme, Kommunikation und mehr. Du kannst Erfahren Sie hier mehr über RapidAPI.

Wie verwende ich die APIs von RapidAPI?

1. Erste Anmeldung/Registrierung bei RapidAPI hier

2. Gehen Sie zu a Entwicklerautorisierungsseite und erstellen Sie eine Autorisierung vom Typ „RapidAPI“, indem Sie rechts oben auf „Autorisierung hinzufügen“ klicken.

3. Gehen Sie zurück zur Startseite, um APIs zu entdecken, und klicken Sie auf eine beliebige API. Ich zum Beispiel Ich habe hier auf eine Nachrichten-API für Kryptowährungen geklickt.

4. Sie würden eine Seite wie diese sehen, außerdem ist der API-Schlüssel bereits im Testcode vorhanden. Stellen Sie einfach sicher, dass das Ziel auf „Python‚:

5. Klicken Sie nun rechts oben auf „Zum Testen abonnieren“ und wählen Sie vorerst die kostenlose Model aus. Klicken Sie dann auf „Abonnieren“, nachdem Sie auf „Kostenlosen Plan starten“ geklickt haben.

6. Jetzt können Sie die Schaltfläche „Testendpunkt“ rechts oben verwenden. Der Testcode wird ausgeführt und Sie können die Antwort erhalten.

Notiz: Die meisten APIs verfügen über ein großzügiges kostenloses Kontingent und können bis zu den genannten monatlichen Limits genutzt werden.

Integration von Agenten in RapidAPI

In diesem Abschnitt erstellen wir Agenten mithilfe der Funktion „create_agent“ von langchain.brokers und die Agenten werden von unterstützt OpenAIinsbesondere das „gpt-5-mini“. Experimentieren Sie ruhig mit verschiedenen Modellen, Modellanbietern oder Agenten-Frameworks.

Voraussetzung

Um Wiederholungen zu vermeiden, verwenden wir denselben Importsatz und initialisieren die APIs, um sie für mehrere Agenten zu verwenden. Und abonnieren Sie unbedingt die APIs in den Hyperlinks, wenn Sie gemeinsam mit mir testen möchten. Außerdem werde ich Google Colab für die Demo verwenden.

Abonnieren Sie diese APIs

Konfigurieren Sie Ihr Google Colab-Notizbuch

Fügen Sie Ihre OpenAI-API und RapidAPI als „OPENAI_API_KEY“ und „RAPIDAPI_KEY“ im Abschnitt „Geheimnisse“ auf der linken Seite hinzu und vergessen Sie nicht, den Pocket book-Zugriff zu aktivieren.

Installationen

!pip set up langchain langchain_core langchain_openai -q 

Importe

from google.colab import userdata 
import os 
import http.shopper 
import json 
from langchain_core.instruments import instrument 
from langchain_openai import ChatOpenAI 
from langchain.brokers import create_agent

API-Schlüssel

os.environ('OPENAI_API_KEY') = userdata.get('OPENAI_API_KEY') 
RAPIDAPI_KEY = userdata.get('RAPIDAPI_KEY') 

Aufbau eines Nachrichtenagenten

@instrument
def search_news(question: str, restrict: int = 10) -> str:
    """Seek for real-time information articles based mostly on a question. Returns newest information articles."""
    conn = http.shopper.HTTPSConnection("real-time-news-data.p.rapidapi.com")

    headers = {
        "x-rapidapi-key": RAPIDAPI_KEY,
        "x-rapidapi-host": "real-time-news-data.p.rapidapi.com",
    }

    conn.request(
        "GET",
        f"/search?question={question}&restrict={restrict}&time_published=anytime&nation=US&lang=en",
        headers=headers,
    )

    res = conn.getresponse()
    information = res.learn()
    end result = json.hundreds(information.decode("utf-8"))

    return json.dumps(end result, indent=2)

news_agent = create_agent(
    ChatOpenAI(temperature=0, mannequin="gpt-5-mini"),
    instruments=(search_news),
)

Beachten Sie, dass wir die von RapidAPI bereitgestellte API als Software verwenden und das Software an den Agenten übergeben. Der Agent nimmt die Hilfe des Instruments in Anspruch, wenn er der Meinung ist, dass ein Software-Aufruf erforderlich ist.

# Check the agent 
end result = news_agent.invoke({ 
 "messages": ({"function": "consumer", "content material": "Seek for newest information about Messi"}) 

}) 
print(end result("messages")(-1).content material)

Ergebnis

Großartig! Wir haben unseren ersten Agenten gemacht und er sieht intestine aus. Wenn Sie möchten, können Sie mit neuen Eingabeaufforderungen experimentieren.

Notiz: Unser Agent arbeitet meistens mit nur einem Wort, wenn er etwas gefragt wird (Beispiel: „Sport“, „Wald“ usw.). Dies liegt daran, dass das Software nur eine einzelne Zeichenfolge und keinen Satz akzeptiert. Um dies zu beheben, können wir die Systemaufforderung unseres Agenten konfigurieren.

Aktienagent

Erstellen wir einen Inventory Agent, der verwendet Yahoos API um die Aktiendetails mithilfe eines Börsentickersymbols einer bestimmten Aktie abzurufen.

Code

@instrument
def get_stock_history(image: str, interval: str = "1m", restrict: int = 640) -> str:
    """Get historic inventory value information for an emblem."""
    conn = http.shopper.HTTPSConnection("yahoo-finance15.p.rapidapi.com")

    headers = {
        "x-rapidapi-key": RAPIDAPI_KEY,
        "x-rapidapi-host": "yahoo-finance15.p.rapidapi.com",
    }

    path = (
        f"/api/v2/markets/inventory/historical past?"
        f"image={image}&interval={interval}&restrict={restrict}"
    )

    conn.request("GET", path, headers=headers)
    res = conn.getresponse()
    information = res.learn()
    end result = json.hundreds(information.decode("utf-8"))

    return json.dumps(end result, indent=2)


stock_agent = create_agent(
    ChatOpenAI(temperature=0, mannequin="gpt-5-mini"),
    instruments=(get_stock_history),
)

# Instance name
end result = stock_agent.invoke(
    {"messages": ({"function": "consumer", "content material": "Get the final intraday value historical past for AAPL"})}
)

print(end result("messages")(-1).content material)

Ergebnis

Großartig, wir haben die Ausgabe für AAPL (Apple Inc.) erfolgreich abgerufen und die Informationen erfolgen vollständig in Echtzeit.

Immobilienmakler

Das Ziel besteht hier darin, mithilfe einer API einen Agenten zu erstellen, der nach Immobilien zum Verkauf/zur Miete sucht. Die API, die wir von Zoopla verwenden, durchsucht die Immobilien speziell in Großbritannien.

Code

@instrument
def search_properties(
    location_value: str,
    location_identifier: str = "metropolis",
    web page: int = 1,
) -> str:
    """
    Seek for residential properties.

    Args:
        location_value: The title of the placement
            (e.g., 'London', 'Manchester', 'E1 6AN').
        location_identifier: The class of the placement.
            - Use 'metropolis' for main cities (default).
            - Use 'postal_code' if the consumer offers a postcode (e.g., 'W1').
            - Use 'space' for smaller neighborhoods.
    """
    # URL encoding to stop InvalidURL errors
    safe_val = location_value.exchange(" ", "%20").exchange(",", "%2C")
    safe_id = location_identifier.exchange(" ", "%20")

    conn = http.shopper.HTTPSConnection("zoopla.p.rapidapi.com")

    headers = {
        "x-rapidapi-key": RAPIDAPI_KEY,
        "x-rapidapi-host": "zoopla.p.rapidapi.com",
    }

    path = (
        f"/properties/v2/checklist?locationValue={safe_val}"
        f"&locationIdentifier={safe_id}"
        f"&class=residential&furnishedState=Any"
        f"&sortOrder=newest_listings&web page={web page}"
    )

    conn.request("GET", path, headers=headers)
    res = conn.getresponse()
    information = res.learn()
    end result = json.hundreds(information.decode("utf-8"))

    return json.dumps(end result, indent=2)


property_agent = create_agent(
    ChatOpenAI(temperature=0, mannequin="gpt-5-mini"),
    instruments=(search_properties),
    system_prompt=(
        "You're a real-estate skilled. When a consumer asks for a location, "
        "infer the 'location_identifier' your self, often 'metropolis' or "
        "'postal_code'. Don't ask the consumer for technical identifiers; "
        "name the instrument instantly."
    ),
)

end result = property_agent.invoke(
    {"messages": ({"function": "consumer", "content material": "Seek for properties in London, England"})}
)

print(end result("messages")(-1).content material)

Ergebnis

Wir haben die tatsächlichen Eigenschaften als Ausgabe erhalten, sie wurden jedoch aus offensichtlichen Gründen unscharf.

Agent für Filmempfehlungen

Dieser Agent hat Zugriff auf die am besten und am schlechtesten bewerteten APIs der IMDB als Instruments und wir konfigurieren die Systemaufforderung so, dass sie basierend auf der Aufforderung das zu verwendende Software auswählt.

@instrument
def get_top_rated_movies() -> str:
    """
    Fetch the checklist of top-rated English motion pictures on IMDb.

    Use this when the consumer needs a advice or a "good" film.
    """
    conn = http.shopper.HTTPSConnection("imdb236.p.rapidapi.com")

    headers = {
        "x-rapidapi-key": RAPIDAPI_KEY,
        "x-rapidapi-host": "imdb236.p.rapidapi.com",
    }

    conn.request("GET", "/api/imdb/top-rated-english-movies", headers=headers)
    res = conn.getresponse()

    # Decode and return uncooked JSON for the agent to course of
    return res.learn().decode("utf-8")


@instrument
def get_lowest_rated_movies() -> str:
    """
    Fetch the checklist of lowest-rated motion pictures on IMDb.

    Use this when the consumer asks for "unhealthy" motion pictures or motion pictures to keep away from.
    """
    conn = http.shopper.HTTPSConnection("imdb236.p.rapidapi.com")

    headers = {
        "x-rapidapi-key": RAPIDAPI_KEY,
        "x-rapidapi-host": "imdb236.p.rapidapi.com",
    }

    conn.request("GET", "/api/imdb/lowest-rated-movies", headers=headers)
    res = conn.getresponse()

    return res.learn().decode("utf-8")


movie_agent = create_agent(
    ChatOpenAI(temperature=0, mannequin="gpt-5-mini"),
    instruments=(get_top_rated_movies, get_lowest_rated_movies),
    system_prompt=(
        "You might be an skilled film critic. Your aim is to assist customers discover motion pictures "
        "based mostly on high quality. If a consumer asks for one thing 'good', 'really useful', "
        "or 'basic', name get_top_rated_movies. If a consumer asks for one thing "
        "'unhealthy', 'horrible', or 'lowest rated', name get_lowest_rated_movies. "
        "Each instruments require no parameters. Summarize the leads to a pleasant "
        "manner in a single sentence."
    ),
)

# Instance utilization
end result = movie_agent.invoke(
    {
        "messages": (
            {
                "function": "consumer",
                "content material": "I am within the temper for a very horrible film, what is the worst on the market?",
            }
        )
    }
)

print(end result("messages")(-1).content material)

Ergebnis

If you need really terrible, IMDb’s lowest-rated picks embody Daniel der
 Zauberer (Daniel the Wizard) and Smolensk — each hovering round a 1.2
 common score and excellent in case you’re after a 
“so-bad-it’s-fascinating” watch. 

Großartig! Wir haben erfolgreich einen Agenten erstellt, der auf mehrere Instruments zugreifen und sowohl hoch- als auch am schlechtesten bewertete Filme vorschlagen kann.

Abschluss

Durch die Integration von Echtzeit-APIs mit Agenten können wir über statische Antworten hinausgehen und Systeme aufbauen, die sich wirklich clever anfühlen. RapidAPI macht diese Integration einfach und domänenübergreifend skalierbar. Außerdem ist es wichtig, dass wir die richtigen Werkzeuge auswählen und den Agenten so abstimmen, dass er mit dem Werkzeug harmoniert. Beispielsweise können viele APIs einen Fehler ausgeben, wenn im Argument einfache Anführungszeichen oder Leerzeichen vorhanden sind. Auch RapidAPI bietet MCP-Unterstützung über seine APIs hinweg, die im Rahmen der laufenden Bemühungen zur Entwicklung besserer Agenten untersucht werden können.

Häufig gestellte Fragen

Leidenschaftlich für Technologie und Innovation, Absolvent des Vellore Institute of Know-how. Derzeit arbeite ich als Information Science Trainee mit Schwerpunkt auf Information Science. Großes Interesse an Deep Studying und generativer KI, begierig darauf, modernste Techniken zu erforschen, um komplexe Probleme zu lösen und wirkungsvolle Lösungen zu schaffen.

Bild vom Autor

# Einführung

Die Fähigkeit, hochwertige, relevante Informationen zu sammeln, ist nach wie vor eine Kernkompetenz eines jeden Datenexperten. Es gibt zwar mehrere Möglichkeiten, Daten zu sammeln, eine der leistungsfähigsten und zuverlässigsten Methoden sind jedoch APIs (Utility Programming Interfaces). Sie dienen als Brücken und ermöglichen es verschiedenen Softwaresystemen, nahtlos zu kommunizieren und Daten auszutauschen.

In diesem Artikel erläutern wir die Grundlagen der Verwendung von APIs für die Datenerfassung – warum sie wichtig sind, wie sie funktionieren und wie man in Python mit ihnen beginnt.

# Was ist eine API?

Eine API (Utility Programming Interface) ist eine Reihe von Regeln und Protokollen, die es verschiedenen Softwaresystemen ermöglichen, effizient zu kommunizieren und Daten auszutauschen.
Stellen Sie sich das wie ein Essen in einem Restaurant vor. Anstatt direkt mit dem Koch zu sprechen, geben Sie Ihre Bestellung bei einem Kellner auf. Der Kellner prüft, ob die Zutaten verfügbar sind, gibt die Anfrage an die Küche weiter und bringt Ihr Essen zurück, sobald es fertig ist.
Eine API funktioniert auf die gleiche Weise: Sie empfängt Ihre Anfrage nach bestimmten Daten, prüft, ob diese Daten vorhanden sind, und gibt sie zurück, falls verfügbar – und fungiert als Übermittler zwischen Ihnen und der Datenquelle.
Bei der Verwendung einer API umfassen Interaktionen typischerweise die folgenden Komponenten:

• Consumer: Die Anwendung oder das System, das eine Anfrage zum Zugriff auf Daten oder Funktionen sendet
• Anfrage: Der Consumer sendet eine strukturierte Anfrage an den Server und gibt an, welche Daten er benötigt
• Server: Das System, das die Anfrage verarbeitet und die angeforderten Daten bereitstellt oder eine Aktion ausführt
• Antwort: Der Server verarbeitet die Anfrage und sendet die Daten oder das Ergebnis in einem strukturierten Format zurück, normalerweise JSON oder XML

Bild vom Autor

Diese Kommunikation ermöglicht es Anwendungen, Informationen oder Funktionen effizient auszutauschen und so Aufgaben wie das Abrufen von Daten aus einer Datenbank oder die Interaktion mit Diensten von Drittanbietern zu ermöglichen.

# Warum APIs zur Datenerfassung verwenden?

APIs bieten mehrere Vorteile für die Datenerfassung:

• Effizienz: Sie bieten direkten Zugriff auf Daten und machen eine manuelle Datenerfassung überflüssig
• Echtzeitzugriff: APIs liefern häufig aktuelle Informationen, die für zeitkritische Analysen unerlässlich sind
• Automatisierung: Sie ermöglichen automatisierte Datenabrufprozesse und reduzieren so menschliche Eingriffe und potenzielle Fehler
• Skalierbarkeit: APIs können große Mengen an Anfragen verarbeiten und eignen sich daher für umfangreiche Datenerfassungsaufgaben

# API-Aufrufe in Python implementieren

Ein einfacher API-Aufruf in Python ist eine der einfachsten und praktischsten Übungen für den Einstieg in die Datenerfassung. Das Beliebte Anfragen Mit der Bibliothek ist es einfach, HTTP-Anfragen zu senden und Antworten zu verarbeiten.
Um zu demonstrieren, wie es funktioniert, verwenden wir die Zufällige Benutzergenerator-APIein kostenloser Dienst, der Dummy-Benutzerdaten im JSON-Format bereitstellt, perfekt zum Testen und Lernen.
Hier finden Sie eine Schritt-für-Schritt-Anleitung für Ihren ersten API-Aufruf in Python.

// Installieren der Anforderungsbibliothek:

// Importieren der erforderlichen Bibliotheken:

import requests
import pandas as pd

// Überprüfen der Dokumentationsseite:

Bevor Sie Anfragen stellen, ist es wichtig zu verstehen, wie die API funktioniert. Dazu gehört die Überprüfung verfügbarer Endpunkte, Parameter und Antwortstrukturen. Beginnen Sie mit einem Besuch die Random Person API-Dokumentation.

// Definieren des API-Endpunkts und der Parameter:

Basierend auf der Dokumentation können wir eine einfache Anfrage erstellen. In diesem Beispiel rufen wir Benutzerdaten ab, die auf Benutzer aus den USA beschränkt sind:

url="https://randomuser.me/api/"
params = {'nat': 'us'}

// GET-Anfrage stellen:

Benutzen Sie die requests.get() Funktion mit der URL und den Parametern:

response = requests.get(url, params=params)

// Umgang mit der Antwort:

Prüfen Sie, ob die Anfrage erfolgreich warfare, und verarbeiten Sie dann die Daten:

if response.status_code == 200:
    information = response.json()
    # Course of the info as wanted
else:
    print(f"Error: {response.status_code}")

// Konvertieren unserer Daten in einen Datenrahmen:

Um die Arbeit mit den Daten zu vereinfachen, können wir sie in eine konvertieren Pandas DataFrame:

information = response.json()
df = pd.json_normalize(information("outcomes"))
df

Lassen Sie es uns nun an einem realen Fall veranschaulichen.

# Arbeiten mit der Eurostat-API

Eurostat ist das statistische Amt der Europäischen Union. Es bietet hochwertige, harmonisierte Statistiken zu einem breiten Themenspektrum wie Wirtschaft, Demografie, Umwelt, Industrie und Tourismus – und deckt alle EU-Mitgliedstaaten ab.

Über seine API bietet Eurostat öffentlichen Zugriff auf eine umfangreiche Sammlung von Datensätzen in maschinenlesbaren Formaten und ist damit eine wertvolle Ressource für Datenexperten, Forscher und Entwickler, die an der Analyse von Daten auf europäischer Ebene interessiert sind.

// Schritt 0: Die Daten in der API verstehen:

Wenn Sie im Abschnitt „Daten“ von Eurostat nachsehen, finden Sie einen Navigationsbaum. Wir können versuchen, einige interessante Daten in den folgenden Unterabschnitten zu identifizieren:

• Detaillierte Datensätze: Vollständige Eurostat-Daten im mehrdimensionalen Format
• Ausgewählte Datensätze: Vereinfachte Datensätze mit weniger Indikatoren, in 2–3 Dimensionen
• EU-Politik: Nach bestimmten EU-Politikbereichen gruppierte Daten
• Querschnittsübergreifend: Thematische Daten, zusammengestellt aus mehreren Quellen

// Schritt 1: Überprüfung der Dokumentation:

Beginnen Sie immer mit der Dokumentation. Den API-Leitfaden von Eurostat finden Sie hier Hier. Es erläutert die API-Struktur, verfügbare Endpunkte und wie gültige Anfragen erstellt werden.

// Schritt 2: Generieren der ersten Anrufanfrage:

Um eine API-Anfrage mit Python zu generieren, besteht der erste Schritt darin, die zu installieren und zu importieren requests Bibliothek. Denken Sie daran, dass wir es bereits im vorherigen einfachen Beispiel installiert haben. Anschließend können wir mithilfe eines Demodatensatzes aus der Eurostat-Dokumentation ganz einfach eine Anrufanfrage generieren.

# We import the requests library
import requests

# Outline the URL endpoint -> We use the demo URL within the EUROSTATS API documentation.
url = "https://ec.europa.eu/eurostat/api/dissemination/statistics/1.0/information/DEMO_R_D3DENS?lang=EN"

# Make the GET request
response = requests.get(url)

# Print the standing code and response information
print(f"Standing Code: {response.status_code}")
print(response.json())  # Print the JSON response

Profi-Tipp: Wir können die URL in die Foundation-URL und Parameter aufteilen, um es einfacher zu machen verstehen welche Daten Wir fordern von der API an.

# We import the requests library
import requests

# Outline the URL endpoint -> We use the demo URL within the EUROSTATS API documentation.
url = "https://ec.europa.eu/eurostat/api/dissemination/statistics/1.0/information/DEMO_R_D3DENS"

# Outline the parameters -> We outline the parameters so as to add within the URL.
params = {
   'lang': 'EN'  # Specify the language as English
}

# Make the GET request
response = requests.get(url, params=params)

# Print the standing code and response information
print(f"Standing Code: {response.status_code}")
print(response.json())  # Print the JSON response

// Schritt 3: Bestimmen des aufzurufenden Datensatzes:

Anstatt den Demodatensatz zu verwenden, können Sie einen beliebigen Datensatz aus der Eurostat-Datenbank auswählen. Lassen Sie uns beispielsweise den Datensatz abfragen TOUR_OCC_ARN2das Daten zu touristischen Unterkünften enthält.

# We import the requests library
import requests

# Outline the URL endpoint -> We use the demo URL within the EUROSTATS API documentation.
base_url = "https://ec.europa.eu/eurostat/api/dissemination/statistics/1.0/information/"
dataset = "TOUR_OCC_ARN2"

url = base_url + dataset
# Outline the parameters -> We outline the parameters so as to add within the URL.
params = {
    'lang': 'EN'  # Specify the language as English
}

# Make the GET request -> we generate the request and acquire the response
response = requests.get(url, params=params)

# Print the standing code and response information
print(f"Standing Code: {response.status_code}")
print(response.json())  # Print the JSON response

// Schritt 4: Die Antwort verstehen

Die API von Eurostat gibt Daten im JSON-Stat-Format zurück, einem Commonplace für mehrdimensionale statistische Daten. Sie können die Antwort in einer Datei speichern und deren Struktur erkunden:

import requests
import json

# Outline the URL endpoint and dataset
base_url = "https://ec.europa.eu/eurostat/api/dissemination/statistics/1.0/information/"
dataset = "TOUR_OCC_ARN2"

url = base_url + dataset

# Outline the parameters so as to add within the URL
params = {
    'lang': 'EN',
    "time": 2019  # Specify the language as English
}

# Make the GET request and acquire the response
response = requests.get(url, params=params)

# Verify the standing code and deal with the response
if response.status_code == 200:
    # Parse the JSON response
    information = response.json()

    # Generate a JSON file and write the response information into it
    with open("eurostat_response.json", "w") as json_file:
        json.dump(information, json_file, indent=4)  # Save JSON with fairly formatting

    print("JSON file 'eurostat_response.json' has been efficiently created.")
else:
    print(f"Error: Acquired standing code {response.status_code} from the API.")

// Schritt 5: Umwandlung der Antwort in nutzbare Daten:

Nachdem wir nun die Daten erhalten haben, können wir eine Möglichkeit finden, sie in einem Tabellenformat (CSV) zu speichern, um den Analyseprozess zu vereinfachen.

import requests
import pandas as pd

# Step 1: Make the GET request to the Eurostat API
base_url = "https://ec.europa.eu/eurostat/api/dissemination/statistics/1.0/information/"
dataset = "TOUR_OCC_ARN2"  # Vacationer lodging statistics dataset
url = base_url + dataset
params = {'lang': 'EN'}  # Request information in English

# Make the API request
response = requests.get(url, params=params)

# Step 2: Verify if the request was profitable
if response.status_code == 200:
    information = response.json()

    # Step 3: Extract the scale and metadata
    dimensions = information('dimension')
    dimension_order = information('id')  # ('geo', 'time', 'unit', 'indic', and many others.)

    # Extract labels for every dimension dynamically
    dimension_labels = {dim: dimensions(dim)('class')('label') for dim in dimension_order}

    # Step 4: Decide the scale of every dimension
    dimension_sizes = {dim: len(dimensions(dim)('class')('index')) for dim in dimension_order}

    # Step 5: Create a mapping for every index to its respective label
    # For instance, if we now have 'geo', 'time', 'unit', and 'indic', map every index to the right label
    index_labels = {
        dim: checklist(dimension_labels(dim).keys())
        for dim in dimension_order
    }

    # Step 6: Create a listing of rows for the CSV
    rows = ()
    for key, worth in information('worth').objects():
        # `key` is a string like '123', we have to break it down into the corresponding labels
        index = int(key)  # Convert string index to integer

        # Calculate the indices for every dimension
        indices = {}
        for dim in reversed(dimension_order):
            dim_index = index % dimension_sizes(dim)
            indices(dim) = index_labels(dim)(dim_index)
            index //= dimension_sizes(dim)

        # Assemble a row with labels from all dimensions
        row = {f"{dim.capitalize()} Code": indices(dim) for dim in dimension_order}
        row.replace({f"{dim.capitalize()} Identify": dimension_labels(dim)(indices(dim)) for dim in dimension_order})
        row("Worth (Vacationer Lodging)") = worth
        rows.append(row)

    # Step 7: Create a DataFrame and put it aside as CSV
    if rows:
        df = pd.DataFrame(rows)
        csv_filename = "eurostat_tourist_accommodation.csv"
        df.to_csv(csv_filename, index=False)
        print(f"CSV file '{csv_filename}' has been efficiently created.")
    else:
        print("No legitimate information to save lots of as CSV.")
else:
    print(f"Error: Acquired standing code {response.status_code} from the API.")

// Schritt 6: Generieren einer spezifischen Ansicht

Stellen Sie sich vor, wir möchten nur die Aufzeichnungen zu Campingplätzen, Flats oder Accommodations führen. Mit dieser Bedingung können wir eine Abschlusstabelle erstellen und eine erhalten pandas DataFrame mit denen wir arbeiten können.

# Verify the distinctive values within the 'Nace_r2 Identify' column
set(df("Nace_r2 Identify"))

# Record of choices to filter
choices = ('Tenting grounds, leisure car parks and trailer parks',
          'Vacation and different short-stay lodging',
          'Accommodations and related lodging')

# Filter the DataFrame primarily based on whether or not the 'Nace_r2 Identify' column values are within the choices checklist
df = df(df("Nace_r2 Identify").isin(choices))
df

# Finest Practices beim Arbeiten mit APIs

• Lesen Sie die Dokumente: Sehen Sie sich immer die offizielle API-Dokumentation an, um Endpunkte und Parameter zu verstehen
• Behandeln Sie Fehler: Verwenden Sie Bedingungen und Protokollierung, um fehlgeschlagene Anforderungen ordnungsgemäß zu verarbeiten
• Respektieren Sie Ratenbegrenzungen: Vermeiden Sie eine Überlastung des Servers – prüfen Sie, ob Ratenbegrenzungen gelten
• Sichere Anmeldeinformationen: Wenn die API eine Authentifizierung erfordert, legen Sie Ihre API-Schlüssel niemals in öffentlichem Code offen

# Zusammenfassung

Die API von Eurostat ist ein leistungsstarker Zugang zu einer Fülle strukturierter, qualitativ hochwertiger europäischer Statistiken. Indem Sie lernen, wie Sie in der Struktur navigieren, Datensätze abfragen und Antworten interpretieren, können Sie den Zugriff auf wichtige Daten für Analysen, Recherchen oder Entscheidungen automatisieren – direkt aus Ihren Python-Skripten.

Sie können den entsprechenden Code überprüfen in meinem GitHub-Repository My-Articles-Pleasant-Hyperlinks

Josep Ferrer ist ein Analyseingenieur aus Barcelona. Er hat einen Abschluss in Physik-Ingenieurwesen und arbeitet derzeit im Bereich Datenwissenschaft, angewandt auf die menschliche Mobilität. Er ist nebenberuflich als Content material-Ersteller tätig und konzentriert sich auf Datenwissenschaft und -technologie. Josep schreibt über alles, was mit KI zu tun hat, und behandelt die Anwendung der anhaltenden Explosion in diesem Bereich.