Sammeln von Echtzeitdaten mit APIs: Eine praktische Anleitung zur Verwendung von Python

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.