19 KiB
title, description
| title | description |
|---|---|
| Web scraping HTTP en Python avec Fetcher et FetcherSession | Envoyez des requêtes HTTP synchrones ou asynchrones avec imitation de navigateur, cookies, proxies et sessions réutilisables. Extrayez les données des réponses avec Scrapling. |
Requêtes HTTP
Fetcher envoie des requêtes HTTP rapides et légères grâce à curl_cffi, une bibliothèque performante qui propose de nombreuses options pour éviter la détection.
!!! success "Avant de commencer"
1. Lisez [Les bases des fetchers](../fetching/choosing.md) pour comprendre l’[objet Response](../fetching/choosing.md#response-object) et choisir un fetcher.
2. Lisez [Rechercher des éléments](../parsing/selection.md) pour savoir comment trouver et extraire des éléments de [Selector](../parsing/main_classes.md#selector)/[Response](../fetching/choosing.md#response-object).
3. Lisez [Classes principales](../parsing/main_classes.md) pour connaître les propriétés et méthodes de [Selector](../parsing/main_classes.md#selector) dont hérite [Response](../fetching/choosing.md#response-object).
Utilisation de base
La principale façon d’importer ce fetcher est la même que pour les autres :
from scrapling.fetchers import Fetcher
Consultez la configuration du parser ici.
Arguments communs
Toutes les méthodes de requête partagent ces arguments :
- url : URL cible.
- stealthy_headers : génère et ajoute des en-têtes de navigateur réel, dont un referer Google. Activé par défaut.
- follow_redirects : contrôle les redirections. La valeur par défaut est
"safe": suit les redirections, mais refuse celles vers des IP internes ou privées pour protéger contre le SSRF. UtilisezTruepour les suivre sans restriction, ouFalsepour les désactiver. - timeout : délai maximal en secondes pour terminer chaque requête. 30 secondes par défaut.
- retries : nombre maximal de tentatives lorsqu’une requête échoue, première tentative comprise. 3 par défaut.
- retry_delay : secondes d’attente entre les tentatives. 1 seconde par défaut.
- impersonate : imite l’empreinte TLS d’un navigateur. Accepte une chaîne ou une liste, comme
"chrome110","firefox102"ou"safari15_5"pour des versions précises. Utilisez"chrome","firefox","safari"ou"edge"pour la dernière version disponible. Les requêtes semblent ainsi venir d’un vrai navigateur au niveau TLS. Avec une liste, une option est choisie au hasard pour chaque requête. Par défaut, utilise la dernière version de Chrome disponible. - http3 : utilise HTTP/3. False par défaut. Peut poser problème avec
impersonate. - cookies : cookies de la requête. Accepte un dictionnaire
name→valueou une liste de dictionnaires. - proxy : proxy utilisé pour acheminer tout le trafic HTTP et HTTPS de cette requête. Le format est
http://username:password@localhost:8030. - proxy_auth : authentification HTTP Basic du proxy, sous forme de tuple (nom d’utilisateur, mot de passe).
- proxies : dictionnaire de proxies au format
{"http": proxy_url, "https": proxy_url}. - proxy_rotator : objet
ProxyRotatorpour changer automatiquement de proxy. Ne peut pas être combiné avecproxyouproxies. - headers : en-têtes de la requête. Ils peuvent remplacer ceux générés par
stealthy_headers. - max_redirects : nombre maximal de redirections. 30 par défaut. Utilisez -1 pour ne pas limiter.
- verify : indique si les certificats HTTPS doivent être vérifiés. True par défaut.
- cert : tuple des noms de fichiers (certificat, clé) pour le certificat client.
- selector_config : dictionnaire de réglages du parser pour créer l’objet
Selector/Responsefinal.
!!! note "Notes"
1. Les navigateurs disponibles pour l’imitation sont (`"edge"`, `"chrome"`, `"chrome_android"`, `"safari"`, `"safari_beta"`, `"safari_ios"`, `"safari_ios_beta"`, `"firefox"`, `"tor"`).<br/>
2. Les navigateurs et leurs versions apparaissent dans l’autocomplétion de l’argument et sont actualisés à chaque mise à jour de `curl_cffi`.<br/>
3. Si `impersonate` ou `stealthy_headers` est activé, les fetchers génèrent des en-têtes réels correspondant à la version du navigateur utilisée.
Pour d’autres réglages, vous pouvez passer à chaque méthode les arguments acceptés par curl_cffi qu’elle ne gère pas déjà.
Encodage du texte
Si une page qui n’utilise pas UTF-8 affiche des caractères incorrects, passez default_encoding="shift_jis", ou l’encodage réel de la page, avec la requête. Il sera utilisé si l’en-tête Content-Type ne précise pas d’encodage. Il ne remplace pas l’encodage fourni par le serveur.
Si le serveur indique un mauvais encodage, vous pouvez imposer le bon avec selector_config={"encoding": "shift_jis"}.
Méthodes HTTP
Chaque méthode a ses propres arguments, comme params pour GET et data/json pour POST, PUT et DELETE.
Voici quelques exemples :
Les méthodes
OPTIONSetHEADne sont pas disponibles.
GET
from scrapling.fetchers import Fetcher
# Basic GET
page = Fetcher.get('https://example.com')
page = Fetcher.get('https://scrapling.requestcatcher.com/get', stealthy_headers=True)
page = Fetcher.get('https://scrapling.requestcatcher.com/get', proxy='http://username:password@localhost:8030')
# With parameters
page = Fetcher.get('https://example.com/search', params={'q': 'query'})
# With headers
page = Fetcher.get('https://example.com', headers={'User-Agent': 'Custom/1.0'})
# Basic HTTP authentication
page = Fetcher.get("https://example.com", auth=("my_user", "password123"))
# Browser impersonation
page = Fetcher.get('https://example.com', impersonate='chrome')
# HTTP/3 support
page = Fetcher.get('https://example.com', http3=True)
Pour les requêtes asynchrones, un petit ajustement suffit :
from scrapling.fetchers import AsyncFetcher
# Basic GET
page = await AsyncFetcher.get('https://example.com')
page = await AsyncFetcher.get('https://scrapling.requestcatcher.com/get', stealthy_headers=True)
page = await AsyncFetcher.get('https://scrapling.requestcatcher.com/get', proxy='http://username:password@localhost:8030')
# With parameters
page = await AsyncFetcher.get('https://example.com/search', params={'q': 'query'})
# With headers
page = await AsyncFetcher.get('https://example.com', headers={'User-Agent': 'Custom/1.0'})
# Basic HTTP authentication
page = await AsyncFetcher.get("https://example.com", auth=("my_user", "password123"))
# Browser impersonation
page = await AsyncFetcher.get('https://example.com', impersonate='chrome110')
# HTTP/3 support
page = await AsyncFetcher.get('https://example.com', http3=True)
Dans tous les cas, page est un Response, qui est aussi un Selector. Vous pouvez l’utiliser directement :
page.css('.something.something')
page = Fetcher.get('https://api.github.com/events')
>>> page.json()
[{'id': '<redacted>',
'type': 'PushEvent',
'actor': {'id': '<redacted>',
'login': '<redacted>',
'display_login': '<redacted>',
'gravatar_id': '',
'url': 'https://api.github.com/users/<redacted>',
'avatar_url': 'https://avatars.githubusercontent.com/u/<redacted>'},
'repo': {'id': '<redacted>',
...
POST
from scrapling.fetchers import Fetcher
# Basic POST
page = Fetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, params={'q': 'query'})
page = Fetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, stealthy_headers=True)
page = Fetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030', impersonate="chrome")
# Another example of form-encoded data
page = Fetcher.post('https://example.com/submit', data={'username': 'user', 'password': 'pass'}, http3=True)
# JSON data
page = Fetcher.post('https://example.com/api', json={'key': 'value'})
Pour les requêtes asynchrones, un petit ajustement suffit :
from scrapling.fetchers import AsyncFetcher
# Basic POST
page = await AsyncFetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'})
page = await AsyncFetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, stealthy_headers=True)
page = await AsyncFetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030', impersonate="chrome")
# Another example of form-encoded data
page = await AsyncFetcher.post('https://example.com/submit', data={'username': 'user', 'password': 'pass'}, http3=True)
# JSON data
page = await AsyncFetcher.post('https://example.com/api', json={'key': 'value'})
PUT
from scrapling.fetchers import Fetcher
# Basic PUT
page = Fetcher.put('https://example.com/update', data={'status': 'updated'})
page = Fetcher.put('https://example.com/update', data={'status': 'updated'}, stealthy_headers=True, impersonate="chrome")
page = Fetcher.put('https://example.com/update', data={'status': 'updated'}, proxy='http://username:password@localhost:8030')
# Another example of form-encoded data
page = Fetcher.put("https://scrapling.requestcatcher.com/put", data={'key': ['value1', 'value2']})
Pour les requêtes asynchrones, un petit ajustement suffit :
from scrapling.fetchers import AsyncFetcher
# Basic PUT
page = await AsyncFetcher.put('https://example.com/update', data={'status': 'updated'})
page = await AsyncFetcher.put('https://example.com/update', data={'status': 'updated'}, stealthy_headers=True, impersonate="chrome")
page = await AsyncFetcher.put('https://example.com/update', data={'status': 'updated'}, proxy='http://username:password@localhost:8030')
# Another example of form-encoded data
page = await AsyncFetcher.put("https://scrapling.requestcatcher.com/put", data={'key': ['value1', 'value2']})
DELETE
from scrapling.fetchers import Fetcher
page = Fetcher.delete('https://example.com/resource/123')
page = Fetcher.delete('https://example.com/resource/123', stealthy_headers=True, impersonate="chrome")
page = Fetcher.delete('https://example.com/resource/123', proxy='http://username:password@localhost:8030')
Pour les requêtes asynchrones, un petit ajustement suffit :
from scrapling.fetchers import AsyncFetcher
page = await AsyncFetcher.delete('https://example.com/resource/123')
page = await AsyncFetcher.delete('https://example.com/resource/123', stealthy_headers=True, impersonate="chrome")
page = await AsyncFetcher.delete('https://example.com/resource/123', proxy='http://username:password@localhost:8030')
Gestion des sessions
Utilisez FetcherSession pour envoyer plusieurs requêtes avec la même configuration. Elle fonctionne en code synchrone et asynchrone : elle détecte le mode utilisé et adapte la session sans nécessiter une autre importation.
FetcherSession accepte presque tous les arguments des méthodes de requête. Vous pouvez définir des réglages pour toute la session, puis les modifier pour une requête précise, comme dans les exemples suivants.
from scrapling.fetchers import FetcherSession
# Create a session with default configuration
with FetcherSession(
impersonate='chrome',
http3=True,
stealthy_headers=True,
timeout=30,
retries=3
) as session:
# Make multiple requests with the same settings and the same cookies
page1 = session.get('https://scrapling.requestcatcher.com/get')
page2 = session.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'})
page3 = session.get('https://api.github.com/events')
# All requests share the same session and connection pool
Vous pouvez aussi utiliser ProxyRotator avec FetcherSession pour changer automatiquement de proxy entre les requêtes :
from scrapling.fetchers import FetcherSession, ProxyRotator
rotator = ProxyRotator([
'http://proxy1:8080',
'http://proxy2:8080',
'http://proxy3:8080',
])
with FetcherSession(proxy_rotator=rotator, impersonate='chrome') as session:
# Each request automatically uses the next proxy in rotation
page1 = session.get('https://example.com/page1')
page2 = session.get('https://example.com/page2')
# You can check which proxy was used via the response metadata
print(page1.meta['proxy'])
Pour une requête précise, remplacez le proxy ou le rotateur de la session en passant proxy= à la méthode :
with FetcherSession(proxy='http://default-proxy:8080') as session:
# Uses the session proxy
page1 = session.get('https://example.com/page1')
# Override the proxy for this specific request
page2 = session.get('https://example.com/page2', proxy='http://special-proxy:9090')
Un exemple asynchrone :
async with FetcherSession(impersonate='firefox', http3=True) as session:
# All standard HTTP methods available
response = await session.get('https://example.com')
response = await session.post('https://scrapling.requestcatcher.com/post', json={'data': 'value'})
response = await session.put('https://scrapling.requestcatcher.com/put', data={'update': 'info'})
response = await session.delete('https://scrapling.requestcatcher.com/delete')
Ou, mieux encore :
import asyncio
from scrapling.fetchers import FetcherSession
# Async session usage
async with FetcherSession(impersonate="safari") as session:
urls = ['https://example.com/page1', 'https://example.com/page2']
tasks = [
session.get(url) for url in urls
]
pages = await asyncio.gather(*tasks)
Fetcher utilise FetcherSession pour créer une session temporaire à chaque requête.
Avantages des sessions
- Plus rapides : 10 fois plus rapides que la création d’une session par requête.
- Cookies persistants : gestion automatique des cookies entre les requêtes.
- Moins de ressources : meilleure utilisation de la mémoire et du processeur pour plusieurs requêtes.
- Configuration centralisée : un seul endroit pour gérer les réglages.
Exemples
Des exemples complets pour débuter en web scraping.
Requête HTTP simple
from scrapling.fetchers import Fetcher
# Make a request
page = Fetcher.get('https://example.com')
# Check the status
if page.status == 200:
# Extract title
title = page.css('title::text').get()
print(f"Page title: {title}")
# Extract all links
links = page.css('a::attr(href)').getall()
print(f"Found {len(links)} links")
Extraire des produits
from scrapling.fetchers import Fetcher
def scrape_products():
page = Fetcher.get('https://example.com/products')
# Find all product elements
products = page.css('.product')
results = []
for product in products:
results.append({
'title': product.css('.title::text').get(),
'price': product.css('.price::text').re_first(r'\d+\.\d{2}'),
'description': product.css('.description::text').get(),
'in_stock': product.has_class('in-stock')
})
return results
Télécharger des fichiers
from scrapling.fetchers import Fetcher
page = Fetcher.get('https://raw.githubusercontent.com/D4Vinci/Scrapling/main/docs/assets/main_cover.png')
with open(file='main_cover.png', mode='wb') as f:
f.write(page.body)
Parcourir les pages de résultats
from scrapling.fetchers import Fetcher
def scrape_all_pages():
base_url = 'https://example.com/products?page={}'
page_num = 1
all_products = []
while True:
# Get current page
page = Fetcher.get(base_url.format(page_num))
# Find products
products = page.css('.product')
if not products:
break
# Process products
for product in products:
all_products.append({
'name': product.css('.name::text').get(),
'price': product.css('.price::text').get()
})
# Next page
page_num += 1
return all_products
Envoyer des formulaires
from scrapling.fetchers import Fetcher
# Submit login form
response = Fetcher.post(
'https://example.com/login',
data={
'username': 'user@example.com',
'password': 'password123'
}
)
# Check login success
if response.status == 200:
# Extract user info
user_name = response.css('.user-name::text').get()
print(f"Logged in as: {user_name}")
Extraire des tableaux
from scrapling.fetchers import Fetcher
def extract_table():
page = Fetcher.get('https://example.com/data')
# Find table
table = page.css('table')[0]
# Extract headers
headers = [
th.text for th in table.css('thead th')
]
# Extract rows
rows = []
for row in table.css('tbody tr'):
cells = [td.text for td in row.css('td')]
rows.append(dict(zip(headers, cells)))
return rows
Menu de navigation
from scrapling.fetchers import Fetcher
def extract_menu():
page = Fetcher.get('https://example.com')
# Find navigation
nav = page.css('nav')[0]
menu = {}
for item in nav.css('li'):
links = item.css('a')
if links:
link = links[0]
menu[link.text] = {
'url': link['href'],
'has_submenu': bool(item.css('.submenu'))
}
return menu
Quand utiliser chaque option
Utilisez Fetcher si vous :
- Avez besoin de requêtes HTTP rapides.
- Voulez limiter l’utilisation des ressources.
- N’avez pas besoin d’exécuter JavaScript, car les données sont accessibles par requêtes HTTP.
- Avez besoin d’éviter certaines détections, par exemple si le site est protégé mais n’utilise pas de défis JavaScript.
Utilisez FetcherSession si vous :
- Envoyez plusieurs requêtes au même site ou à des sites différents.
- Devez conserver des cookies ou une authentification entre les requêtes.
- Voulez réutiliser les connexions pour améliorer les performances.
- Devez garder les mêmes réglages entre les requêtes.
- Travaillez avec des API qui nécessitent un état de session.
Utilisez d’autres fetchers si vous :
- Devez automatiser un navigateur.
- Avez besoin d’options avancées pour éviter la détection de bots.
- Devez exécuter JavaScript ou interagir avec du contenu dynamique.