Erste Schritte mit Python HTTP-Anfragen für REST-APIs

Schnelle Antwort: GET- und POST-Anfragen in Python stellen

Hast du es eilig? Hier ist die Python-Syntax für eine einfache GET und POST Anfrage:

1. GET-Anfrage

import requests

# The API endpoint
url = "https://jsonplaceholder.typicode.com/posts/1"

# A GET request to the API
response = requests.get(url)

# Print the response
print(response.json())

2. POST-Anfrage

import requests

# The API endpoint
url = "https://jsonplaceholder.typicode.com/posts"

# Data to be sent
data = {
    "userID": 1,
    "title": "Making a POST request",
    "body": "This is the data we created."
}

# A POST request to the API
response = requests.post(url, json=data)

# Print the response
print(response.json())

Wenn du tiefer in die Erstellung von HTTP-Anfragen mit Python eintauchen und mehr über REST-APIs erfahren möchtest, lies weiter!

Was ist eine REST API?

Wir haben festgestellt, dass APIs Software-Vermittler sind. Man kann sie auch als eine Art Softwareschnittstelle betrachten, die anderen Anwendungen Zugriff auf bestimmte Daten und Methoden gewährt. 

Eine der beliebtesten Architekturen für die Erstellung von APIs ist das REpresentational State Transfer (REST)-Muster. Die REST-Architektur ermöglicht es, dass Client und Server unabhängig voneinander implementiert werden können, ohne sich gegenseitig zu kennen. Das bedeutet, dass der Code auf beiden Seiten geändert werden kann, ohne dass man sich Gedanken darüber machen muss, wie sich die Änderung auf die andere Seite auswirkt. 

REST-APIs folgen daher einer Reihe von Richtlinien, die die Kommunikation zwischen Software vereinfachen und den Zugriff auf Daten unkomplizierter und logischer machen sollen. Mach dir keine Sorgen, wenn du diese Richtlinien nicht kennst. Du musst sie nicht kennen, um loszulegen - was du wissen musst, ist, wie Daten von REST-Diensten offengelegt werden. 

Die Daten von REST-Webdiensten werden dem Internet über eine öffentliche URL zur Verfügung gestellt, auf die durch Senden einer HTTP-Anfrage zugegriffen werden kann.  

Übersicht über die HTTP-Anforderungsmethoden

Spulen wir noch einmal zu unserer Restaurant-Analogie zurück: Wenn du in einem Restaurant Essen bestellst, kommt der Kellner auf dich zu und du sagst, was du willst. Der Kellner gibt dann deinen Wunsch an den Koch weiter, der das Essen zubereitet und es dem Kellner übergibt, damit er es dir zurückbringt. Mit anderen Worten: Der Koch würde dein Essen erst zubereiten, wenn deine Anfrage abgeschickt wurde. 

REST-APIs sind gleich: Sie warten auf HTTP-Anfragen, bevor sie eine Aktion ausführen. HTTP definiert eine Reihe von Anforderungsmethoden, die der API mitteilen, welche Operationen für eine bestimmte Ressource durchgeführt werden sollen. Sie legt fest, wie mit den Ressourcen am angegebenen Endpunkt interagiert werden soll. 

Es gibt mehrere HTTP-Methoden, aber fünf werden häufig bei REST-APIs verwendet: 

Es ist sehr wahrscheinlich, dass du in der Datenanalyse und Datenwissenschaft mehr GET-Anfragen als jede andere Methode durchführen wirst. Das liegt daran, dass es die notwendige Methode ist, um auf bestimmte Datensätze zuzugreifen. Erfahre mehr darüber im DataCamp-Kurs Intermediate Importing Data in Python.

Wenn du eine Anfrage an einen Webserver stellst, gibt die API eine Antwort zurück. An die Antwort ist ein HTTP-Statuscode angehängt. Der Zweck des Statuscodes ist es, zusätzliche Informationen über die Antwort zu liefern, damit der Kunde weiß, welche Art von Anfrage er erhalten hat.

Was sind API-Endpunkte?

Eine URL definiert die Daten, mit denen du auf einem Webserver interagierst. Ähnlich wie eine Webseiten-URL mit einer einzelnen Seite verbunden ist, ist eine Endpunkt-URL mit bestimmten Ressourcen innerhalb einer API verknüpft. Daher kann ein Endpunkt als digitaler Ort beschrieben werden, an dem eine API Anfragen zu einer bestimmten Ressource auf ihrem Server entgegennimmt - stell dir das als das andere Ende eines Kommunikationskanals vor. 

Um mehr Kontext zu schaffen, stellen REST-APIs eine Reihe von öffentlichen URLs zur Verfügung, die von Client-Anwendungen angefordert werden können, um auf die Ressourcen des Webdienstes zuzugreifen. Die öffentlichen URLs, die von der REST-API bereitgestellt werden, werden als "Endpunkte" bezeichnet.

Mit Python HTTP-Anfragen stellen

Das Python-Modul requests ermöglicht es Entwicklern, Code für die Interaktion mit REST-APIs zu schreiben. Sie ermöglicht es ihnen, HTTP-Anfragen mit Python zu senden, ohne sich um die Komplexität solcher Aufgaben kümmern zu müssen (z. B. manuelles Hinzufügen von Abfragezeichenfolgen zu URLs, Formularcodierung PUT und POST Daten usw.). 

Obwohl es als De-facto-Standard für HTTP-Anfragen in Python gilt, ist das Modul requests nicht Teil der Standardbibliothek von Python - es muss installiert werden. 

Der einfachste Weg, das Modul für Anfragen zu installieren, ist mit pip: 

python -m pip install requests

Es wird immer empfohlen, die Python-Pakete, die für verschiedene Projekte benötigt werden, in virtuellen Umgebungen zu verwalten. Auf diese Weise können die Pakete für ein Projekt die Systemwerkzeuge in anderen Projekten nicht beeinträchtigen und zerstören, da sie isoliert sind - anstatt global installiert zu werden. 

Jetzt haben wir das Anfragemodul installiert, also lass uns sehen, wie es funktioniert. Folge dem Code in dieser DataLab-Arbeitsmappe. 

Eine GET-Anfrage in Python stellen

Wir haben bereits festgestellt, dass GET eine der häufigsten HTTP-Anfragemethoden ist, die dir bei der Arbeit mit REST-APIs begegnen. Es ermöglicht dir (dem Kunden), Daten von Webservern abzurufen. 

Es ist wichtig zu wissen, dass GET eine Nur-Lese-Operation ist, d.h. sie eignet sich nur für den Zugriff auf bestehende Ressourcen und sollte nicht verwendet werden, um sie zu verändern. 

Um zu demonstrieren, wie das Anfragemodul funktioniert, verwenden wir JSONPlaceholder, eine frei verfügbare Fake-API, die zum Testen und Prototyping verwendet wird. 

import requests

# The API endpoint
url = "https://jsonplaceholder.typicode.com/posts/1"

# A GET request to the API
response = requests.get(url)

# Print the response
response_json = response.json()
print(response_json)

"""
{'userId': 1, 'id': 1, 'title': 'sunt aut facere repellat provident occaecati excepturi optio reprehenderit', 'body': 'quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto'}
"""

Im obigen Code haben wir Folgendes gemacht: 

1. Definiert den API-Endpunkt, von dem Daten abgerufen werden sollen.
2. Verwende die Methode requests.get(url), um die Daten von dem definierten Endpunkt abzurufen. 
3. Wir haben die Methode response.json() verwendet, um die Antwortdaten in einem Wörterbuchobjekt zu speichern; beachte, dass dies nur funktioniert, weil das Ergebnis im JSON-Format geschrieben wird - andernfalls wäre ein Fehler aufgetreten.   
4. Der letzte Schritt besteht darin, die JSON-Antwortdaten zu drucken. 

Wir können auch den von der API zurückgegebenen Statuscode wie folgt überprüfen: 

# Print status code from original response (not JSON)
print(response.status_code)

"""
200
"""

Du kannst auch Argumente an eine Python-GET-Anfrage übergeben. Dazu müssen wir den obigen Code leicht abändern. So sieht der neue Code aus:

# The API endpoint
url = "https://jsonplaceholder.typicode.com/posts/"

# Adding a payload
payload = {"id": [1, 2, 3], "userId":1}

# A get request to the API
response = requests.get(url, params=payload)

# Print the response
response_json = response.json()

for i in response_json:
    print(i, "\n")

"""
{'userId': 1, 'id': 1, 'title': 'sunt aut facere repellat provident occaecati excepturi optio reprehenderit', 'body': 'quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto'}

{'userId': 1, 'id': 2, 'title': 'qui est esse', 'body': 'est rerum tempore vitae\nsequi sint nihil reprehenderit dolor beatae ea dolores neque\nfugiat blanditiis voluptate porro vel nihil molestiae ut reiciendis\nqui aperiam non debitis possimus qui neque nisi nulla'}

{'userId': 1, 'id': 3, 'title': 'ea molestias quasi exercitationem repellat qui ipsa sit aut', 'body': 'et iusto sed quo iure\nvoluptatem occaecati omnis eligendi aut ad\nvoluptatem doloribus vel accusantium quis pariatur\nmolestiae porro eius odio et labore et velit aut'}
"""

Hier ist, was wir anders gemacht haben: 

1. Der API-Endpunkt wurde geändert. Beachte, dass es keine "1" mehr am Ende hat. 
2. Definiert die Nutzlast in einem Wörterbuch.  
3. Übergibt die Nutzlast an das param Argument der requests.get() Methode. 
4. Das Ergebnis ist ein Listenobjekt, das wir in einer Schleife durchlaufen und jedes Element in eine neue Zeile drucken.  

Eine POST-Anfrage in Python stellen

GET Anfragen ermöglichen es dir, Daten abzurufen; POST Anfragen ermöglichen es dir, neue Daten zu erstellen. Schauen wir uns an, wie wir neue Daten auf dem JSONPlaceholder-Server erstellen können.

# Define new data to create
new_data = {
    "userID": 1,
    "id": 1,
    "title": "Making a POST request",
    "body": "This is the data we created."
}

# The API endpoint to communicate with
url_post = "https://jsonplaceholder.typicode.com/posts"

# A POST request to tthe API
post_response = requests.post(url_post, json=new_data)

# Print the response
post_response_json = post_response.json()
print(post_response_json)

"""
{'userID': 1, 'id': 101, 'title': 'Making a POST request', 'body': 'This is the data we created.'}
"""

Im obigen Code haben wir Folgendes gemacht: 

1. Wir haben eine neue Ressource erstellt, die wir der JSONPlaceholder-API hinzufügen wollen.
2. Definiere den Endpunkt für POST, um die neuen Daten zu erhalten.
3. Sende eine POST Anfrage mit der Methode requests.post(). Beachte, dass der Parameter json in der Methode post() gesetzt wurde. Damit teilen wir der API mit, dass wir explizit ein JSON-Objekt an die angegebene URL senden. 
4. Verwende die Methode response.json(), um die Antwortdaten in einem Wörterbuchobjekt zu speichern.
5. Der letzte Schritt besteht darin, die JSON-Antwortdaten zu drucken. 

Aber, warte!

Bevor du den nächsten Teil des Codes liest, nimm dir 20 Sekunden Zeit, um zu überlegen, welchen Statuscode die API zurückgeben wird. 

Zur Erinnerung: Dieses Mal haben wir eine neue Ressource erstellt, anstatt sie einfach abzurufen. 

Okay, jetzt geht's los... 

# Print status code from original response (not JSON)
print(post_response.status_code)

"""
201
"""

Hast du es richtig gemacht? 

Python HTTP-Anfragen Fortgeschrittene Themen

HTTP-Anfragen mit Python zu stellen, ist in der Regel einfach, aber manchmal sind fortgeschrittene Einstellungen erforderlich oder Probleme unvermeidlich. Hier sind einige Herausforderungen, denen du begegnen könntest und wie du sie lösen kannst. 

Authentifizierung von HTTP-Anfragen

Bis jetzt waren unsere Interaktionen mit der REST-API ziemlich einfach. Die JSONPlaceholder-API erfordert keine Authentifizierung, damit du mit ihr interagieren kannst. Es gibt jedoch mehrere Fälle, in denen eine REST-API eine Authentifizierung erfordert, bevor der Zugriff auf bestimmte Endpunkte gewährt wird - vor allem, wenn du mit sensiblen Daten zu tun hast. 

Wenn du zum Beispiel Integrationen erstellen, Daten abrufen und deine Arbeitsabläufe auf GitHub automatisieren willst, kannst du dies mit der GitHub REST API tun. Es gibt jedoch viele Vorgänge in der GitHub REST API, die eine Authentifizierung erfordern, wie z.B. das Abrufen von öffentlichen und privaten Informationen über authentifizierte Nutzer. 

Hier ist ein einfacher Workaround, der das Python-Modul für Anfragen verwendet: 

from requests.auth import HTTPBasicAuth

private_url = "https://api.github.com/user"
github_username = "username"
token = "token"

private_url_response = requests.get(
    url=private_url,
    auth=HTTPBasicAuth(github_username, token)
)

private_url_response.status_code

"""
200
"""

In dem obigen Code haben wir:

1. Importiert das HTTPBasicAuth Objekt von requests.auth. Dieses Objekt verknüpft die HTTP-Basisauthentifizierung mit dem gegebenen Anfrageobjekt - das ist im Grunde dasselbe, als würdest du deinen Benutzernamen und dein Passwort auf einer Website eingeben. 
2. Definiert den privaten URL-Endpunkt, auf den zugegriffen werden soll.
3. Du hast eine Variable mit einem GitHub-Benutzernamen instanziiert - wir haben den Benutzernamen aus Datenschutzgründen anonymisiert.
4. Instanziiert eine Variable GitHub mit einem persönlichen Access Token zur Authentifizierung.  
5. Ruft Daten von unserem Endpunkt ab und speichert sie in der Variable private_url_response . 
6. Zeigt den Statuscode an.  

Umgang mit HTTP-Anfragefehlern

Es gibt Fälle, in denen die Anfragen an eine API nicht wie erwartet funktionieren. Es können mehrere Faktoren auf der Client- oder Serverseite eine Rolle spielen. Unabhängig von der Ursache ist das Ergebnis immer dasselbe: Die Anfrage schlägt fehl. 

Wenn du REST-APIs verwendest, ist es immer eine gute Idee, deinen Code widerstandsfähig zu machen. Bevor du jedoch robusten Code schreiben kannst, musst du wissen, wie du mit den gemeldeten Fehlern umgehen kannst, wenn die Dinge nicht nach Plan laufen.  

Für diese Demonstration kehren wir zur JSONPlaceholder-API zurück. Wir werden zunächst etwas Code schreiben und dann erklären, was passiert.  

# A deliberate typo is made in the endpoint "postz" instead of "posts"
url = "https://jsonplaceholder.typicode.com/postz"

# Attempt to GET data from provided endpoint
try:
    response = requests.get(url)
    response.raise_for_status()
# If the request fails (404) then print the error.
except requests.exceptions.HTTPError as error:
  print(error)

"""
404 Client Error: Not Found for url: https://jsonplaceholder.typicode.com/postz
"""

Im obigen Code: 

1. Wir haben den Endpunkt des JSONPlace-Inhabers definiert, von dem die Daten abgerufen werden sollen, aber wir haben uns bei der Erstellung der URL absichtlich vertippt - das wird einen 404-Fehler auslösen. 
2. Wir haben die in Python eingebaute Ausnahmebehandlung verwendet, um try und except (abzufangen), wenn beim Versuch, den JSONPlaceholder-Endpunkt zu besuchen, Fehler auftreten. Beachte, dass die Methode raise_for_status() verwendet wird, um ein HTTPError Objekt zurückzugeben, wenn während des Prozesses ein Fehler auftritt.
3. Und schließlich haben wir den Fehler ausgedruckt, der aufgetreten ist. 

Obwohl wir in diesem Beispiel gezeigt haben, wie man 404-Fehlerstatuscodes behandelt, kann dasselbe Format für jeden HTTP-Statuscode verwendet werden. 

Umgang mit zu vielen Weiterleitungen

HTTP-Statuscodes mit dem Format 3xx zeigen an, dass der Client umgeleitet wurde und einige zusätzliche Aktionen durchführen muss, um die Anfrage abzuschließen. Dies kann jedoch gelegentlich zu einer unendlichen Umleitungsschleife führen.

Das Python-Modul für Anfragen bietet das Objekt TooManyRedirects, um dieses Problem zu lösen: 

"""
Note: The code here will not raise an error
but the structure is how you would hand a case where there
are multiple redirects
"""

url = "https://jsonplaceholder.typicode.com/posts"

try:
  response = requests.get(url)
  response.raise_for_status()
except requests.exceptions.TooManyRedirects as error:
  print(error)

Du kannst auch die maximale Anzahl von Weiterleitungen als Parameter deiner HTTP-Anforderungsmethode festlegen: 

# Solution 2
url = "https://jsonplaceholder.typicode.com/posts"
session = requests.Session()
session.max_redirects = 3
response = session.get(url)

Eine andere Möglichkeit ist, Weiterleitungen komplett zu deaktivieren: 

# Solution 3
url = "https://jsonplaceholder.typicode.com/posts"
session = requests.Session()
session.allow_redirects = False
response = session.get(url)

Behandlung von Verbindungsfehlern bei HTTP-Anfragen

Dies sind andere Arten von Fehlern, die auftreten können, wenn du versuchst, Anfragen an einen Server zu senden. Es gibt verschiedene Gründe dafür, dass du keine Antwort vom Server erhältst (z. B. DNS-Fehler, verweigerte Verbindung, Probleme mit der Internetverbindung usw.), aber das Ergebnis ist immer dasselbe: Es wird ein Verbindungsfehler gemeldet. 

Du kannst das requests Module ConnectionError Ausnahmeobjekt verwenden, um diese Probleme abzufangen und sie entsprechend zu behandeln. 

So würde der Code aussehen:  

"""
Note: The code here will not raise an error
but the structure is how you would hand a case where there
is a connection error.
"""

url = "https://jsonplaceholder.typicode.com/posts"

try:
  response = requests.get(url)
except requests.ConnectionError as error:
  print(error)

Zeitüberschreitung bei HTTP-Anfragen

Wenn der API-Server deine Verbindung annimmt, aber deine Anfrage nicht innerhalb der zulässigen Zeit beenden kann, erhältst du einen "Timeout-Fehler".

Wir zeigen dir, wie du in diesem Fall vorgehst, indem wir den Parameter timeout in der Methode requests.get() auf eine extrem kleine Zahl setzen; das löst einen Fehler aus, den wir mit dem Objekt requests.Timeout behandeln. 

url = "https://jsonplaceholder.typicode.com/posts"

try:
  response = requests.get(url, timeout=0.0001)
except requests.Timeout as error:
  print(error)

Die einfachste Lösung für Timeout-Fehler ist es, längere Timeouts zu setzen. Andere Lösungen können darin bestehen, dass du deine Anfragen optimierst, eine Wiederholungsschleife in deine Skripte einbaust oder asynchrone API-Aufrufe durchführst - eine Technik, die es deiner Software ermöglicht, eine potenziell langwierige Aktivität zu starten, während sie auf andere Ereignisse reagiert, anstatt zu warten, bis die Aufgabe abgeschlossen ist.

Einpacken

In diesem Tutorium haben wir uns damit beschäftigt, was APIs sind und eine gängige API-Architektur namens REST kennengelernt. Wir haben uns auch die HTTP-Methoden angesehen und wie wir die Python-Bibliothek requests nutzen können, um mit Webdiensten zu interagieren. 

Schau dir die folgenden Kurse an, um deine Kenntnisse in Data Science zu erweitern: 

• Einführung in APIs in Python
• Optimierter Dateningestion mit Pandas 
• Analyse von Social Media Daten in Python
• Zwischendurch Daten in Python importieren