Dieses Tutorial zeigt Möglichkeiten, mit der Requests Library in Python für Web-Scraping zu arbeiten:
- Einführung in die Requests Library
- HTTP-Methoden
- Aufschlüsselung eines Response-Objekts aus Requests
- Anfrageanpassung mit der Python Requests Library
- Weitere Konfigurationen
Requests ist ein unkompliziertes und benutzerfreundliches HTTP-Toolkit für Python. Im Detail stellt es eine intuitive API bereit, um HTTP-Anfragen zu stellen und Antworten auf einfache und leicht verständliche Weise zu verarbeiten. Mit über 50k Stars auf GitHub und Millionen täglichen Downloads ist Requests der beliebteste HTTP-Client in Python.
Zu den wichtigsten Funktionen dieser Library gehören eine umfassende API, die alle HTTP-Methoden abdeckt, der Umgang mit Serverantworten, die Anpassung von Anfragen, Login-Mechanismen, die Handhabung sicherer Zertifikate und vieles mehr. Darüber hinaus unterstützt das Python-Requests-Modul sofort HTTP/1.1.
Der einfachste und empfohlene Weg, Requests zu installieren, ist über pip. Insbesondere heißt das zugehörige pip-Paket zur Requests Library requests. So können Sie den HTTP-Client mit folgendem Befehl installieren:
pip install requestsUm requests in Ihrem Python-Skript zu verwenden, importieren Sie es mit der folgenden Zeile:
import requestsPerfekt! Das Requests-Paket ist nun installiert und einsatzbereit.
Die wichtigsten Anwendungsfälle der Python-requests-Library umfassen:
- HTTP-Anfragen an Webserver stellen: Abrufen von Daten von Webservern durch das Senden von GET-Anfragen.
- APIs konsumieren: Senden von Anfragen an API-Endpunkte und Verarbeitung ihrer Antworten, Interaktion mit verschiedenen Webdiensten und Zugriff auf deren Daten.
- Web-Scraping: Abrufen von HTML-Dokumenten, die zu Webseiten gehören und anschließend mit Libraries wie
BeautifulSoupgeparst werden können, um spezifische Informationen zu extrahieren. - Webanwendungen testen: Simulation von HTTP-Anfragen und Verifizierung der Antworten, Automatisierung des Testprozesses und Sicherstellung der korrekten Funktion von Webdiensten.
- Dateien herunterladen: Abrufen von Dateien von Webservern, wie Bilder, Dokumente oder andere Mediendateien, durch das Senden von HTTP-
GET-Anfragen an die jeweiligen URLs.
Methoden
Werfen Sie einen Blick auf die öffentlichen Methoden, die von der requests-Library bereitgestellt werden, in der folgenden Tabelle:
| Method | Description |
requests.request() |
Sendet eine benutzerdefinierte HTTP-Anfrage mit der angegebenen Methode an die gegebene URL |
requests.get() |
Sendet eine GET-Anfrage an die angegebene URL |
requests.post() |
Sendet eine POST-Anfrage an die angegebene URL |
requests.put() |
Sendet eine PUT-Anfrage an die angegebene URL |
requests.patch() |
Sendet eine PATCH-Anfrage an die angegebene URL |
requests.delete() |
Sendet eine DELETE-Anfrage an die angegebene URL |
requests.head() |
Sendet eine HEAD-Anfrage an die angegebene URL |
Diese decken die nützlichsten HTTP-Anfragemethoden ab. Erfahren Sie mehr über deren Verwendung in der offiziellen API-Dokumentation.
Sehen Sie die Python-requests-Library in Aktion beim Umgang mit den Methoden GET, POST, PUT, DELETE und HEAD in HTTP.
In HTTP wird die Methode GET verwendet, um eine bestimmte Ressource von einem Server anzufordern. So können Sie mit requests.get() eine HTTP-GET-Anfrage stellen:
import requests
# send a GET request to the specified URL
response = requests.get('https://api.example.com/data')Sie können das gleiche 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 über eine zusätzliche String-Variable angeben.
Die HTTP-Methode POST wird verwendet, um Daten an einen Server zur weiteren Verarbeitung zu übermitteln. So stellen Sie eine POST-Anfrage mit requests.post():
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-Anfrage müssen Sie diesmal auch die Daten angeben, die über die Option data an den Server gesendet werden sollen. requests fügt diese Daten dem Body der HTTP-Anfrage hinzu.
Für JSON-Bodies übergeben Sie Ihr Datenobjekt an die Option json statt an data:
response = requests.post('https://api.example.com/product', json=product)Entsprechend können Sie dieselbe Anfrage wie folgt mit request.request() 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)Die Methode PUT wird verwendet, um eine Ressource auf dem Server zu aktualisieren oder zu ersetzen. Das Senden einer PUT-Anfrage mit dem Python-requests-Modul ist einfach und folgt einem ähnlichen Muster wie bei POST-Anfragen. Was sich ändert, ist, dass die zu verwendende Methode requests.put() ist. Außerdem lautet der HTTP-Methoden-String in requests.request() 'PUT'.
Die Methode PATCH wird verwendet, um partielle Änderungen an einer Online-Ressource vorzunehmen. Genau wie bei PUT-Anfragen ist das Senden von PATCH-Anfragen in der Python-requests-Library ähnlich zu POST-Anfragen. Was sich ändert, ist, dass die zu verwendende Methode requests.patch() ist und der HTTP-Methoden-String in requests.request() 'PATCH' lautet.
Die Methode DELETE wird verwendet, um eine durch eine bestimmte URI identifizierte Ressource zu löschen. So stellen Sie in requests mit der Methode delete() eine HTTP-DELETE-Anfrage:
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-Anfrage auch mit requests.request() ausführen:
import requests
response = requests.request('DELETE', 'https://api.example.com/products/75')Die Methode HEAD ist ähnlich zu GET, fordert jedoch nur die Header der Antwort an, ohne den eigentlichen Body-Inhalt. Daher ist die vom Server zurückgegebene Antwort für eine HEAD-Anfrage äquivalent zu der einer GET-Anfrage, jedoch ohne Body-Daten.
Verwenden Sie requests.head(), um in Python eine HTTP-HEAD-Anfrage zu stellen:
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-Anfrage auch mit requests.request() ausführen:
import requests
response = requests.request('HEAD', 'https://api.example.com/resource')Sehen wir uns an, wie Sie mit Response-Objekten umgehen.
Nach dem Stellen einer HTTP-Anfrage empfängt requests die Antwort vom Server und bildet sie in ein spezielles Response-Objekt ab.
Werfen Sie einen Blick auf das folgende Python-requests-Beispiel:
import requests
response = requests.get('http://lumtest.com/myip.json')
print(response)Dies gibt zurück:
<Response [200]>response ist ein Response-Objekt, das einige nützliche Methoden und Eigenschaften bereitstellt. Entdecken Sie die wichtigsten davon in den nächsten Abschnitten!
Warning:
requestsgeben nicht immer eine Antwort zurück. Im Fehlerfall (z. B. bei einer ungültigen URL) wird eineRequestExceptionausgelöst. Schützen Sie sich mit der folgenden Logik vor dieser Exception:
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)Response-Statuscodes sind standardisierte Werte, die vom Server zurückgegeben werden, um den Erfolg, Misserfolg oder einen anderen Zustand der Anfrage anzuzeigen.
Sie sind besonders hilfreich bei der Fehlerbehandlung, da sie dem Client ermöglichen, verschiedene Fehlertypen zu erkennen und angemessen zu behandeln. Beispielsweise weist ein 4xx-Statuscode auf einen clientseitigen Fehler hin (z. B. eine ungültige Anfrage), während ein 5xx-Statuscode auf einen serverseitigen Fehler hinweist.
Das Prüfen des Statuscodes ist in der Regel der erste Schritt bei der Verarbeitung einer Antwort in Python mit der requests-Library. Nach dem Stellen einer Anfrage sollten Sie immer den Statuscode der Antwort prüfen, um festzustellen, ob die Anfrage erfolgreich war oder nicht. Greifen Sie über das Attribut status_code des Response-Objekts auf den Statuscode zu:
response.status_code # 200Abhä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 Anfrage und einer Fehlerantwort unterscheiden. requests vereinfacht diesen Prozess dank einer benutzerdefinierten Überladung von __bool()__. Konkret können Sie ein Response-Objekt direkt in einem konditionalen Ausdruck verwenden. Das wird zu True ausgewertet, wenn der Statuscode zwischen 200 und 399 liegt, andernfalls zu False.
Mit anderen Worten: Es ist möglich, den erfolgreichen Ausgang einer Anfrage mit dieser Logik zu prüfen:
if response:
print('Successful request!')
# handle the response...
else:
print(f'Request failed with status code: {response.status_code}')
Greifen Sie über das Attribut headers auf die Header einer Serverantwort zu:
import requests
response = requests.get('http://lumtest.com/myip.json')
response_headers = response.headers
print(response_headers)Dies gibt aus:
{'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, gibt response.headers ein dictionary-ähnliches Objekt zurück. Das bedeutet, dass Sie Header-Werte über ihren Schlüssel abrufen können. Angenommen, Sie möchten auf den Content-Type-Header der Antwort zugreifen. So können Sie das tun:
response_headers['Content-Type'] # 'application/json; charset=utf-8'Da die HTTP-Spezifikation Header als nicht case-sensitiv definiert, ermöglicht requests den Zugriff darauf, ohne sich um die Groß-/Kleinschreibung zu kümmern:
response_headers['content-type'] # 'application/json; charset=utf-8'requests bietet verschiedene Attribute und Methoden, um auf die Nutzlast einer Antwort zuzugreifen:
response.content: Gibt den Inhalt der Antwort als Bytes zurück.response.text: Gibt den Inhalt der Antwort als Unicode-String zurück.response.json(): Gibt den JSON-kodierten Inhalt der Antwort als 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 Aufrufers zurückgibt. Das Ergebnis des obigen Snippets wird in etwa 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 Thema wie man JSON in Python parst.
Während HTTP Cookies über Header definiert werden, stellt das Response-Objekt ein spezielles Attribut cookies bereit, um damit umzugehen. Dieses gibt ein http.cookiejar-Objekt mit den Cookies zurück, die der Server zurückgesendet hat.
Werfen Sie einen Blick auf das folgende Beispiel, das zeigt, wie Sie Cookies aus einem Response-Objekt in der Python-requests-Library auslesen:
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 kann in etwa Folgendes erzeugen:
session_id : be400765483cf840dfbbd39
user_id : 7164
expires : Sat, 01 Jan 2025 14:30:00 GMT
HTTP-Anfragen beinhalten häufig spezielle Filter-Parameter und benutzerdefinierte Header. Sehen wir uns an, wie Sie diese in requests angeben.
Query-Parameter, auch bekannt als URL-Parameter, sind zusätzliche Parameter, die in einer HTTP-Anfrage an das Ende einer URL angehängt werden. Sie liefern dem Server zusätzliche Informationen über die Anfrage, meist darüber, wie Daten gefiltert und die Antwort angepasst werden soll.
Betrachten Sie diese URL:
https://api.example.com/data?key1=value1&key2=value2
In diesem Beispiel ist ?key1=value1&key2=value2 der Query-String, während key1 und key2 Query-Parameter sind.
Ein Query-String beginnt mit ? und besteht aus einem Schlüssel-Wert-Paar, getrennt durch ein Gleichheitszeichen (=) und verbunden durch &. Das programmgesteuerte Angeben dieses Query-Strings in Python-Code ist nicht immer einfach, insbesondere beim Umgang mit optionalen Parametern. Deshalb bietet requests die Option params:
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 auch als Liste von Tupeln an requests ü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)Um die Header in einer HTTP-Anfrage in requests anzupassen, übergeben Sie sie als Dictionary an die Option headers. Beispielsweise können Sie in requests einen benutzerdefinierten User-Agent-String setzen mit:
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)Während HTTP Cookies über Header an den Server gesendet werden, stellt requests eine dedizierte Option cookies zur Anpassung bereit. 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.
request bietet eine umfangreiche API und es gibt viele fortgeschrittene Techniken. Erkunden Sie einige der relevantesten!
Die Proxy-Integration in requests ermöglicht es Ihnen, Ihre HTTP-Anfragen über einen Proxy-Server zu leiten. Dies ist ein leistungsstarker Mechanismus, um Ihre IP-Adresse zu verbergen, Ratenbegrenzung zu umgehen oder auf geo-eingeschränkte Inhalte zuzugreifen.
Sie können einen Proxy-Server in die Python-requests-Library integrieren, indem Sie die Option proxies 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)Für ein vollständiges Tutorial folgen Sie unserem Leitfaden zur Verwendung eines Proxy mit Python Requests.
HTTP-Login-Mechanismen, besser bekannt als „Basic Login Mechanisms“, ist ein einfaches Login-Mechanismus-Schema, das in das HTTP-Protokoll integriert ist. Es beinhaltet das Senden eines Benutzernamens und Passworts, kodiert im Base64-Format, im Authorization-Header.
Obwohl Sie dies implementieren könnten, indem Sie den Authorization-Header manuell setzen, stellt requests dafür eine dedizierte Option auth bereit. Diese akzeptiert ein Tupel mit Benutzername und Passwort. Verwenden Sie sie, um in der Python-requests-Library mit Basic Login Mechanisms umzugehen:
import requests
# define the username and password for basic login mechanisms
username = 'sample_username'
password = 'sample_password'
# send a GET request with basic login mechanisms
response = requests.get('https://api.example.com/private/users', auth=(username, password))Die SSL-Zertifikatsverifizierung ist entscheidend, um eine sichere Kommunikation zwischen Clients und Servern über das Internet zu gewährleisten. Gleichzeitig gibt es Situationen, in denen Sie dem Zielserver vertrauen und die Verifizierung nicht erzwingen müssen.
Insbesondere beim Routen 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-Zertifikatsverifizierung deaktivieren. In 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)Standardmäßig wartet requests automatisch unbegrenzt auf eine Antwort des Servers. Wenn der Server überlastet ist oder eine Netzwerkverlangsamung vorliegt, kann dieses Verhalten problematisch werden.
Um zu vermeiden, dass Ihre Anwendung verlangsamt wird, während sie auf eine Antwort wartet, die möglicherweise nie eintrifft, bietet requests eine Option timeout. Diese akzeptiert eine Ganzzahl oder Fließkommazahl, die die Anzahl der Sekunden angibt, die auf eine Antwort gewartet werden soll:
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 diese 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 Anfrage innerhalb des angegebenen Connect-Timeouts eine Verbindung herstellt und innerhalb des Read-Timeouts Daten empfängt, wird die Antwort wie üblich zurückgegeben. Andernfalls wird, wenn ein Timeout eintritt, eine Timeout-Exception 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")Das Python-requests-Modul ist eine nützliche und beliebte HTTP-Library, die mehrere Anwendungsfälle abdeckt. Allerdings legt jede HTTP-Anfrage Ihre öffentliche IP-Adresse offen. Das liefert Informationen darüber, wer Sie sind und wo Sie leben, was nicht gut für Ihre Privatsphäre ist.
Es gibt mehrere Möglichkeiten, Ihre IP-Adresse zu verbergen, und der effektivste Weg zu mehr Sicherheit und Privatsphäre ist die Nutzung eines Proxy-Servers. Bright Data betreibt die besten Proxy-Server der Welt und bedient Fortune-500-Unternehmen sowie mehr als 20.000 Kunden.
Registrieren Sie sich und starten Sie noch heute eine kostenlose Testversion!