R Academy · Leçon

Gérer la pagination et plusieurs pages

Parcourez les résultats paginés et combinez les données extraites en un seul jeu de données.

Leçon 4 sur 413 étapes

Gérer la pagination et plusieurs pages est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Comprendre la pagination

De nombreux sites Web répartissent leur contenu sur plusieurs pages. La pagination fondée sur l’URL ajoute un numéro de page à l’URL (par exemple ?page=2 ou /page/2/). Repérez le motif pour construire les URL par programmation.

library(rvest)

# Common URL pagination patterns:
# Pattern 1: query parameter
# https://site.com/products?page=1
# https://site.com/products?page=2

# Pattern 2: path segment
# https://site.com/products/page/1/
# https://site.com/products/page/2/

# Build URLs for pages 1 to 5
base_url <- 'https://books.toscrape.com/catalogue/page-'
page_urls <- paste0(base_url, 1:5, '.html')
page_urls
# [1] 'https://books.toscrape.com/catalogue/page-1.html'
# [2] 'https://books.toscrape.com/catalogue/page-2.html' ...

Construire des motifs d’URL avec sprintf

sprintf() et paste0() construisent toutes deux des chaînes d’URL, mais sprintf() offre davantage de contrôle sur le remplissage par des zéros et le formatage. Utilisez celle qui correspond à la structure des URL du site.

# Various URL building approaches

# paste0 for simple concatenation
pages <- 1:5
urls_v1 <- paste0('https://site.com/list?p=', pages)
urls_v1[1]  # 'https://site.com/list?p=1'

# sprintf for formatted strings
urls_v2 <- sprintf('https://site.com/page/%02d/', pages)
urls_v2[1]  # 'https://site.com/page/01/'

# With multiple parameters
urls_v3 <- sprintf('https://site.com/items?page=%d&size=20', pages)
urls_v3[3]  # 'https://site.com/items?page=3&size=20'

# glue package alternative
# glue('https://site.com/page/{pages}')

Extraire plusieurs pages avec map()

purrr::map() applique une fonction d’extraction à un vecteur d’URL et renvoie une liste de résultats. Combinez-la avec dplyr::bind_rows() pour fusionner les résultats en un seul tableau de données.

library(rvest)
library(purrr)

# Define a function to scrape one page
scrape_page <- function(url) {
  # In real code: page <- read_html(url)
  # Here we simulate with local HTML
  page <- read_html(sprintf(
    '<ul><li class="item">Item %d-A</li><li class="item">Item %d-B</li></ul>',
    url, url
  ))
  data.frame(
    title = html_text2(html_elements(page, '.item')),
    page  = url
  )
}

# Apply over pages 1 and 2 (simulated with numbers)
results <- map(1:2, scrape_page)
do.call(rbind, results)

Extraire poliment : Sys.sleep()

Envoyer rapidement de nombreuses requêtes à un serveur est impoli et peut entraîner une limitation du débit ou le blocage de l’IP. Ajoutez Sys.sleep() entre les requêtes pour respecter le serveur. Un délai d’une à deux secondes suffit généralement.

library(rvest)

# Polite scraping with delays between requests
scrape_with_delay <- function(urls, delay = 1.5) {
  results <- vector('list', length(urls))
  for (i in seq_along(urls)) {
    cat(sprintf('Scraping page %d of %d\n', i, length(urls)))
    # results[[i]] <- read_html(urls[[i]])
    Sys.sleep(delay)  # Wait before next request
  }
  results
}

# Also: randomize delay to appear more human-like
random_delay <- function(min = 1, max = 3) {
  Sys.sleep(runif(1, min = min, max = max))
}
random_delay()
cat('Always be polite to servers you scrape')

Définir un agent utilisateur

Identifiez poliment votre extracteur en définissant un en-tête User-Agent explicite. Les serveurs l’utilisent pour identifier les robots. Un bon User-Agent contient votre nom et vos coordonnées afin que les propriétaires du site puissent vous contacter.

library(rvest)

# Default user agent reveals R/rvest
# Better: set a descriptive, honest UA
ua <- paste0(
  'MyResearchBot/1.0 ',
  '(Academic research; ',
  'contact: researcher@university.edu)'
)

# With httr/httr2 for UA control:
# library(httr2)
# response <- request(url) |>
#   req_headers('User-Agent' = ua) |>
#   req_perform()
# html <- read_html(resp_body_string(response))

# Or use polite package for full compliance:
# library(polite)
# session <- bow('https://example.com', user_agent = ua)
cat('Honest UA: better for everyone')

Respecter robots.txt

robots.txt indique aux robots d’exploration les chemins qui leur sont interdits. Le paquet robotstxt vous permet de vérifier par programmation si une URL est autorisée avant de l’extraire.

library(rvest)
# library(robotstxt)  # uncomment to use

# Check if scraping is allowed:
# rtxt <- robotstxt(domain = 'books.toscrape.com')
# rtxt$check(paths = '/catalogue/', bot = '*')
# TRUE means allowed

# Robots.txt typically looks like:
# User-agent: *
# Disallow: /admin/
# Disallow: /private/
# Allow: /catalogue/
# Crawl-delay: 2

# The polite package combines UA + robots.txt + delays:
# library(polite)
# session <- bow('https://books.toscrape.com')
# page <- scrape(session)
cat('Always check robots.txt before large-scale scraping')

Suivre les liens de pagination

Au lieu de deviner les URL, suivez le lien « Suivant » présent sur chaque page. html_attr(html_element(page, 'a.next'), 'href') trouve dynamiquement le lien vers la page suivante et gère les schémas de pagination non séquentiels.

library(rvest)

# Pattern: follow 'next' links dynamically
scrape_all_pages <- function(start_url, max_pages = 10) {
  all_data <- list()
  url <- start_url
  i <- 1
  while (!is.null(url) && i <= max_pages) {
    # page <- read_html(url)
    # data <- extract_data(page)
    # all_data[[i]] <- data
    # next_link <- html_attr(html_element(page, 'li.next a'), 'href')
    # url <- if (!is.na(next_link)) xml2::url_absolute(next_link, url)
    #        else NULL
    cat(sprintf('Would scrape page %d: %s\n', i, url))
    url <- NULL  # Stop in this demo
    i <- i + 1
  }
  do.call(rbind, all_data)
}
scrape_all_pages('https://books.toscrape.com')

session_follow_link() avec rvest

La fonction session() de rvest crée une session de navigation avec état qui conserve les cookies et l’historique. session_follow_link() permet de suivre un lien, ce qui est utile pour les sites nécessitant une connexion ou conservant un état entre les pages.

library(rvest)
# Stateful session with rvest
# s <- session('https://example.com/login')
# s <- session_submit(s,
#   html_form(read_html(s))[[1]],
#   list(username='me', password='pw')
# )
# After login, navigate:
# page2 <- session_follow_link(s, 'Products')
# page3 <- session_back(page2)   # go back
# session_history(page2)         # show history

# For simple cases, follow href directly:
# href <- html_attr(html_element(page, 'a.next'), 'href')
# next_page <- session_jump_to(s, href)
cat('session() maintains cookies across requests')

Détecter la dernière page

Sachez quand vous arrêter : vérifiez si le bouton « Suivant » existe, si le nombre d’éléments de la page actuelle est inférieur à celui attendu ou si le numéro de page dépasse un total connu. Gérez les cas particuliers avec soin.

library(rvest)
# Strategy 1: Check if 'Next' link exists
has_next <- function(page) {
  next_link <- html_element(page, 'li.next a')
  !is.na(html_attr(next_link, 'href'))
}

# Strategy 2: Compare item count to expected page size
page_size <- 20
check_done <- function(items_on_page) {
  items_on_page < page_size
}

# Strategy 3: Read total from pagination text
# e.g., 'Page 1 of 50' -> extract 50
extract_total_pages <- function(page) {
  text <- html_text2(html_element(page, '.current'))
  as.integer(gsub('.*of (\\d+).*', '\\1', text))
}
cat('Always plan your stopping condition')

Gérer les erreurs d’extraction

Les erreurs réseau, les dépassements de délai et les erreurs 404 surviendront tôt ou tard. Encadrez les requêtes avec tryCatch() pour gérer les échecs proprement et consignez les pages qui ont échoué afin de pouvoir les réessayer plus tard.

library(rvest)

safe_scrape <- function(url) {
  tryCatch({
    # page <- read_html(url)
    # data <- extract_data(page)
    # return(data)
    cat(sprintf('Scraping: %s\n', url))
    data.frame(url = url, status = 'ok')
  }, error = function(e) {
    cat(sprintf('FAILED: %s -> %s\n', url, e$message))
    data.frame(url = url, status = 'error')
  })
}

urls <- c('https://example.com/page/1',
          'https://example.com/page/2')
results <- lapply(urls, safe_scrape)
do.call(rbind, results)

Mettre en cache les pages extraites

Enregistrez le HTML téléchargé sur le disque avant de l’analyser. Ainsi, si l’analyse échoue, vous n’aurez pas besoin de le télécharger à nouveau. Les relectures se font depuis le disque et non depuis le réseau : c’est plus respectueux et plus rapide pendant le développement.

library(rvest)

scrape_cached <- function(url, cache_dir = 'cache') {
  dir.create(cache_dir, showWarnings = FALSE)
  # Create a filename from URL hash
  fname <- file.path(cache_dir,
    paste0(digest::digest(url), '.html'))
  if (file.exists(fname)) {
    cat('Loading from cache\n')
    return(read_html(fname))
  }
  cat('Downloading...\n')
  # page <- read_html(url)
  # xml2::write_html(page, fname)
  # return(page)
  cat('Cached to:', fname, '\n')
}

# Without digest: use URLencode or gsub
url <- 'https://example.com/page/1'
fname <- gsub('[^a-z0-9]', '_', tolower(url))
cat(fname)

Vérification rapide

Vérifiez votre compréhension de l’extraction multipage, respectueuse et robuste.

Réponds-y dans la leçon interactive

Récapitulatif : pagination et extraction respectueuse

À retenir : Construisez les URL des pages avec paste0() ou sprintf(). Utilisez purrr::map() pour appliquer l’extraction à de nombreuses URL. Ajoutez toujours Sys.sleep() entre les requêtes. Vérifiez robots.txt avec le paquet robotstxt. Suivez dynamiquement les liens « Suivant » avec html_attr() ou session_follow_link(). Détectez la dernière page en vérifiant l’absence du lien Suivant. Encadrez les requêtes avec tryCatch() pour résister aux erreurs. Mettez le HTML en cache sur le disque pendant le développement.

# Multi-page scraping template:
# urls <- paste0(base, 1:n_pages)
# results <- purrr::map(urls, function(url) {
#   Sys.sleep(runif(1, 1, 2))  # polite delay
#   page <- read_html(url)
#   extract_data(page)          # your parser
# })
# df <- dplyr::bind_rows(results)

# Key principles:
# 1. Respect robots.txt
# 2. Add delays (Sys.sleep)
# 3. Set honest User-Agent
# 4. Cache HTML during development
# 5. Handle errors with tryCatch
cat('Polite scraping = sustainable scraping')

Gratuit pour commencer

Apprends R avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 43
Leçons: 159

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Gérer la pagination et plusieurs pages » est-elle gratuite ?

Oui — le texte complet de « Gérer la pagination et plusieurs pages » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Gérer la pagination et plusieurs pages » ?

Parcourez les résultats paginés et combinez les données extraites en un seul jeu de données. Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer R Academy ?

Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Gérer la pagination et plusieurs pages » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon R Academy ?

Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à R Academy