4.5Automatisation & web scraping
L'essentiel en 30 secondes
- ROI d'abord : tâche de 30 min/semaine + script de 2 h = rentabilisé en un mois ; pathlib, openpyxl/pandas, logging en boîte à outils.
- Duo statique :
requests.getrécupère (timeout, user-agent),BeautifulSoupparse (select) ; Selenium pilote un navigateur pour le JavaScript. - Réflexe de Nabil : robots.txt + CGU AVANT la première requête, délais entre requêtes, API officielle préférée au scraping.
Mini-cas filé — Nabil automatise sa veille prix
Chaque lundi, Nabil, à Alger, relève à la main des prix publics pour sa veille concurrentielle : 30 minutes copiées-collées. Il écrit un script poli : il lit le robots.txt et les CGU du site, espace ses requêtes de 2 secondes avec un user-agent identifié, extrait les prix avec BeautifulSoup et les stocke en CSV avec logs. Quand le site propose une API officielle, il bascule dessus. Dernier jalon du fil rouge : l'analyste qui a gagné ses lundis — proprement.
Dernier cas du fil rouge 4.1-4.5 — Nabil boucle ses spécialisations.
1. Automatiser ce qui est rentable
On automatise ce qui est répétitif : fichiers, tableurs (openpyxl/pandas), rapports, e-mails — avec pathlib pour les chemins. La règle : calculer le ROI avant de coder (30 min/semaine contre 2 h de dev = rentable en un mois). Et on fiabilise : logging pour tracer, try ciblés avec alertes, tests sur des copies (jamais sur les originaux), puis planification (cron, Planificateur) pour tourner seul. Nabil teste son renommage sur des copies avant de toucher aux vrais dossiers.
2. Scraper poli : requests, BeautifulSoup, Selenium
Pour les pages statiques : requests.get télécharge (avec timeout et User-Agent identifié), BeautifulSoup analyse le HTML (select(".prix")), on stocke en CSV. La politesse : lire robots.txt, espacer les requêtes (time.sleep), ne jamais bourriner — sinon bannissement. Pour le JavaScript et le défilement infini : Selenium pilote un vrai navigateur, plus lourd. Et la règle maîtresse : si une API officielle existe (ou si login/CGU l'interdisent), on l'utilise — le scraping vient en dernier, jamais contre les règles.
🔎 Exemple concret — 🔎 Exemple concret — La veille prix de Nabil
Le scraper poli de Nabil, avec les API réelles :
r = requests.get(url, timeout=10, headers={"User-Agent": "veille-perso"})
prix = BeautifulSoup(r.text, "html.parser").select_one(".prix").text
logging.info("%s : %s", url, prix) # tout est tracé
time.sleep(2) # politesse : espacer les requêtesLecture : récupérer, parser, tracer, patienter.
Leçon : timeout + user-agent + délai = scraper poli.
Vocabulaire de la section
- Automatisation / ROI
- Confier les tâches répétitives à un script (fichiers, tableurs, rapports) après avoir vérifié que le temps gagné dépasse le temps de dev.
Exemple simple : Nabil : 30 min/semaine économisées pour 2 h de dev, rentable en un mois.
Ce que ce n'est pas : automatiser une tâche faite deux fois par an.
Réflexe : calculer le ROI avant de coder.
- requests + BeautifulSoup
- Le duo des pages statiques : requests télécharge la page, BeautifulSoup analyse le HTML (select) pour extraire les champs.
Exemple simple : Nabil extrait les prix publics avec select_one et les stocke en CSV.
Ce que ce n'est pas : un navigateur piloté pour une page statique simple.
Réflexe : timeout + user-agent + requêtes espacées, toujours.
- Selenium
- Pilotage d'un vrai navigateur pour les pages JavaScript (contenu chargé, défilement infini) — puissant mais plus lourd.
Exemple simple : Nabil y recourt quand les prix ne sont pas dans le HTML initial.
Ce que ce n'est pas : bourriner du requests sur du contenu généré en JS.
Réflexe : Selenium seulement si le statique ne suffit pas.
- robots.txt / CGU
- Les règles d'accès d'un site (fichier robots.txt, conditions d'utilisation) : ce qu'on peut collecter, à quel rythme — à lire avant la première requête.
Exemple simple : Nabil lit les deux, espace ses requêtes et bascule sur l'API officielle.
Ce que ce n'est pas : scraper en masse un site qui l'interdit.
Réflexe : autorisé + espacé + tracé, ou on s'abstient.
En pratique — En pratique — Automatiser puis scraper poliment
- Choisissez UNE tâche répétitive, calculez son ROI (temps/semaine contre temps de dev) et automatisez-la avec pathlib/pandas.
- Ajoutez logging, try ciblés avec alertes, et testez sur des copies — jamais sur les originaux.
- Avant tout scraping : lisez CGU + robots.txt, cherchez une API officielle, et prévoyez timeout, user-agent et délais.
- Scrapez (requests + BeautifulSoup), stockez en CSV, planifiez (cron/Planificateur) et surveillez les logs.
Script prêt à dire — justifier sa collecte (30 s)
« C'est Nabil : CGU et robots.txt lus avant la première requête, API officielle préférée, requêtes espacées avec user-agent identifié, tout tracé en logs. Nos lundis sont automatisés — et notre collecte est défendable. »
À dire avant toute mise en prod d'un scraper ; montrez CGU + logs.
Modèle copier-coller — scraper poli (code testé)
import csv
import logging
import time
import requests
from bs4 import BeautifulSoup
logging.basicConfig(level=logging.INFO)
URLS = ["https://example.com/page-1", "https://example.com/page-2"]
HEADERS = {"User-Agent": "veille-perso (contact : exemple@domaine.test)"}
# Préalable : lire https://example.com/robots.txt + CGU,
# préférer l'API officielle si elle existe.
with open("prix.csv", "w", newline="", encoding="utf-8") as f:
out = csv.writer(f)
out.writerow(["url", "prix"])
for url in URLS:
r = requests.get(url, timeout=10, headers=HEADERS)
r.raise_for_status()
prix = BeautifulSoup(r.text, "html.parser").select_one(".prix").text.strip()
out.writerow([url, prix])
logging.info("%s : %s", url, prix)
time.sleep(2) # politesse : espacer les requêtes
Tâche bureautique
Renommage, rapports, e-mails : pathlib + pandas + logging, testé sur copies, puis planifié.
Veille occasionnelle
Comme Nabil : quelques pages, espacées, tracées — le script tourne le lundi, personne n'y pense.
Page JavaScript
Contenu absent du HTML ? Selenium pilote un navigateur — plus lourd, à réserver à ce cas.
Collecte régulière
API officielle dès qu'elle existe : stable, autorisée, plus rapide que tout scraping.
✓ Bonnes pratiques
- Calculer le ROI avant d'automatiser.
- Lire CGU + robots.txt avant la première requête.
- Logs + tests sur copies + requêtes espacées.
✗ Pièges fréquents
- Scraper sans lire CGU ni robots.txt.
- Bourriner sans délai (bannissement assuré).
- Lancer un script destructeur sans test.
Points clés à retenir
- AUTOMATISER le répétitif rentable : pathlib, openpyxl/pandas, smtplib — ROI calculé.
- DUO statique : REQUESTS (télécharge) + BEAUTIFULSOUP (analyse HTML).
- SELENIUM = navigateur piloté pour le JS ; API OFFICIELLE préférée au scraping.
- POLITESSE : robots.txt, délais, user-agent ; FIABILITÉ : logs, copies test, planification.
Défi 48h — appliquez demain
Automatisez 1 tâche répétitive (ROI calculé, testée sur copies) OU scrapez 2 pages autorisées (CGU lues) avec délais + logs.
- Je peux citer ROI, requests, BeautifulSoup, Selenium.
- Je sais expliquer CGU/robots.txt + délais.
- J'ai 1 script fiable ou 1 collecte polie qui tourne.
Questions fréquentes
Le web scraping est-il légal ?
Ça dépend : CGU et robots.txt du site, droits sur les données (dont personnelles), rythme de collecte — le tout encadre ce qui est permis. Règles de Nabil : lire CGU + robots.txt avant la première requête, espacer les requêtes, préférer l'API officielle, ne jamais collecter de données personnelles sans base légale, et faire valider par un juriste en cas de doute ou d'usage professionnel.
requests suffit-il, ou faut-il Selenium ?
requests + BeautifulSoup suffisent quand les données sont dans le HTML initial (pages statiques) : rapide et léger. Selenium devient nécessaire quand le contenu est généré en JavaScript (chargement dynamique, défilement infini) : il pilote un vrai navigateur, plus lourd et plus lent. On commence statique, on passe au navigateur seulement si besoin.
Quel duo pour scraper des pages statiques ?