Eine vollständiger Leitfaden zur Python-Requests-Bibliothek

In diesem umfassenden Leitfaden lernen Sie Folgendes:

• Was Requests ist, wie man es installiert und warum es die beliebteste Python-HTTP-Client-Bibliothek ist.
• Wie man es mit verschiedenen HTTP-Methoden verwendet.
• Was es für die Bearbeitung von Serverantworten bietet.
• Welche Anforderungsanpassungen es unterstützt.
• Die fortgeschrittenen Szenarien, die von der Python-Requests-Bibliothek abgedeckt werden

Legen wir los!

Einführung in die Requests-Bibliothek

Erfahren Sie, was Requests ist, wie man es installiert, wann man es benutzt und was es bietet.

Definition

Requests ist eine elegante und einfache HTTP-Bibliothek für Python. Im Einzelnen handelt es sich um eine intuitive API für die Erstellung von HTTP-Requests und die Bearbeitung von Responses auf einfache und für den Menschen lesbare Weise. Mit über 50.000 Sternen auf GitHub und Millionen täglicher Downloads ist Requests der beliebteste HTTP-Client in Python.

Zu den wichtigsten Funktionen dieser Bibliothek gehört eine umfassende API, die alle HTTP-Methoden, die Bearbeitung von Responses, die Anpassung von Requests, die Authentifizierung, die Verwaltung von SSL-Zertifikaten und vieles mehr abdeckt. Darüber hinaus unterstützt das Python-Requests-Modul standardmäßig HTTP/1.1.

Einrichtung

Die einfachste und empfohlene Methode, Requests zu installieren, ist über pip. Das pip-Paket, das mit der Requests-Bibliothek verbunden ist, heißt Requests. Sie können den HTTP-Client also mit dem folgenden Befehl installieren:

pip install requests

Um Requests in Ihrem Python-Skript zu verwenden, importieren Sie es mit der folgenden Zeile:

import requests

Fantastisch! Das Requests-Paket ist jetzt installiert und kann verwendet werden.

Anwendungsfälle

Zu den wichtigsten Anwendungsfällen der Python-Requests-Bibliothek gehören:

• Ausführung von HTTP-Requests an Webserver: Ruft Daten von Webservern ab, indem GET-Requests gesendet werden.
• Verbrauch von APIs: Senden Sie Requests an API-Endpunkte und bearbeiten Sie deren Responses, interagieren Sie mit verschiedenen Web-Services und greifen Sie auf deren Daten zu.
• Web Scraping: Ruft HTML-Dokumente ab, die mit Webseiten verknüpft sind. Diese können dann mithilfe von Bibliotheken wie BeautifulSoup analysiert werden, um bestimmte Informationen zu extrahieren. Erfahren Sie mehr in unserem Python-Web-Scraping-Leitfaden.
• Testen von Webanwendungen: Simulieren Sie HTTP-Requests und verifizieren Sie die Responses, automatisieren Sie den Testprozess und stellen Sie sicher, dass die Web-Services ordnungsgemäß funktionieren.
• Herunterladen von Dateien: Rufen Sie Dateien wie Bilder, Dokumente oder andere Mediendateien von Webservern ab, indem Sie HTTP-GET-Request an die jeweiligen URLs senden.

Methoden

Sehen Sie sich in der folgenden Tabelle die öffentlichen Methoden an, die von der Requests-Bibliothek verfügbar gemacht werden:

Wie Sie sehen, decken diese die nützlichsten HTTP-Request-Methoden ab. Weitere Informationen zur Verwendung finden Sie in der offiziellen API-Dokumentation.

Zeit, sie in Aktion zu sehen!

HTTP-Methoden

Sehen Sie sich die Requests-Python-Bibliothek in Aktion an, wenn es um die Methoden GET, POST, PUT, DELETE und HEAD in HTTP geht.

GET

In HTTP wird die GET -Methode verwendet, um eine bestimmte Ressource von einem Server anzufordern. So können Sie eine HTTP-GET-Request mit requests.get() ausführen:

import requests

# send a GET request to the specified URL

response = requests.get('https://api.example.com/data')

Ebenso können Sie dasselbe Ergebnis mit requests.request() wie folgt erzielen:

import requests

response = requests.request('GET', 'https://api.example.com/data')

In diesem Fall müssen Sie die zu verwendende HTTP-Methode manuell mit einer zusätzlichen String-Variable angeben.

POST

Die HTTP-POST-Methode wird verwendet, um Daten zur weiteren Verarbeitung an einen Server zu senden. So führen Sie eine POST-Request mit requests.post() aus:

import requests

# data to be sent in the POST request

product = {

'name': 'Limitor 500',

'description': 'The Limitor 500 is a high-performance electronic device designed to regulate power consumption in industrial settings. It offers advanced features such as real-time monitoring, adjustable settings, and remote access for efficient energy management.',

'price': 199.99,

'manufacturer': 'TechCorp Inc.',

'category': 'Electronics',

'availability': 'In Stock'

}

# send a POST request to the specified URL

response = requests.post('https://api.example.com/product', data=product)

Im Vergleich zu einer GET-Request müssen Sie dieses Mal auch die Daten angeben, die über die Option data an den Server gesendet werden sollen. Requests fügt diese Daten zum Hauptteil der HTTP-Request hinzu.

Für JSON-Bodies übergeben Sie Ihr Datenobjekt anstelle von data an die Option json:

response = requests.post('https://api.example.com/product', json=product)

Entsprechend können Sie dieselbe Request mit request.request() wie folgt ausführen:

import requests

product = {

'name': 'Limitor 500',

'description': 'The Limitor 500 is a high-performance electronic device designed to regulate power consumption in industrial settings. It offers advanced features such as real-time monitoring, adjustable settings, and remote access for efficient energy management.',

'price': 199.99,

'manufacturer': 'TechCorp Inc.',

'category': 'Electronics',

'availability': 'In Stock'

}

response = requests.request('POST', 'https://api.example.com/product', data=product)

PUT

Die PUT -Methode wird verwendet, um eine Ressource auf dem Server zu aktualisieren oder zu ersetzen. Das Senden einer PUT-Request mit dem Python-Requests-Modul ist einfach und folgt einem ähnlichen Muster wie bei POST-Requests. Was sich ändert, ist, dass die zu verwendende Methode requests.put() ist. Außerdem ist der HTTP-Methode-String in requests.request() 'PUT'.

PATCH

Die PATCH -Methode wird verwendet, um teilweise Änderungen an einer Online-Ressource vorzunehmen. Genau wie bei PUT-Requests ähnelt das Senden von PATCH-Requests in der Python-Requests-Bibliothek POST-Requests. Was sich ändert, ist, dass die anzuwendende Methode requests.patch() und der HTTP-Methode-String in requests.request() 'PATCH' ist.

DELETE

Die DELETE -Methode wird verwendet, um eine Ressource zu löschen, die durch einen bestimmten URI identifiziert wird. So führen Sie eine HTTP-DELETE -Request in Requests mit der delete()-Methode aus:

import requests

# send a DELETE request for the product with id = 75

response = requests.delete('https://api.example.com/products/75')

Entsprechend können Sie eine DELETE-Request mit requests.request() ausführen:

import requests

response = requests.request('DELETE', 'https://api.example.com/products/75')

HEAD

Die HEAD -Methode ähnelt GET, aber sie fordert nur die Header der Response an, ohne den eigentlichen Textinhalt. Die Response, die der Server für eine HEAD-Request zurückgibt, entspricht also der einer GET-Request, jedoch ohne Textdaten.

Verwenden Sie requests.head(), um eine HTTP-HEAD-Request in Python zu auszuführen:

import requests

# send a HEAD request to the specified URL

response = requests.head('https://api.example.com/resource')

Auf die gleiche Weise können Sie eine HEAD-Request mit requests.request() ausführen:

import requests

response = requests.request('HEAD', 'https://api.example.com/resource')

Ein Response-Objekt aus Requests aufschlüsseln

Jetzt, da Sie wissen, wie man HTTP-Requests mit Request ausführt, ist es an der Zeit, zu sehen, wie man mit Response-Objekten umgeht.

Response-Objekt

Nach einer HTTP-Request erhalten Requests die Response vom Server und ordnen sie einem speziellen Response-Objekt zu.

Schauen Sie sich das folgende Beispiel für Python-Requests an:

import requests

response = requests.get('http://lumtest.com/myip.json')

print(response)

Das Ergebnis sieht folgendermaßen aus:

<Response [200]>

Response ist ein Response-Objekt, das einige nützliche Methoden und Eigenschaften bereitstellt. Erkunden Sie die wichtigsten in den nächsten Abschnitten!

Warnung: Requests geben nicht immer eine Antwort zurück. Im Falle von Fehlern (z. B. einer ungültigen URL) wird eine RequestException ausgelöst. Schützen Sie sich mit der folgenden Logik vor dieser Ausnahme:

try:

response = requests.get('http://lumtest.com/myip.json')

# handle the response

except requests.exceptions.RequestException as e:

print('An error occurred during the request:', e)

Statuscodes

Wenn es um HTTP geht, sind Response-Statuscodes standardisierte Werte, die vom Server zurückgegeben werden, um den Erfolg, Misserfolg oder eine andere Bedingung der Request anzuzeigen. Diese Statuscodes sind so wichtig, weil sie sofort Feedback darüber geben, ob die Request erfolgreich war oder nicht, und wenn nicht, was schiefgelaufen ist.

Sie sind besonders hilfreich bei der Fehlerbehandlung, da sie es dem Client ermöglichen, verschiedene Arten von Fehlern zu erkennen und entsprechend zu behandeln. Beispielsweise weist ein 4xx-Statuscode auf einen clientseitigen Fehler hin (z. B. eine ungültige Request), während ein 5xx-Statuscode auf einen serverseitigen Fehler hinweist.

Die Kontrolle des Statuscodes ist in der Regel der erste Schritt bei der Bearbeitung einer Response in Python unter Verwendung der Requests-Bibliothek. Nachdem Sie eine Request ausgeführt haben, sollten Sie immer den Statuscode der Response überprüfen, um festzustellen, ob die Request erfolgreich war oder nicht. Greifen Sie über das Attribut status_code des Response-Objekts auf den Statuscode zu:

response.status_code # 200

Abhängig vom empfangenen Statuscode sollten Sie bedingte Anweisungen verwenden, um verschiedene Szenarien angemessen zu behandeln:

import requests

response = requests.get('http://lumtest.com/myip.json')

# check if the request was successful (status code 200)

if response.status_code == 200:

print('Successful request!')

# handle the response...

elif response.status_code == 404:

print('Resource not found!')

else:

print(f'Request failed with status code: {response.status_code}')

In den meisten Szenarien müssen Sie nur zwischen einer erfolgreichen Request und einer Fehlerantwort unterscheiden. Requests vereinfacht diesen Vorgang dank einer benutzerdefinierten __bool()__-Überladung. Insbesondere können Sie ein Response-Objekt direkt in einem bedingten Ausdruck verwenden. Dadurch wird True ausgewertet, wenn der Statuscode zwischen 200 und 399 liegt, andernfalls als False.

Mit anderen Worten, es ist möglich, das erfolgreiche Ergebnis einer Request mit dieser Logik zu überprüfen:

if response:

print('Successful request!')

# handle the response...

else:

print(f'Request failed with status code: {response.status_code}')

Response-Header

Greifen Sie über das Attribut Headers auf die Header einer Server-Response zu:

import requests

response = requests.get('http://lumtest.com/myip.json')

response_headers = response.headers

print(response_headers)

Das wird gedruckt:

{'Server': 'nginx', 'Date': 'Thu, 09 May 2024 12:51:08 GMT', 'Content-Type': 'application/json; charset=utf-8', 'Content-Length': '279', 'Connection': 'keep-alive', 'Cache-Control': 'no-store', 'Access-Control-Allow-Origin': '*'}

Wie Sie sehen können, gibt response.headers ein Dictionary-ähnliches Objekt zurück. Das bedeutet, dass Sie per Schlüssel auf Header-Werte zugreifen können. Nehmen wir beispielsweise an, Sie möchten auf den Content-Type-Header der Response zugreifen. Im Folgenden erfahren Sie, wie Sie das tun können:

response_headers['Content-Type'] # 'application/json; charset=utf-8'

Da die HTTP-Spezifikation Header als unabhängig von Groß- und Kleinschreibung definiert, können Sie mit Requests auf sie zugreifen, ohne sich Gedanken über ihre Groß- und Kleinschreibung machen zu müssen:

response_headers['content-type'] # 'application/json; charset=utf-8'

Response-Inhalt

Requests bietet verschiedene Attribute und Methoden, um auf die Nutzdaten einer Response zuzugreifen:

• response.content: Gibt den Inhalt der Response in Byte zurück.
• response.text: Gibt den Inhalt der Response als Zeichenfolge in Unicode zurück.
• response.json(): Gibt den JSON-kodierten Inhalt der Response in einem Dictionary zurück.

Sehen Sie sie im folgenden Beispiel in Aktion:

import requests

response = requests.get('http://lumtest.com/myip.json')

# access the response as bytes

response_bytes = response.content

print(type(response_bytes))

print(response_bytes)

print()

# retrieve the response as text

response_text = response.text

print(type(response_text))

print(response_text)

print()

# retrieve the response as a JSON-encoded dictionary

response_json = response.json()

print(type(response_json))

print(response_json)

print()

http://lumtest.com/myip.json ist ein spezieller Endpunkt, der Informationen über die IP des Anrufers zurückgibt. Das Ergebnis des obigen Snippets wird ungefähr so aussehen:

<class 'bytes'>

b'{"ip":"45.85.135.110","country":"US","asn":{"asnum":62240,"org_name":"Clouvider Limited"},"geo":{"city":"Ashburn","region":"VA","region_name":"Virginia","postal_code":"20149","latitude":39.0469,"longitude":-77.4903,"tz":"America/New_York","lum_city":"ashburn","lum_region":"va"}}'

<class 'str'>

{"ip":"45.85.135.110","country":"US","asn":{"asnum":62240,"org_name":"Clouvider Limited"},"geo":{"city":"Ashburn","region":"VA","region_name":"Virginia","postal_code":"20149","latitude":39.0469,"longitude":-77.4903,"tz":"America/New_York","lum_city":"ashburn","lum_region":"va"}}

<class 'dict'>

{'ip': '45.85.135.110', 'country': 'US', 'asn': {'asnum': 62240, 'org_name': 'Clouvider Limited'}, 'geo': {'city': 'Ashburn', 'region': 'VA', 'region_name': 'Virginia', 'postal_code': '20149', 'latitude': 39.0469, 'longitude': -77.4903, 'tz': 'America/New_York', 'lum_city': 'ashburn', 'lum_region': 'va'}}

Beachten Sie die drei verschiedenen Response-Formate. Als Dictionary ist response.json() besonders nützlich, da es den Datenzugriff vereinfacht:

response_json['country'] # 'US'

Weitere Informationen finden Sie in unserem Leitfaden zum Parsen von JSON in Python.

Response-Cookies

Während HTTP-Cookies über Header definiert werden, bietet das Response-Objekt ein spezielles Cookies-Attribut, um mit ihnen umzugehen. Dies gibt ein http.cookiejar-Objekt mit den Cookies zurück, die der Server zurückgesendet hat.

Schauen Sie sich das folgende Beispiel an, das zeigt, wie Sie von einem Response-Objekt aus der Python.Requests-Bibliothek auf Cookies zugreifen:

import requests

# define the login credentials

credentials = {

'username': 'example_user',

'password': 'example_password'

}

# send a POST request to the login endpoint

response = requests.post('https://www.example.com/login', data=credentials)

# access the cookies set by the server

cookies = response.cookies

# print the cookies received from the server

for cookie in cookies:

print(cookie.name, ':', cookie.value)

Das obige Beispiel-Snippet könnte so etwas ergeben:

session_id : be400765483cf840dfbbd39

user_id : 7164

expires : Sat, 01 Jan 2025 14:30:00 GMT

Anpassung mit der Python-Requests-Bibliothek anfordern

HTTP-Requests beinhalten oft spezielle Filterparameter und benutzerdefinierte Header. Schauen wir uns an, wie man sie in Requests spezifiziert.

Abfrage-String-Parameter

Abfrageparameter, auch als URL-Parameter bekannt, sind zusätzliche Parameter, die in einer HTTP-Request an das Ende einer URL angehängt werden. Sie stellen dem Server zusätzliche Informationen über die Request zur Verfügung, in der Regel darüber, wie Daten gefiltert und die Response angepasst werden.

Betrachten Sie diese URL:

https://api.example.com/data?key1=value1&key2=value2

In diesem Beispiel ist ?key1=value1&key2=value2 der Abfrage-String, während key1 und key2 Abfrageparameter sind.

Ein Abfrage-String beginnt mit ? und besteht aus einem Schlüssel-Wert-Paar, das durch ein Gleichheitszeichen (=) getrennt und durch & verkettet ist. Die programmgesteuerte Angabe dieses Abfrage-Strings im Python-Code ist nicht immer einfach, insbesondere wenn es um optionale Parameter geht. Aus diesem Grund bietet Requests die Option params an:

import requests

# define query parameters as a dictionary

params = {

'page': 1,

'limit': 10,

'category': 'electronics'

}

# send a GET request to the following URL:

# 'https://api.example.com/products?page=1&limit=10&category=electronics'

response = requests.get('https://api.example.com/products', params=params)

Entsprechend können Sie die Parameter an Requests als Liste von Tupeln übergeben:

import requests

# define query parameters as a list of tuples

params = [

('page', '1'),

('limit', '10'),

('category', 'electronics')

]

response = requests.get('https://api.example.com/products', params=params)

Oder als Bytes-String:

import requests

# define query parameters as a bytes string

params = b'page=1&limit=10&category=electronics'

response = requests.get('https://api.example.com/products', params=params)

Request-Header

Um die Header in einer HTTP-Request in Requests anzupassen, übergeben Sie sie als Dictionary an die Option headers. Sie können beispielsweise einen benutzerdefinierten User-Agent-String in Requests mit Folgendem festlegen:

import requests

# define custom headers

custom_headers = {

'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',

# other headers...

}

# send a GET request with custom headers

response = requests.get('https://api.example.com/data', headers=custom_headers)

Request-Cookies

Während HTTP-Cookies über Header an den Server gesendet werden, bietet Requests eine spezielle Option für Cookies, um sie anzupassen. Verwenden Sie sie wie im folgenden Beispiel:

# define custom cookies

custom_cookies = {

'session_id': 'be400765483cf840dfbbd39',

'user_id': '7164'

}

# send a GET request with custom cookies

response = requests.get('https://www.example.com', cookies=custom_cookies)

Beachten Sie, dass cookies ein Dictionary oder ein http.cookiejar-Objekt akzeptiert.

Andere Konfigurationen

Request bietet eine umfangreiche API und es stehen viele fortgeschrittene Techniken zur Verfügung. Entdecken Sie einige der relevantesten!

Proxy-Einrichtung

Die Proxy-Integration in Requests ermöglicht es Ihnen, Ihre HTTP-Request über einen Proxy-Server weiterzuleiten. Dies ist ein leistungsstarker Mechanismus, um Ihre IP-Adresse zu verbergen, Ratenbegrenzer zu umgehen oder auf geografisch eingeschränkte Inhalte zuzugreifen.

Sie können einen Proxy-Server in die Python-Requests-Bibliothek integrieren, indem Sie die Option Proxys verwenden:

import requests

# define the proxy settings

proxy = {

'http': 'http://username:[email protected]:8080',

'https': 'https://username:[email protected]:8080'

}

# Make a request using the proxy

response = requests.get('https://www.example.com', proxies=proxy)

Ein vollständiges Tutorial finden Sie in unserem Tutorial zur Verwendung eines Proxys mit Python-Requests.

Grundlegende Authentifizierung

Die HTTP-Authentifizierung, besser bekannt als „Standardauthentifizierung“, ist ein einfaches Authentifizierungsschema, das in das HTTP-Protokoll integriert ist. Es umfasst das Senden eines Benutzernamens und eines Passworts, die im Base64-Format im Authentifizierungs-Header kodiert sind.

Obwohl Sie sie implementieren könnten, indem Sie den Authentifizierungs-Header manuell setzen, stellt Requests eine dedizierte auth-Option dafür bereit. Dies akzeptiert ein Tupel mit dem Benutzernamen und dem Passwort. Verwenden Sie es, um die grundlegende Authentifizierung in der Requests-Python-Bibliothek zu erledigen:

import requests

# define the username and password for basic authentication

username = 'sample_username'

password = 'sample_password'

# send a GET request with basic authentication

response = requests.get('https://api.example.com/private/users', auth=(username, password))

Überprüfung des SSL-Zertifikats

Die Überprüfung des SSL-Zertifikats ist entscheidend für die sichere Kommunikation zwischen Clients und Servern über das Internet. Gleichzeitig gibt es Situationen, in denen Sie dem Zielserver vertrauen und keine Überprüfung erzwingen müssen.

Insbesondere beim Routing von HTTP-Traffic über Proxy-Server können Fehler im Zusammenhang mit SSL-Zertifikaten auftreten. In diesem Fall müssen Sie möglicherweise die SSL-Zertifikatsüberprüfung deaktivieren. Bei Requests ist dies über die Option verify möglich:

import requests

# send a GET request to a website with SSL certificate verification disabled

response = requests.get('https://api.example.com/data', verify=False)

Timeouts

Standardmäßig warten Requests automatisch auf unbestimmte Zeit, bis der Server antwortet. Wenn der Server überlastet ist oder das Netzwerk verlangsamt wird, kann dieses Verhalten zu einem Problem werden.

Um zu vermeiden, dass Ihre Anwendung verlangsamt wird, während Sie auf eine Response warten, die möglicherweise nie eintrifft, haben Requests eine timeout -Option. Dies akzeptiert eine Ganzzahl oder eine Gleitzahl, die die Anzahl der Sekunden angibt, die auf eine Response gewartet werden muss:

import requests

# timeout after 2 second

response1 = requests.get("https://api.example.com/data", timeout=2)

Alternativ akzeptiert timeout ein Tupel mit zwei Elementen: connect timeout und read timeout. Geben Sie sie wie im folgenden Beispiel an:

import requests

# timeout after 2.5 seconds for connections and 4 seconds for reading response

response = requests.get("https://api.example.com/data", timeout=(2.5, 4))

Wenn die Request innerhalb des angegebenen Verbindungs-Timeouts eine Verbindung aufbaut und innerhalb des Lese-Timeouts Daten empfängt, wird die Response wie gewohnt zurückgegeben. Andernfalls wird bei einem Timeout der Request eine Timeout-Ausnahme ausgelöst:

import requests

from requests.exceptions import Timeout

try:

response = requests.get("https://api.example.com/data", timeout=(2.5, 4))

except Timeout:

print("The request timed out")

Fazit

In diesem Artikel haben Sie sich mit der Requests-Bibliothek befasst und verstanden, was sie ist, welche Methoden sie hat, wie sie verwendet werden und vieles mehr. Sie haben gelernt, dass das Python-Requests-Modul eine nützliche und beliebte HTTP-Bibliothek ist, die mehrere Anwendungsfälle abdeckt.

Das Problem ist, dass jede HTTP-Request Ihre öffentliche IP preisgibt. Dies liefert Informationen darüber, wer Sie sind und wo Sie leben, was nicht gut hinsichtlich Datenschutz ist. Es gibt mehrere Möglichkeiten, Ihre IP-Adresse zu verbergen. Die effektivste Methode, um mehr Sicherheit und Datenschutz zu erreichen, ist die Verwendung eines Proxy-Servers.

Bright Data kontrolliert die besten Proxy-Server der Welt und betreut Fortune-500-Unternehmen und mehr als 20.000 Kunden. Das Angebot umfasst eine breite Palette von Proxy-Arten:

• Rechenzentrums-Proxys – Über 770.000 Rechenzentrum-IPs.
• Privatanwender-Proxys – Über 72 Millionen Privatanwender-IPs in mehr als 195 Ländern.
• IDA-Proxys – Über 700.000 IDA-IPs.
• Mobile Proxys – Über 7 Millionen mobile IPs.