Gestión de paginación y varias páginas
Recorra resultados paginados y combine los datos extraídos en un único conjunto de datos.
Gestión de paginación y varias páginas es una lección gratuita de R Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.
Comprender la paginación
Muchos sitios web distribuyen el contenido en varias páginas. La paginación basada en URL añade un número de página a la URL (por ejemplo, ?page=2 o /page/2/). Identifique el patrón para construir las URL mediante código.
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' ...Crear patrones de URL con sprintf
sprintf() y paste0() construyen cadenas de URL, pero sprintf() ofrece más control sobre el relleno con ceros y el formato. Use la que mejor se adapte a la estructura de URL del sitio.
# 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}')Extraer varias páginas con map()
purrr::map() aplica una función de scraping a un vector de URL y devuelve una lista de resultados. Combínela con dplyr::bind_rows() para unirlos en un solo data frame.
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)Scraping responsable: Sys.sleep()
Enviar solicitudes rápidas y repetidas a un servidor es una mala práctica y puede activar límites de frecuencia o bloqueos de IP. Añada Sys.sleep() entre las solicitudes para respetar el servidor. Normalmente, un retraso de 1-2 segundos es suficiente.
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')Establecer un User-Agent
Identifique su scraper de forma respetuosa estableciendo un encabezado User-Agent descriptivo. Los servidores lo utilizan para identificar bots. Un buen User-Agent incluye su nombre y sus datos de contacto para que los propietarios del sitio puedan comunicarse con usted.
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')Respetar robots.txt
robots.txt indica a los crawlers qué rutas están restringidas. El paquete robotstxt permite comprobar mediante código si una URL está permitida antes de extraerla.
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')Seguir los enlaces de paginación
En lugar de adivinar las URL, siga el enlace real «Next» de cada página. html_attr(html_element(page, 'a.next'), 'href') encuentra dinámicamente el enlace a la página siguiente y gestiona los patrones de paginación no secuenciales.
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() con rvest
session() de rvest crea una sesión de navegación con estado que conserva las cookies y el historial. session_follow_link() navega hasta un enlace, lo que resulta útil en sitios que requieren iniciar sesión o mantener el estado entre páginas.
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')Detectar la última página
Sepa cuándo detenerse: compruebe si existe el botón «Next», si la cantidad de elementos de la página actual es menor de lo esperado o si el número de página supera un total conocido. Gestione los casos extremos correctamente.
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')Gestionar errores de scraping
Se producirán errores de red, tiempos de espera agotados y errores 404. Envuelva las solicitudes en tryCatch() para gestionar los fallos correctamente y registre qué páginas fallaron, de modo que pueda volver a intentarlo más adelante.
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)Almacenar en caché las páginas extraídas
Guarde el HTML descargado en el disco antes de analizarlo. Así, si el análisis falla, no tendrá que volver a descargarlo. Las nuevas lecturas se realizan desde el disco y no desde la red: es una opción respetuosa y rápida durante el desarrollo.
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)Comprobación rápida
Compruebe su comprensión del scraping responsable y robusto de varias páginas.
Repaso: paginación y scraping responsable
Conceptos clave: Construya las URL de las páginas con paste0() o sprintf(). Use purrr::map() para aplicar el scraping a muchas URL. Añada siempre Sys.sleep() entre las solicitudes. Compruebe robots.txt con el paquete robotstxt. Siga dinámicamente los enlaces «Next» con html_attr() o session_follow_link(). Detecte la última página comprobando si falta el enlace Next. Envuelva las solicitudes en tryCatch() para mejorar la tolerancia a errores. Almacene el HTML en el disco durante el desarrollo.
# 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')Preguntas frecuentes
¿La lección «Gestión de paginación y varias páginas» es gratis?
Sí — el texto completo de «Gestión de paginación y varias páginas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Gestión de paginación y varias páginas»?
Recorra resultados paginados y combine los datos extraídos en un único conjunto de datos. Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar R Academy?
No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Gestión de paginación y varias páginas»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de R Academy?
Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Estructura HTML y selectores CSS
- Fundamentos de html_element() y html_text()
- Extracción de tablas y enlaces
- Gestión de paginación y varias páginas