Gestione della paginazione e di più pagine
Scorra i risultati paginati e combini i dati acquisiti in un unico dataset.
Gestione della paginazione e di più pagine è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.
Comprendere la paginazione
Molti siti web distribuiscono i contenuti su più pagine. La paginazione basata sull'URL aggiunge un numero di pagina all'URL (ad esempio ?page=2 o /page/2/). Identifichi il pattern per costruire programmaticamente gli URL.
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' ...Creazione di pattern per gli URL con sprintf
sprintf() e paste0() costruiscono entrambe stringhe URL, ma sprintf() offre un controllo maggiore sul riempimento con zeri e sulla formattazione. Usi quella più adatta alla struttura degli URL del sito.
# 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}')Scraping di più pagine con map()
purrr::map() applica una funzione di scraping a un vettore di URL e restituisce una lista di risultati. La combini con dplyr::bind_rows() per unirli in un unico 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 rispettoso: Sys.sleep()
L'invio di richieste rapide a un server è poco rispettoso e può attivare limitazioni della frequenza o blocchi dell'IP. Inserisca Sys.sleep() tra le richieste per rispettare il server. In genere è sufficiente un'attesa di 1-2 secondi.
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')Impostazione di uno User Agent
Identifichi educatamente il Suo scraper impostando un'intestazione User-Agent descrittiva. I server la usano per identificare i bot. Un buon User-Agent include il Suo nome e le Sue informazioni di contatto, così i proprietari del sito possono raggiungerLa.
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')Rispetto di robots.txt
robots.txt indica ai crawler quali percorsi non possono essere visitati. Il pacchetto robotstxt consente di verificare programmaticamente se un URL è autorizzato prima di eseguirne lo scraping.
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')Seguire i link di paginazione
Anziché indovinare gli URL, segua il link 'Next' effettivo presente in ogni pagina. html_attr(html_element(page, 'a.next'), 'href') individua dinamicamente il link alla pagina successiva e gestisce anche pattern di paginazione non sequenziali.
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() di rvest crea una sessione di navigazione con stato, che conserva cookie e cronologia. session_follow_link() consente di seguire un link, una funzione utile per i siti che richiedono l'accesso o mantengono lo stato tra le pagine.
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')Rilevamento dell'ultima pagina
Stabilisca quando interrompere l'operazione: verifichi se il pulsante 'Next' esiste, se il numero di elementi nella pagina corrente è inferiore a quello previsto o se il numero di pagina supera un totale noto. Gestisca i casi limite in modo appropriato.
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')Gestione degli errori di scraping
Si verificheranno errori di rete, timeout e risposte 404. Racchiuda le richieste in tryCatch() per gestire correttamente gli errori e registri le pagine che non è stato possibile elaborare, così da poterle riprovare in seguito.
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)Memorizzazione nella cache delle pagine estratte
Salvi l'HTML scaricato su disco prima di analizzarlo. In questo modo, se l'analisi non riesce, non dovrà scaricarlo nuovamente. Le successive letture avverranno dal disco, non dalla rete: una soluzione rispettosa e rapida durante lo sviluppo.
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)Verifica rapida
Verifichi la Sua comprensione dello scraping multipagina rispettoso e robusto.
Riepilogo: paginazione e scraping rispettoso
Punti chiave: costruisca gli URL delle pagine con paste0() o sprintf(). Usi purrr::map() per applicare lo scraping a numerosi URL. Inserisca sempre Sys.sleep() tra le richieste. Verifichi robots.txt con il pacchetto robotstxt. Segua dinamicamente i link 'Next' con html_attr() o session_follow_link(). Rilevi l'ultima pagina verificando l'assenza del link Next. Racchiuda le richieste in tryCatch() per rendere il processo resiliente agli errori. Memorizzi l'HTML su disco durante lo sviluppo.
# 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')Domande Frequenti
La lezione «Gestione della paginazione e di più pagine» è gratuita?
Sì — il testo completo di «Gestione della paginazione e di più pagine» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.
Cosa imparerò in «Gestione della paginazione e di più pagine»?
Scorra i risultati paginati e combini i dati acquisiti in un unico dataset. Eserciti R Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare R Academy?
Non è richiesta alcuna esperienza precedente. R Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Gestione della paginazione e di più pagine»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione R Academy?
Sì. Ogni lezione R Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Struttura HTML e selettori CSS
- Basi di html_element() e html_text()
- Acquisizione di tabelle e link
- Gestione della paginazione e di più pagine