`. Encapsula la lógica para recuperar todas las URL de paginación en una función:
```none
def get_all_page_urls(base_url="https://www.scrapethissite.com/pages/forms/"):
# Obtener la primera página para extraer los enlaces de paginación
response = requests.get(base_url)
# Analizar la página
selector = Selector(text=response.text)
# Extraer todos los enlaces de la página del área de paginación
page_links = selector.css("ul.pagination li a::attr(href)").getall() # Ajustar el selector en función de la estructura HTML
unique_links = list(set(page_links)) # Eliminar duplicados si los hay
# Construir URL completas para todas las páginas
full_urls = [urljoin(base_url, link) for link in unique_links]
return full_urls
```
Esta función hace lo siguiente:
- El método [`getall()`](https://parsel.readthedocs.io/en/latest/parsel.html#parsel.selector.Selector.getall) recupera todos los enlaces de paginación.
- El método `list(set())` elimina los duplicados para evitar visitar la misma página dos veces.
- El método [`urljoin()`](https://docs.python.org/3/library/urllib.parse.html#urllib.parse.urljoin), de la biblioteca `urlib.parse`, convierte todas las URL relativas en URL absolutas para que puedan utilizarse en futuras solicitudes HTTP.
Para que el código anterior funcione, asegúrate de importar `urljoin` desde la biblioteca estándar de Python:
```none
from urllib.parse import urljoin
```
Ahora puede extraer todas las páginas con:
```none
# Dónde almacenar los datos extraídos
data = []
# Obtener todas las URL de las páginas
page_urls = get_all_page_urls()
# Iterar sobre ellas y aplicar la lógica de rastreo
for url in page_urls:
# Rastrear la página actual
page_data = scrape_page(url)
# Añadir los datos rastreados a la lista
data.extend(page_data)
# Imprimir los datos extraídos
print("Datos de todas las páginas:")
for entry in data:
print(entry)
```
El fragmento anterior:
1. Recupera todas las URL de las páginas llamando a la función `get_all_page_urls()`.
2. Extrae datos de cada página llamando a la función `scrape_page()`. A continuación, agrega los resultados con el método [`extend()`](https://docs.python.org/3/tutorial/datastructures.html).
3. Imprime los datos extraídos.
¡Fantástico! La lógica de paginación de Parsel ya está implementada.
### Paso 6: Ponlo todo junto
A continuación se muestra lo que debería contener ahora el archivo `parsel_scraper.py`:
```none
import requests
from parsel import Selector
from urllib.parse import urljoin
def scrape_page(url):
# Obtener el contenido de la página.
response = requests.get(url)
# Realizar el parseo del contenido HTML.
selector = Selector(text=response.text)
# Dónde almacenar los datos extraídos.
data = []
# Seleccionar todas las filas del cuerpo de la tabla
rows = selector.css("table.table tr.team")
# Iterar sobre cada fila y extraer los datos de la misma
for row in rows:
# Extraer los datos de cada columna
name = row.css("td.name::text").get()
year = row.css("td.year::text").get()
wins = row.css("td.wins::text").get()
losses = row.css("td.losses::text").get()
ot_losses = row.css("td.ot-losses::text").get()
pct = row.css("td.pct::text").get()
gf = row.css("td.gf::text").get()
ga = row.css("td.ga::text").get()
diff = row.css("td.diff::text").get()
# Añadir los datos extraídos a la lista
data.append({
"name": name.strip(),
"year": year.strip(),
"wins": wins.strip(),
"losses": losses.strip(),
"ot_losses": ot_losses.strip(),
"pct": pct.strip(),
"gf": gf.strip(),
"ga": ga.strip(),
"diff": diff.strip(),
})
return data
def get_all_page_urls(base_url="https://www.scrapethissite.com/pages/forms/"):
# Obtener la primera página para extraer los enlaces de paginación.
response = requests.get(base_url)
# Realizar el parseo de la página.
selector = Selector(text=response.text)
# Extraer todos los enlaces de la página del área de paginación
page_links = selector.css("ul.pagination li a::attr(href)").getall() # Ajustar el selector según la estructura HTML
unique_links = list(set(page_links)) # Eliminar duplicados, si los hay
# Construir URL completas para todas las páginas
full_urls = [urljoin(base_url, link) for link in unique_links]
return full_urls
# Dónde almacenar los datos extraídos
data = []
# Obtener todas las URL de las páginas
page_urls = get_all_page_urls()
# Iterar sobre ellas y aplicar la lógica de rastreo
for url in page_urls:
# Rastrear la página actual
page_data = scrape_page(url)
# Añadir los datos rastreados a la lista
data.extend(page_data)
# Imprimir los datos extraídos
print("Datos de todas las páginas:")
for entry in data:
print(entry)
```
¡Muy bien! Has completado tu primer proyecto de scraping con Parsel.
## Escenarios avanzados de Scraping web con Parsel en Python
En la sección anterior, aprendiste a utilizar Parsel en Python para extraer los datos de una página web de destino utilizando selectores CSS. ¡Es hora de considerar algunos escenarios más avanzados!
### Seleccionar elementos por texto
Parsel ofrece diferentes métodos de consulta para recuperar el texto de HTML utilizando [XPath](https://parsel.readthedocs.io/en/latest/usage.html#some-xpath-tips). En este caso, la función `text()` se utiliza para extraer el contenido de texto de un elemento.
Imagina que tienes un código HTML como este:
```none
Bienvenido a Parsel
Este es un párrafo.
Otro párrafo.
```
Puede recuperar todo el texto de la siguiente manera:
```none
from parsel import Selector
html = """
Bienvenido a Parsel
Este es un párrafo.
Otro párrafo.
"""
selector = Selector(text=html)
# Extraer texto de la etiqueta
h1_text = selector.xpath("//h1/text()").get()
print("Texto H1:", h1_text)
# Extraer texto de todas las etiquetas
p_texts = selector.xpath("//p/text()").getall()
print("Nodos de texto de párrafo:", p_texts)
```
Este fragmento localiza las etiquetas `
` y `
` y extrae el texto de ellas con `text()`, lo que da como resultado:
```none
Texto H1: Bienvenido a Parsel
Nodos de texto de párrafo: ['Este es un párrafo.', 'Otro párrafo.']
```
Otra función útil es `contains()`, que se puede utilizar para buscar elementos que contengan un texto específico. Por ejemplo, supongamos que tienes el siguiente código HTML:
```none
Este es un párrafo de prueba.
Otro párrafo de prueba.
Contenido no relacionado.
```
Ahora quieres extraer el texto de los párrafos que solo contienen la palabra «prueba». Puedes hacerlo con el siguiente código:
```none
from parsel import Selector
# html = """..."""
selector = Selector(text=html)
# Extraer párrafos que contengan la palabra «prueba»
test_paragraphs = selector.xpath("//p[contains(text(), 'test')]/text()").getall()
print("Párrafos que contienen 'prueba':", test_paragraphs)
```
El Xpath `p[contains(text(), 'test')]/text()` se encarga de buscar el párrafo que solo contiene «test». El resultado será:
```none
Párrafos que contienen «test»: ['Este es un párrafo de prueba.', 'Otro párrafo de prueba.']
```
Pero, ¿qué pasa si quieres interceptar el texto que comienza con un valor específico de una cadena? ¡Pues puedes usar la función `starts-with()`! Considera este HTML:
```none
Empieza aquí.
Empieza de nuevo.
Termina aquí.
```
Para recuperar el texto de los párrafos que comienzan con la palabra «start», utiliza `p[starts-with(text(), 'Start')]/text()` de la siguiente manera:
```none
from parsel import Selector
# html = """..."""
selector = Selector(text=html)
# Extrae los párrafos cuyo texto comienza con «Start»
start_paragraphs = selector.xpath("//p[starts-with(text(), 'Start')]/text()").getall()
print("Párrafos que comienzan con 'Start':", start_paragraphs)
```
El fragmento anterior produce:
```none
Párrafos que comienzan con «Start»: ['Start here.', 'Start again.']
```
Más información sobre [los selectores CSS frente a los selectores XPath.](/blog/web-data/xpath-vs-css-selectors)
### Uso de expresiones regulares
Parsel le permite recuperar texto para condiciones avanzadas utilizando [expresiones regulares](https://parsel.readthedocs.io/en/latest/usage.html#regular-expressions) con la función `re:test()`.
Considere este HTML:
```none
Elemento 12345
Elemento ABCDE
Un párrafo
2026 es el año actual
```
Para extraer el texto de los párrafos que solo contienen valores numéricos, puede utilizar `re:test()` de la siguiente manera:
```none
from parsel import Selector
# html = """..."""
selector = Selector(text=html)
# Extraer párrafos cuyo texto coincida con un patrón numérico
numeric_items = selector.xpath("//p[re:test(text(), 'd+')]/text()").getall()
print("Elementos numéricos:", numeric_items)
```
El resultado es:
```none
Elementos numéricos: ['Elemento 12345', '2026 es el año actual']
```
Otro uso típico de las expresiones regulares es interceptar direcciones de correo electrónico. Esto se puede utilizar para extraer texto de párrafos que solo contienen direcciones de correo electrónico. Por ejemplo, consideremos el siguiente HTML:
```none
Contáctanos en [email protected]
Envíe un correo electrónico a [email protected]
No hay correo electrónico aquí.
```
A continuación se muestra cómo se puede utilizar `re:test()` para seleccionar nodos que contienen direcciones de correo electrónico:
```none
from parsel import Selector
selector = Selector(text=html)
# Extraer párrafos que contengan direcciones de correo electrónico
emails = selector.xpath("//p[re:test(text(), '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}')]/text()").getall()
print("Correos electrónicos coincidentes:", emails)
```
El resultado es:
```none
Correspondencias de correo electrónico: ['Contáctanos en ` de la siguiente manera:
```none
from parsel import Selector
selector = Selector(text=html)
# Selecciona el padre de la etiqueta