---
title: "Eine vollständiger Leitfaden zur Python-Requests-Bibliothek"
slug: python-requests-guide
date: 2024-05-19T06:55:35+00:00
modified: 2026-04-20T11:24:28+00:00
permalink: https://brightdata.de/blog/web-data-de/python-requests-guide
type: blog
---
[ Blog ](https://brightdata.de/blog "Blog") / [Web Data](https://brightdata.de/blog/web-data-de)
[Web Data](https://brightdata.de/blog/web-data-de)
# Eine vollständiger Leitfaden zur Python-Requests-Bibliothek
Erfahren Sie, wie Sie die Python-Requests-Bibliothek für Web Scraping verwenden, einschließlich Installation, HTTP-Methoden und Serverantworten.
16 min lesen
[  ](https://brightdata.com/blog/authors/antonello-zanini)
[Antonello Zanini
Technical Writer
](https://brightdata.com/blog/authors/antonello-zanini)
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](https://github.com/psf/requests) 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](https://datatracker.ietf.org/doc/html/rfc2616).
**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:
```none
`pip install requests`
```
Um `Requests `in Ihrem Python-Skript zu verwenden, importieren Sie es mit der folgenden Zeile:
```none
`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](https://brightdata.de/blog/wie/web-scraping-with-python).
- **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:
**Methode****Beschreibung**[`requests.request()`](https://requests.readthedocs.io/en/latest/api/#requests.request)Sendet eine benutzerdefinierte HTTP-Request mit der angegebenen Methode an die angegebene URL[`requests.get()`](https://requests.readthedocs.io/en/latest/api/#requests.get)Sendet eine `GET`-Request an die angegebene URL[`requests.post()`](https://requests.readthedocs.io/en/latest/api/#requests.post)Sendet eine `POST`-Request an die angegebene URL[`requests.put()`](https://requests.readthedocs.io/en/latest/api/#requests.put)Sendet eine `PUT`-Request an die angegebene URL[`requests.patch()`](https://requests.readthedocs.io/en/latest/api/#requests.patch)Sendet eine `PATCH`-Request an die angegebene URL[`requests.delete()`](https://requests.readthedocs.io/en/latest/api/#requests.delete)Sendet eine `DELETE`-Request an die angegebene URL[`requests.head()`](https://requests.readthedocs.io/en/latest/api/#requests.head)Sendet eine `HEAD`-Request an die angegebene URLWie Sie sehen, decken diese die nützlichsten HTTP-Request-Methoden ab. Weitere Informationen zur Verwendung finden Sie in der offiziellen [API-Dokumentation](https://requests.readthedocs.io/en/latest/api/).
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:
```none
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:
```none
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:
```none
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`:
```none
`response = requests.post('https://api.example.com/product', json=product)`
```
Entsprechend können Sie dieselbe Request mit `request.request()` wie folgt ausführen:
```none
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:
```none
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:
```none
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:
```none
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:
```none
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](https://requests.readthedocs.io/en/latest/api/#requests.Response)-Objekt zu.
Schauen Sie sich das folgende Beispiel für Python-`Requests` an:
```none
import requests
response = requests.get('http://lumtest.com/myip.json')
print(response)
```
Das Ergebnis sieht folgendermaßen aus:
```none
``
```
`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:
```none
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](/blog/proxy-101/proxy-error-codes) 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:
```none
`response.status_code # 200`
```
Abhängig vom empfangenen Statuscode sollten Sie bedingte Anweisungen verwenden, um verschiedene Szenarien angemessen zu behandeln:
```none
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()__`](https://www.pythontutorial.net/python-oop/python-__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:
```none
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:
```none
import requests
response = requests.get('http://lumtest.com/myip.json')
response_headers = response.headers
print(response_headers)
```
Das wird gedruckt:
```none
`{'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:
```none
`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:
```none
`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`](https://requests.readthedocs.io/en/latest/api/#requests.Response.content): Gibt den Inhalt der Response in Byte zurück.
- [`response.text`](https://requests.readthedocs.io/en/latest/api/#requests.Response.text): Gibt den Inhalt der Response als Zeichenfolge in Unicode zurück.
- [`response.json()`](https://requests.readthedocs.io/en/latest/api/#requests.Response.json): Gibt den JSON-kodierten Inhalt der Response in einem Dictionary zurück.
Sehen Sie sie im folgenden Beispiel in Aktion:
```none
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:
```none
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"}}'
{"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"}}
{'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:
```none
`response_json['country'] # 'US'`
```
Weitere Informationen finden Sie in unserem [Leitfaden zum Parsen von JSON in Python](https://brightdata.de/blog/wie/parse-json-data-with-python).
**Response-Cookies**
Während [HTTP-Cookies](https://brightdata.de/blog/web-data-de/http-cookies) über Header definiert werden, bietet das `Response`-Objekt ein spezielles `Cookies`-Attribut, um mit ihnen umzugehen. Dies gibt ein [http.cookiejar](https://docs.python.org/3/library/http.cookiejar.html)-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:
```none
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:
```none
session_id : be400765483cf840dfbbd39
user_id : 7164
expires : Sat, 01 Jan 2026 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](https://www.semrush.com/blog/url-parameters/), 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:
```none
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:
```none
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:
```none
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:
```none
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:
```none
# 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:
```none
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](https://brightdata.de/blog/proxys-101/proxy-with-python-requests).
**Grundlegende Authentifizierung**
[Die HTTP-Authentifizierung](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication), 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](https://developer.mozilla.org/en-US/docs/Glossary/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:
```none
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:
```none
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:
```none
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:
```none
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:
```none
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](https://brightdata.de/blog/wie/funf-moglichkeiten-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.[](https://brightdata.de/proxy-types/datacenter-proxies)
- Privatanwender-Proxys – Über 400M+ monthly Privatanwender-IPs in mehr als 195 Ländern.[](https://brightdata.de/proxy-types/residential-proxies)
- IDA-Proxys – Über 700.000 IDA-IPs.[](https://brightdata.de/proxy-types/isp-proxies)
Vertrieb kontaktierenGratis testen
Inhaltsverzeichnis
Dedicated Scraper APIs & No-Code Scrapers
Over 1000 scrapers for all popular domains. Simplify your web scraping.
[See pricing](/pricing/web-scraper "See pricing")
Just want data? Skip scraping.
Hundreds of ready-to-use datasets from all popular domains.
[See pricing](/pricing/datasets "See pricing")
[ ](https://news.ycombinator.com/submitlink?t=Eine+vollst%C3%A4ndiger+Leitfaden+zur+Python-Requests-Bibliothek&u=https://brightdata.de/blog/web-data-de/python-requests-guide) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Eine+vollst%C3%A4ndiger+Leitfaden+zur+Python-Requests-Bibliothek&url=https://brightdata.de/blog/web-data-de/python-requests-guide) [ ](http://www.reddit.com/submit?title=Eine+vollst%C3%A4ndiger+Leitfaden+zur+Python-Requests-Bibliothek&url=https://brightdata.de/blog/web-data-de/python-requests-guide)
## Das könnte Sie auch interessieren
[  ](https://brightdata.de/blog/wie/parsing-xml-in-python "Anleitung zum Parsing von XML in Python")
[How Tos
Vikram Aruchamy
### Anleitung zum Parsing von XML in Python
Lernen Sie, wie Sie XML in Python mit Bibliotheken wie ElementTree, lxml und SAX parsen können, um Ihre Datenverarbeitungsprojekte zu verbessern.
22-Feb-2026
2 min lesen
](https://brightdata.de/blog/wie/parsing-xml-in-python)
[  ](https://brightdata.de/blog/wie/scrape-images-from-websites "Scraping von Bildern aus einer Website in Python")
[How Tos
Antonello Zanini
Technical Writer
### Scraping von Bildern aus einer Website in Python
Erfahren Sie, wie Sie mithilfe von Python und Selenium spielend leicht Bilder von Websites scrappen und dadurch die Datenerfassung für maschinelles Lernen, Marktanalysen und Content-Curation verbessern können.
02-Apr-2024
16 min lesen
](https://brightdata.de/blog/wie/scrape-images-from-websites)
[  ](https://brightdata.de/blog/wie/web-scraping-with-python "Web Scraping mit Python – Schritt-für-Schritt-Anleitung")
[How Tos
Antonello Zanini
Technical Writer
### Web Scraping mit Python – Schritt-für-Schritt-Anleitung
Lernen Sie, Web Scraping mit Python durchzuführen, um schnell Daten von mehreren Websites zu sammeln und so Zeit und Mühe zu sparen.
29-Nov-2022
21 min lesen
](https://brightdata.de/blog/wie/web-scraping-with-python)