Méthodes de Collecte de Données – DeepLearn Platform

La collecte de données constitue la première étape concrète de tout projet d’analyse. Cette phase détermine largement la qualité et la pertinence des insights qui pourront être extraits. Cette leçon présente les méthodes modernes de collecte, en mettant l’accent sur les techniques automatisées qui révolutionnent l’accès à l’information.

Panorama des méthodes de collecte

Méthodes traditionnelles : Les fondamentaux

Les enquêtes et questionnaires :

Collecte directe auprès des répondants via formulaires structurés. Permettent d’obtenir des données qualitatives et quantitatives spécifiques aux besoins de l’étude.

Avantages :

Contrôle total sur les questions posées
Données directement exploitables
Possibilité de cibler précisément la population

Limites :

Biais de réponse et de sélection
Coût élevé pour de grands échantillons
Données figées dans le temps

Les entretiens et observations :

Collecte qualitative approfondie permettant de comprendre les motivations et comportements.

Applications :

Études de marché exploratoires
Recherche en sciences sociales
Validation d’hypothèses métier

Méthodes automatisées : La révolution numérique

Le Web Scraping : Extraction automatisée du web

Le web scraping consiste à extraire automatiquement des informations structurées à partir de pages web. Cette technique ouvre l’accès à une quantité immense de données publiques.

Principe de fonctionnement :

Analyse de la structure HTML de la page cible
Identification des éléments à extraire (balises, classes CSS)
Automatisation de l’extraction via des scripts
Traitement et stockage des données récupérées

Technologies Python essentielles :

Requests : Librairie pour effectuer des requêtes HTTP

import requests

# Récupérer le contenu d'une page
response = requests.get('https://example.com/data')
html_content = response.text

# Vérifier le statut de la réponse
if response.status_code == 200:
    print("Récupération réussie")
else:
    print(f"Erreur: {response.status_code}")

BeautifulSoup : Parser HTML pour extraire les données

from bs4 import BeautifulSoup
import requests

# Récupérer et parser une page
url = "https://quotes.toscrape.com/"
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')

# Extraire toutes les citations
quotes = []
for quote in soup.find_all('div', class_='quote'):
    text = quote.find('span', class_='text').text
    author = quote.find('small', class_='author').text
    quotes.append({
        'text': text,
        'author': author
    })
print(f"Nombre de citations extraites: {len(quotes)}")

Selenium : Pour les sites avec contenu JavaScript dynamique

from selenium import webdriver
from selenium.webdriver.common.by import By
import time

# Initialiser le navigateur
driver = webdriver.Chrome()
driver.get('https://dynamic-content-site.com')

# Attendre le chargement du contenu dynamique
time.sleep(3)

# Extraire les données après chargement JavaScript
elements = driver.find_elements(By.CLASS_NAME, 'dynamic-content')
data = [element.text for element in elements]
driver.quit()

Cas d’usage pratiques :

Veille concurrentielle :

Prix des produits concurrents
Nouvelles offres et promotions
Avis clients sur les plateformes

Recherche et développement :

Publications scientifiques récentes
Brevets et innovations sectorielles
Tendances technologiques

Marketing digital :

Mentions de marque sur le web
Influenceurs et leaders d’opinion
Contenu viral et engagement

Les APIs : L’accès standardisé aux données

Les APIs (Application Programming Interfaces) constituent la méthode privilégiée pour accéder à des données de manière structurée et légale. Elles offrent un accès direct aux systèmes de données des organisations.

Avantages des APIs :

Accès légal et éthique aux données
Format standardisé (généralement JSON)
Documentation officielle disponible
Limites de débit clairement définies
Données en temps réel ou quasi-réel

Types d’APIs courantes :

APIs REST : Standard web le plus répandu

import requests
import json

# Exemple: API GitHub pour récupérer les repositories d'un utilisateur
url = "https://api.github.com/users/octocat/repos"
headers = {
    'Accept': 'application/vnd.github.v3+json',
    'User-Agent': 'MonApp/1.0'
}
response = requests.get(url, headers=headers)
repos = response.json()

# Traiter les données récupérées
for repo in repos[:5]:  # Premiers 5 repositories
    print(f"Nom: {repo['name']}")
    print(f"Description: {repo['description']}")
    print(f"Stars: {repo['stargazers_count']}")
    print("---")

APIs avec authentification : Accès sécurisé aux données privées

import requests

# Exemple: API Twitter avec token d'authentification
headers = {
    'Authorization': 'Bearer VOTRE_TOKEN_ICI',
    'Content-Type': 'application/json'
}
url = "https://api.twitter.com/2/tweets/search/recent"
params = {
    'query': 'science des données',
    'max_results': 10
}
response = requests.get(url, headers=headers, params=params)
tweets = response.json()

# Analyser les tweets récupérés
for tweet in tweets.get('data', []):
    print(f"Tweet: {tweet['text'][:100]}...")
    print(f"ID: {tweet['id']}")

Sources d’APIs publiques remarquables :

APIs gouvernementales :

data.gouv.fr : Données publiques françaises
INSEE : Statistiques nationales
Banque Mondiale : Indicateurs économiques mondiaux

APIs business :

Google Maps : Géolocalisation et itinéraires
OpenWeatherMap : Données météorologiques
Alpha Vantage : Données financières

APIs sociales :

Twitter API : Tweets et tendances
YouTube API : Statistiques de vidéos
LinkedIn API : Données professionnelles

Techniques avancées de collecte

Gestion de la pagination

Beaucoup d’APIs limitent le nombre de résultats par requête, nécessitant une approche par pagination :

import requests
import time

def collect_all_data(base_url, params, max_pages=10):
    all_data = []
    page = 1

    while page <= max_pages:
        params['page'] = page
        response = requests.get(base_url, params=params)

        if response.status_code != 200:
            break

        data = response.json()
        if not data.get('results'):  # Plus de données disponibles
            break

        all_data.extend(data['results'])
        page += 1
        time.sleep(1)  # Respect des limites de débit

    return all_data

Gestion des erreurs et retry

import requests
import time
from requests.exceptions import RequestException

def robust_request(url, max_retries=3, delay=1):
    for attempt in range(max_retries):
        try:
            response = requests.get(url, timeout=10)
            response.raise_for_status()  # Lève une exception si statut d'erreur
            return response

        except RequestException as e:
            print(f"Tentative {attempt + 1} échouée: {e}")
            if attempt < max_retries - 1:
                time.sleep(delay * (2 ** attempt))  # Backoff exponentiel
            else:
                raise

Respect de l’éthique et de la légalité

Fichier robots.txt :

Toujours vérifier les permissions avant de scraper :

import requests

def check_robots_txt(domain):
    robots_url = f"{domain}/robots.txt"
    try:
        response = requests.get(robots_url)
        print("Contenu de robots.txt:")
        print(response.text)
    except:
        print("robots.txt non accessible")

# Exemple d'utilisation
check_robots_txt("https://example.com")

Bonnes pratiques éthiques :

Respecter robots.txt et les conditions de service
Limiter la fréquence des requêtes (éviter la surcharge serveur)
Identifier son bot avec un User-Agent approprié
Ne pas collecter de données personnelles sensibles
Respecter le droit d’auteur et la propriété intellectuelle

Stockage et organisation des données collectées

Structure de stockage recommandée

data_collection_project/
├── raw_data/
│   ├── 2024-03-15_quotes_scraped.json
│   ├── 2024-03-15_weather_api.json
│   └── logs/
├── processed_data/
│   ├── cleaned_quotes.csv
│   └── weather_analysis.csv
├── scripts/
│   ├── scraper_quotes.py
│   ├── api_weather.py
│   └── utils.py
└── documentation/
    ├── api_documentation.md
    └── scraping_notes.md

Sauvegarde et versioning

import json
import pandas as pd
from datetime import datetime

def save_collected_data(data, filename_prefix):
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")

    # Sauvegarde JSON brute
    json_filename = f"raw_data/{timestamp}_{filename_prefix}.json"
    with open(json_filename, 'w', encoding='utf-8') as f:
        json.dump(data, f, ensure_ascii=False, indent=2)

    # Conversion en DataFrame et sauvegarde CSV
    df = pd.DataFrame(data)
    csv_filename = f"processed_data/{timestamp}_{filename_prefix}.csv"
    df.to_csv(csv_filename, index=False, encoding='utf-8')

    print(f"Données sauvegardées: {len(data)} entrées")
    print(f"Fichiers créés: {json_filename}, {csv_filename}")

Points clés à retenir

Le web scraping ouvre l’accès à des données massives mais nécessite vigilance éthique
Les APIs offrent un accès structuré et légal aux données
La gestion d’erreurs et la robustesse sont essentielles pour la collecte automatisée
L’organisation et le versioning des données facilitent les analyses ultérieures
L’éthique doit guider toute démarche de collecte automatisée

Références

Jotform – Méthodes de collecte de données
Jedha – Collecte de données : méthodes et outils
ScrapingBee – Python Web Scraping: Full Tutorial
GeeksforGeeks – Implementing Web Scraping with BeautifulSoup