Python Requests-Bibliothek Snippets

1 Einführung in Python Requests

Die requests-Bibliothek ist Pythons elegante HTTP-Client, die API-Aufrufe zum Kinderspiel macht. Sie abstrahiert die kniffligen Details von HTTP und behält gleichzeitig die Leistung im Hintergrund. Stellen Sie sie sich als Ihren zuverlässigen Kurier für das Internet vor – er kümmert sich um alles, von einfachen Seitenabrufen bis hin zu komplexen Authentifizierungsabläufen.

Warum Entwickler sie lieben:

Menschlich lesbar: Die API liest sich wie eine klare englische Sprache statt kryptische HTTP-Jargon.
Integrierte JSON-Verarbeitung: Automatische Analyse eliminiert Boilerplate-Parsing-Probleme.
Sitzungsunterstützung: Behält Cookies und Verbindungspooling automatisch für Sie bei.
Robuste Fehlerbehandlung: Klare Ausnahmen anstelle von kryptischen Statuscodes.
SSL-Verifizierung: Standardmäßig sicher, flexibel bei Bedarf.

Bereit, Daten abzurufen? Beginnen wir mit den Grundlagen.

2 Voraussetzungen: Python & Pip

Sie benötigen Python 3.6+ und pip, um die requests-Bibliothek zu installieren. Überprüfen wir Ihre Einrichtung:

python --version && pip --version

Wenn diese Befehle funktionieren, sind Sie bestens vorbereitet. Wenn nicht, laden Sie Python von python.org herunter, und pip wird mitgeliefert.

3 Installieren Sie die Requests-Bibliothek

Erstellen wir zunächst eine neue virtuelle Umgebung – dies hält Ihre Projektabhängigkeiten sauber und verhindert Versionskonflikte:

python -m venv .venv && source .venv/bin/activate  # macOS/Linux
# oder
python -m venv .venv && .venv\Scripts\activate  # Windows

Installieren Sie jetzt requests mit pip:

pip install requests

4 Ihr erster GET-Request

Beginnen wir mit der gängigsten Operation – dem Abrufen von Daten. Dieses einfache Snippet holt eine JSON-Antwort von einer öffentlichen API:

import requests

response = requests.get('https://httpbin.org/json')
print(f"Status: {response.status_code}")
print(f"Content-Type: {response.headers['content-type']}")

# Automatische JSON-Verarbeitung
data = response.json()
print(f"Schlüssel: {list(data.keys())}")

Beachten Sie die automatische JSON-Verarbeitung – requests erkennt den Inhaltstyp und analysiert ihn für Sie. Kein manueller json.loads()-Tanz erforderlich.

5 POST-Requests mit Daten

Daten an einen Server senden? POST-Requests verarbeiten Formular-Daten, JSON und Dateien nahtlos. Hier sind die gängigen Muster:

import requests

# Formular-Daten senden
form_data = {'username': 'alice', 'password': 'secret123'}
response = requests.post('https://httpbin.org/post', data=form_data)

# JSON-Daten senden (setzt automatisch den Content-Type-Header)
json_data = {'name': 'Alice', 'email': '[email protected]'}
response = requests.post('https://httpbin.org/post', json=json_data)

print(f"Status: {response.status_code}")
print(f"Antwort: {response.json()}")

Der Parameter json setzt automatisch die richtigen Header und serialisiert Ihre Daten. Viel sauberer als manuelle Header-Einstellungen.

6 Benutzerdefinierte Header & Authentifizierung

APIs benötigen oft benutzerdefinierte Header und Authentifizierung. Requests macht dies mit integrierten Authentifizierungsklassen unkompliziert:

import requests
from requests.auth import HTTPBasicAuth, HTTPDigestAuth

# Benutzerdefinierte Header
headers = {
    'User-Agent': 'MyApp/1.0',
    'Accept': 'application/json',
    'X-API-Key': 'your-api-key-here'
}

response = requests.get('https://httpbin.org/headers', headers=headers)
print(response.json())

# Basic-Authentifizierung
auth = HTTPBasicAuth('username', 'password')
response = requests.get('https://httpbin.org/basic-auth/user/pass', auth=auth)

# API-Schlüssel im Header
api_key = 'sk-1234567890abcdef'
headers = {'Authorization': f'Bearer {api_key}'}
response = requests.get('https://httpbin.org/bearer', headers=headers)

HTTPBasicAuth und HTTPDigestAuth kümmern sich automatisch um die Codierung. Für moderne APIs sind Bearer-Tokens im Authorization-Header der Standard.

7 Fehlerbehandlung & Statuscodes

Robuste Anwendungen behandeln Fehler anmutig. Requests löst Ausnahmen für Netzwerkprobleme aus und stellt detaillierte Antwortobjekte bereit:

import requests
from requests.exceptions import RequestException, Timeout, ConnectionError

try:
    response = requests.get('https://httpbin.org/status/404', timeout=5)
    
    # Löst eine Ausnahme für fehlerhafte Statuscodes aus
    response.raise_for_status()
    
except Timeout:
    print("Request timed out after 5 seconds")
except ConnectionError:
    print("Failed to connect to server")
except RequestException as e:
    print(f"Request failed: {e}")
    
else:
    print(f"Success! Status: {response.status_code}")
    print(f"Headers: {response.headers}")
    print(f"Body: {response.text[:100]}...")  # Erste 100 Zeichen
    
# Manuelle Statuscode-Prüfung
if response.status_code == 200:
    data = response.json()
    print("Data received:", data)
elif response.status_code == 404:
    print("Resource not found")
else:
    print(f"Unexpected status: {response.status_code}")

raise_for_status() wirft einen HTTPError für 4xx/5xx-Antworten. Timeouts verhindern, dass Ihre Anwendung unendlich hängen bleibt.

8 JSON-Verarbeitung & Datenhandling

Effizientes Arbeiten mit JSON-Daten ist dort, wo requests glänzt. Es behandelt Kodierung, Dekodierung und Validierung automatisch:

import requests

# Komplexe JSON-Verarbeitung
response = requests.get('https://httpbin.org/json')

# Sichere JSON-Verarbeitung mit Fehlerbehandlung
try:
    data = response.json()
    print(f"Typ: {type(data)}")
    print(f"Schlüssel: {data.keys() if isinstance(data, dict) else 'Kein Dict'}")
except ValueError as e:
    print(f"Ungültiges JSON: {e}")
    print(f"Roher Inhalt: {response.text}")

# Arbeiten mit verschachtelten Daten
user_data = {
    'name': 'Alice Johnson',
    'email': '[email protected]',
    'preferences': {
        'theme': 'dark',
        'notifications': True,
        'language': 'en'
    }
}

# Komplexe verschachtelte JSON senden
response = requests.post('https://httpbin.org/post', json=user_data)
result = response.json()

# Verschachtelte Werte abrufen
nested = result.get('json', {}).get('preferences', {})
theme = nested.get('theme', 'light')
print(f"Benutzerthema: {theme}")

Verwenden Sie immer sichere Methoden wie get() beim Zugriff auf verschachtelte JSON-Daten, um KeyError-Ausnahmen zu vermeiden.

9 Datei-Downloads & Streaming

Effizientes Herunterladen von Dateien verhindert Speicherprobleme. Verwenden Sie Streaming für große Dateien und überprüfen Sie den Inhaltstyp:

import requests
import os
from pathlib import Path

# Datei herunterladen
url = 'https://httpbin.org/image/jpeg'
response = requests.get(url, stream=True)

if response.status_code == 200:
    # Downloads-Verzeichnis erstellen
    downloads_dir = Path('downloads')
    downloads_dir.mkdir(exist_ok=True)
    
    # Datei speichern
    file_path = downloads_dir / 'image.jpg'
    with open(file_path, 'wb') as f:
        for chunk in response.iter_content(chunk_size=8192):
            if chunk:  # Keep-alive-Chunks filtern
                f.write(chunk)
    
    print(f"Heruntergeladen {file_path} ({file_path.stat().st_size} Bytes)")
else:
    print(f"Download fehlgeschlagen: {response.status_code}")

# Dateiinformationen vor dem Download abrufen
head_response = requests.head(url)
content_length = head_response.headers.get('content-length')
content_type = head_response.headers.get('content-type')

print(f"Dateigröße: {content_length} Bytes")
print(f"Inhaltstyp: {content_type}")

# Download mit Fortschritt
def download_with_progress(url, filename):
    response = requests.get(url, stream=True)
    total_size = int(response.headers.get('content-length', 0))
    
    with open(filename, 'wb') as f:
        downloaded = 0
        for chunk in response.iter_content(chunk_size=1024):
            if chunk:
                f.write(chunk)
                downloaded += len(chunk)
                
                # Fortschritt anzeigen
                if total_size > 0:
                    progress = (downloaded / total_size) * 100
                    print(f"Fortschritt: {progress:.1f}%")

Stream-Downloads verhindern, dass ganze Dateien in den Speicher geladen werden. Perfekt für große Bilder, Dokumente oder Mediendateien.

10 Sitzungsverwaltung & Cookies

Für Anwendungen, die über Anfragen hinweg einen Zustand aufrechterhalten müssen – wie z. B. Login-Sitzungen – verwenden Sie requests Session-Objekte:

import requests

# Eine Sitzung für persistente Verbindungen und Cookies erstellen
session = requests.Session()

# Standard-Header für alle Anfragen festlegen
session.headers.update({
    'User-Agent': 'MyApp/1.0',
    'Accept': 'application/json'
})

# Behandelt automatisch Cookies, Verbindungspooling und Weiterleitungen
response1 = session.get('https://httpbin.org/cookies/set/session_id/abc123')
print("Cookies gesetzt:", response1.cookies.get_dict())

# Nachfolgende Anfragen enthalten die Cookies
response2 = session.get('https://httpbin.org/cookies')
print("Cookies empfangen:", response2.json())

# Sitzungsweite Konfiguration
session.auth = ('username', 'password')
session.timeout = 10

# Kontextmanager für automatische Bereinigung verwenden
with requests.Session() as s:
    response = s.get('https://httpbin.org/json')
    data = response.json()
    print("Kontextmanager verwenden")
    
# Manuelle Cookie-Verwaltung
cookies = {'sessionid': 'abc123', 'csrftoken': 'xyz789'}
response = requests.get('https://httpbin.org/cookies', cookies=cookies)
print("Manuelle Cookies:", response.json())

Sessions kümmern sich automatisch um Connection Pooling, was schnellere nachfolgende Anfragen und eine geringere Serverlast bedeutet.

11 Best Practices & Gängige Muster

Professionelle HTTP-Clients folgen bestimmten Mustern. Hier sind praxiserprobte Praktiken für Produktionscode:

import requests
import logging
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

# Logging für Debugging konfigurieren
logging.basicConfig(level=logging.WARNING)  # Lärm reduzieren
logger = logging.getLogger(__name__)

class APIClient:
    def __init__(self, base_url, timeout=10, max_retries=3):
        self.session = requests.Session()
        
        # Wiederholungsstrategie für temporäre Ausfälle
        retry_strategy = Retry(
            total=max_retries,
            status_forcelist=[429, 500, 502, 503, 504],
            method_whitelist=["HEAD", "GET", "OPTIONS"],
            backoff_factor=1
        )
        
        adapter = HTTPAdapter(max_retries=retry_strategy)
        self.session.mount("http://", adapter)
        self.session.mount("https://", adapter)
        
        self.base_url = base_url
        self.timeout = timeout
    
    def get(self, endpoint, **kwargs):
        """GET-Request mit Fehlerbehandlung ausführen"""
        url = f"{self.base_url.rstrip('/')}/{endpoint.lstrip('/')}"
        
        try:
            response = self.session.get(url, timeout=self.timeout, **kwargs)
            response.raise_for_status()
            return response
        except requests.RequestException as e:
            logger.error(f"Request failed: {e}")
            raise
    
    def post(self, endpoint, **kwargs):
        """POST-Request ausführen"""
        url = f"{self.base_url.rstrip('/')}/{endpoint.lstrip('/')}"
        return self.session.post(url, timeout=self.timeout, **kwargs)

# Beispielverwendung
api = APIClient('https://httpbin.org')
try:
    response = api.get('json')
    data = response.json()
    print(f"Daten erhalten: {list(data.keys())}")
except Exception as e:
    print(f"API-Aufruf fehlgeschlagen: {e}")

# Umgebungsbasierte Konfiguration
import os

API_BASE_URL = os.getenv('API_BASE_URL', 'https://httpbin.org')
API_KEY = os.getenv('API_KEY', 'dev-key')

headers = {
    'Authorization': f'Bearer {API_KEY}',
    'User-Agent': f'MyApp/{__version__}'
}

Diese Muster behandeln Wiederholungsversuche, ordnungsgemäße Fehlerprotokollierung, Umgebungskonfiguration und erstellen eine saubere Abstraktionsschicht für Ihre API-Interaktionen.

Wichtige Erkenntnisse

• Verwenden Sie Sitzungen für Verbindungspooling und Cookie-Verwaltung
• Implementieren Sie immer Timeouts und Fehlerbehandlung
• Nutzen Sie den Parameter json= für automatische Serialisierung
• Streamen Sie große Datei-Downloads, um den Speicher zu verwalten
• Verwenden Sie Umgebungsvariablen für die Konfiguration