Extraits de la Bibliothèque de Requêtes Python

1 Introduction à la bibliothèque Python Requests

La bibliothèque requests est le client HTTP élégant de Python qui rend les appels d'API aussi naturels que possible. Elle abstrait les détails complexes du protocole HTTP tout en conservant la puissance sous le capot. Pensez-y comme à votre coursier fiable pour Internet, capable de tout gérer, des simples récupérations de pages aux flux d'authentification complexes.

Pourquoi les développeurs l'adorent :

Convivialité : L'API se lit comme de l'anglais simple au lieu d'un jargon HTTP cryptique.
JSON intégré : L'analyse automatique élimine les maux de tête liés à l'analyse répétitive.
Support de session : Conserve automatiquement les cookies et le pooling de connexions pour vous.
Gestion robuste des erreurs : Exceptions claires au lieu de codes de statut cryptiques.
Vérification SSL : Sécurisé par défaut, flexible si nécessaire.

Prêt à récupérer des données ? Commençons par les bases.

2 Prérequis : Python et Pip

Vous aurez besoin de Python 3.6+ et de pip pour installer la bibliothèque requests. Vérifions votre configuration :

python --version && pip --version

Si ces commandes fonctionnent, vous êtes prêt. Sinon, téléchargez Python depuis python.org et pip sera inclus.

3 Installer la bibliothèque Requests

D'abord, créons un nouvel environnement virtuel - cela permet de garder vos dépendances de projet propres et d'éviter les conflits de version :

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

Installez maintenant requests en utilisant pip :

pip install requests

4 Votre Première Requête GET

Commençons par l'opération la plus courante : la récupération de données. Cet extrait simple récupère une réponse JSON d'une API publique :

import requests

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

# Analyse JSON automatique
data = response.json()
print(f"Clés : {list(data.keys())}")

Remarquez l'analyse JSON automatique - requests détecte le type de contenu et l'analyse pour vous. Pas besoin de danse json.loads() manuelle.

5 Requêtes POST avec Données

Envoi de données à un serveur ? Les requêtes POST gèrent les données de formulaire, JSON et les fichiers de manière transparente. Voici les modèles courants :

import requests

# Envoyer des données de formulaire
form_data = {'username': 'alice', 'password': 'secret123'}
response = requests.post('https://httpbin.org/post', data=form_data)

# Envoyer des données JSON (définit automatiquement l'en-tête Content-Type)
json_data = {'name': 'Alice', 'email': '[email protected]'}
response = requests.post('https://httpbin.org/post', json=json_data)

print(f"Statut : {response.status_code}")
print(f"Réponse : {response.json()}")

Le paramètre json définit automatiquement les bons en-têtes et sérialise vos données. Beaucoup plus propre que de définir manuellement les en-têtes.

6 En-têtes Personnalisés et Authentification

Les API nécessitent souvent des en-têtes personnalisés et une authentification. Requests rend cela simple avec des classes d'authentification intégrées :

import requests
from requests.auth import HTTPBasicAuth, HTTPDigestAuth

# En-têtes personnalisés
headers = {
    'User-Agent': 'MyApp/1.0',
    'Accept': 'application/json',
    'X-API-Key': 'votre-clé-api-ici'
}

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

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

# Clé API dans l'en-tête
api_key = 'sk-1234567890abcdef'
headers = {'Authorization': f'Bearer {api_key}'}
response = requests.get('https://httpbin.org/bearer', headers=headers)

HTTPBasicAuth et HTTPDigestAuth gèrent l'encodage automatiquement. Pour les API modernes, les jetons Bearer dans l'en-tête Authorization sont la norme.

7 Gestion des Erreurs et Codes de Statut

Les applications robustes gèrent les erreurs avec élégance. Requests soulève des exceptions pour les problèmes réseau et fournit des objets de réponse détaillés :

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

try:
    response = requests.get('https://httpbin.org/status/404', timeout=5)
    
    # Soulever une exception pour les mauvais codes de statut
    response.raise_for_status()
    
except Timeout:
    print("La requête a expiré après 5 secondes")
except ConnectionError:
    print("Échec de la connexion au serveur")
except RequestException as e:
    print(f"La requête a échoué : {e}")
    
else:
    print(f"Succès ! Statut : {response.status_code}")
    print(f"En-têtes : {response.headers}")
    print(f"Corps : {response.text[:100]}...")  # Les 100 premiers caractères
    
# Vérification manuelle du code de statut
if response.status_code == 200:
    data = response.json()
    print("Données reçues :", data)
elif response.status_code == 404:
    print("Ressource non trouvée")
else:
    print(f"Statut inattendu : {response.status_code}")

raise_for_status() lève une HTTPError pour les réponses 4xx/5xx. Les timeouts empêchent votre application de rester bloquée indéfiniment.

8 Traitement JSON et Gestion des Données

Travailler efficacement avec des données JSON est là où requests brille. Il gère l'encodage, le décodage et la validation automatiquement :

import requests

# Gestion JSON complexe
response = requests.get('https://httpbin.org/json')

# Analyse JSON sécurisée avec gestion des erreurs
try:
    data = response.json()
    print(f"Type : {type(data)}")
    print(f"Clés : {data.keys() if isinstance(data, dict) else 'Pas un dict'}")
except ValueError as e:
    print(f"JSON invalide : {e}")
    print(f"Contenu brut : {response.text}")

# Travail avec des données imbriquées
user_data = {
    'name': 'Alice Johnson',
    'email': '[email protected]',
    'preferences': {
        'theme': 'dark',
        'notifications': True,
        'language': 'en'
    }
}

# Envoyer un JSON imbriqué complexe
response = requests.post('https://httpbin.org/post', json=user_data)
result = response.json()

# Accéder aux valeurs imbriquées
nested = result.get('json', {}).get('preferences', {})
theme = nested.get('theme', 'light')
print(f"Thème de l'utilisateur : {theme}")

Utilisez toujours des méthodes sûres comme get() lors de l'accès à des JSON imbriqués pour éviter les exceptions KeyError.

9 Téléchargements de Fichiers et Streaming

Télécharger des fichiers efficacement évite les problèmes de mémoire. Utilisez le streaming pour les fichiers volumineux et vérifiez le type de contenu :

import requests
import os
from pathlib import Path

# Télécharger un fichier
url = 'https://httpbin.org/image/jpeg'
response = requests.get(url, stream=True)

if response.status_code == 200:
    # Créer le répertoire de téléchargements
    downloads_dir = Path('downloads')
    downloads_dir.mkdir(exist_ok=True)
    
    # Sauvegarder le fichier
    file_path = downloads_dir / 'image.jpg'
    with open(file_path, 'wb') as f:
        for chunk in response.iter_content(chunk_size=8192):
            if chunk:  # Filtrer les chunks keep-alive
                f.write(chunk)
    
    print(f"Téléchargé {file_path} ({file_path.stat().st_size} octets)")
else:
    print(f"Échec du téléchargement : {response.status_code}")

# Obtenir les informations du fichier avant le téléchargement
head_response = requests.head(url)
content_length = head_response.headers.get('content-length')
content_type = head_response.headers.get('content-type')

print(f"Taille du fichier : {content_length} octets")
print(f"Type de contenu : {content_type}")

# Télécharger avec progression
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)
                
                # Afficher la progression
                if total_size > 0:
                    progress = (downloaded / total_size) * 100
                    print(f"Progression : {progress:.1f}%")

Les téléchargements en streaming empêchent de charger des fichiers entiers en mémoire. Parfait pour les grandes images, documents ou fichiers multimédias.

10 Gestion des Sessions et Cookies

Pour les applications qui doivent maintenir un état entre les requêtes - comme les sessions de connexion - utilisez les objets Session de requests :

import requests

# Créer une session pour des connexions et cookies persistants
session = requests.Session()

# Définir les en-têtes par défaut pour toutes les requêtes
session.headers.update({
    'User-Agent': 'MyApp/1.0',
    'Accept': 'application/json'
})

# Gère automatiquement les cookies, le pooling de connexions et les redirections
response1 = session.get('https://httpbin.org/cookies/set/session_id/abc123')
print("Cookies définis :", response1.cookies.get_dict())

# Les requêtes ultérieures incluent les cookies
response2 = session.get('https://httpbin.org/cookies')
print("Cookies reçus :", response2.json())

# Configuration au niveau de la session
session.auth = ('username', 'password')
session.timeout = 10

# Utiliser un gestionnaire de contexte pour le nettoyage automatique
with requests.Session() as s:
    response = s.get('https://httpbin.org/json')
    data = response.json()
    print("Utilisation du gestionnaire de contexte")
    
# Gestion manuelle des cookies
cookies = {'sessionid': 'abc123', 'csrftoken': 'xyz789'}
response = requests.get('https://httpbin.org/cookies', cookies=cookies)
print("Cookies manuels :", response.json())

Les sessions gèrent automatiquement le pooling de connexions, ce qui signifie des requêtes ultérieures plus rapides et une charge serveur réduite.

11 Bonnes Pratiques et Modèles Courants

Les clients HTTP professionnels suivent certaines pratiques. Voici des pratiques éprouvées pour le code de production :

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

# Configuration du logging pour le débogage
logging.basicConfig(level=logging.WARNING)  # Réduire le bruit
logger = logging.getLogger(__name__)

class APIClient:
    def __init__(self, base_url, timeout=10, max_retries=3):
        self.session = requests.Session()
        
        # Stratégie de retry pour les échecs transitoires
        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):
        """Effectue une requête GET avec gestion des erreurs"""
        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"La requête a échoué : {e}")
            raise
    
    def post(self, endpoint, **kwargs):
        """Effectue une requête POST"""
        url = f"{self.base_url.rstrip('/')}/{endpoint.lstrip('/')}"
        return self.session.post(url, timeout=self.timeout, **kwargs)

# Exemple d'utilisation
api = APIClient('https://httpbin.org')
try:
    response = api.get('json')
    data = response.json()
    print(f"Données obtenues : {list(data.keys())}")
except Exception as e:
    print(f"L'appel API a échoué : {e}")

# Configuration basée sur l'environnement
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__}'
}

Ces modèles gèrent les retries, le logging d'erreurs approprié, la configuration de l'environnement et créent une couche d'abstraction propre pour vos interactions API.

Points Clés

• Utilisez des sessions pour le pooling de connexions et la gestion des cookies
• Implémentez toujours des timeouts et une gestion des erreurs
• Exploitez le paramètre json= pour une sérialisation automatique
• Diffusez les téléchargements de gros fichiers pour gérer la mémoire
• Utilisez des variables d'environnement pour la configuration