`. Encapsule a lógica para recuperar todas as URLs de paginação em uma função:
```none
def get_all_page_urls(base_url="https://www.scrapethissite.com/pages/forms/"):
# Busque a primeira página para extrair os links de paginação
response = requests.get(base_url)
# Analise a página
selector = Selector(text=response.text)
# Extraia todos os links da página da área de paginação
page_links = selector.css("ul.pagination li a::attr(href)").getall() # Ajuste o seletor com base na estrutura HTML
links_únicos = list(set(links_da_página)) # Remova duplicatas, se houver
# Construa URLs completas para todas as páginas
urls_completas = [urljoin(url_base, link) para link em links_únicos]
retorne urls_completas
```
Esta função faz o seguinte:
- O método [`getall()`](https://parsel.readthedocs.io/en/latest/parsel.html#parsel.selector.Selector.getall) recupera todos os links de paginação.
- O método `list(set())` remove duplicatas para evitar visitar a mesma página duas vezes.
- O método [`urljoin()`](https://docs.python.org/3/library/urllib.parse.html#urllib.parse.urljoin), da biblioteca `urlib.parse`, converte todas as URLs relativas em URLs absolutas para que possam ser usadas em outras solicitações HTTP.
Para que o código acima funcione, certifique-se de importar `urljoin` da biblioteca padrão do Python:
```none
from urllib.parse import urljoin
```
Agora você pode extrair todas as páginas com:
```none
# Onde armazenar os dados extraídos
data = []
# Obter todos os URLs da página
page_urls = get_all_page_urls()
# Itere sobre elas e aplique a lógica de extração
for url in page_urls:
# Extraia a página atual
page_data = scrape_page(url)
# Adicione os dados extraídos à lista
data.extend(page_data)
# Imprima os dados extraídos
print("Dados de todas as páginas:")
for entry in data:
print(entry)
```
O trecho acima:
1. Recupera todas as URLs das páginas chamando a função `get_all_page_urls()`.
2. Rastreia os dados de cada página chamando a função `scrape_page()`. Em seguida, agrega os resultados com o método [`extend()`](https://docs.python.org/3/tutorial/datastructures.html).
3. Imprime os dados coletados.
Fantástico! A lógica de paginação do Parsel agora está implementada.
### Etapa 6: Junte tudo
Abaixo está o que o arquivo `parsel_scraper.py` deve conter agora:
```none
import requests
from parsel import Selector
from urllib.parse import urljoin
def scrape_page(url):
# Busca o conteúdo da página
response = requests.get(url)
# Analisa o conteúdo HTML
selector = Selector(text=response.text)
# Onde armazenar os dados coletados
data = []
# Selecionar todas as linhas no corpo da tabela
rows = selector.css("table.table tr.team")
# Iterar sobre cada linha e extrair os dados dela
for row in rows:
# Extrair dados de cada coluna
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()
# Anexar os dados extraídos à 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(),
})
retornar dados
def obter_todos_os_urls_da_página(url_base="https://www.scrapethissite.com/pages/forms/"):
# Buscar a primeira página para extrair os links de paginação
resposta = requests.get(url_base)
# Analisar a página
seletor = Selector(text=resposta.text)
# Extrair todos os links da página da área de paginação
links_da_página = seletor.css("ul.pagination li a::attr(href)").getall() # Ajustar o seletor com base na estrutura HTML
links_únicos = lista(conjunto(links_da_página)) # Remover duplicatas, se houver
# Construir URLs completas para todas as páginas
full_urls = [urljoin(base_url, link) for link in unique_links]
return full_urls
# Onde armazenar os dados coletados
data = []
# Obter todas as URLs da página
page_urls = get_all_page_urls()
# Iterar sobre elas e aplicar a lógica de extração
para url em page_urls:
# Extrair a página atual
page_data = scrape_page(url)
# Adicionar os dados extraídos à lista
data.extend(page_data)
# Imprimir os dados extraídos
imprimir("Dados de todas as páginas:")
para entrada em data:
imprimir(entrada)
```
Muito bem! Você concluiu seu primeiro projeto de scraping com o Parsel.
## Cenários avançados de Scraping de dados com o Parsel em Python
Na seção anterior, você aprendeu a usar o Parsel em Python para extrair os dados de uma página da web alvo usando seletores CSS. É hora de considerar alguns cenários mais avançados!
### Selecionar elementos por texto
O Parsel oferece diferentes métodos de consulta para recuperar o texto do HTML usando [XPath](https://parsel.readthedocs.io/en/latest/usage.html#some-xpath-tips). Nesse caso, a função `text()` é usada para extrair o conteúdo de texto de um elemento.
Imagine que você tem um código HTML como este:
```none
Bem-vindo ao Parsel
Este é um parágrafo.
Outro parágrafo.
```
Você pode recuperar todo o texto assim:
```none
from parsel import Selector
html = """
Bem-vindo ao Parsel
Este é um parágrafo.
Outro parágrafo.
"""
selector = Selector(text=html)
# Extrair texto da tag
h1_text = selector.xpath("//h1/text()").get()
print("Texto H1:", h1_text)
# Extrair texto de todas as tags
p_texts = selector.xpath("//p/text()").getall()
print("Nós de texto do parágrafo:", p_texts)
```
Este trecho localiza as tags `
` e `
` e extrai o texto delas com `text()`, resultando em:
```none
Texto H1: Bem-vindo ao Parsel
Nós de texto do parágrafo: ['Este é um parágrafo.', 'Outro parágrafo.']
```
Outra função útil é `contains()`, que pode ser usada para corresponder elementos que contêm texto específico. Por exemplo, suponha que você tenha um código HTML como este:
```none
Este é um parágrafo de teste.
Outro parágrafo de teste.
Conteúdo não relacionado.
```
Agora você deseja extrair o texto dos parágrafos que contêm apenas a palavra “teste”. Você pode fazer isso com o seguinte código:
```none
from parsel import Selector
# html = """..."""
selector = Selector(text=html)
# Extrair parágrafos que contêm a palavra “teste”
test_paragraphs = selector.xpath("//p[contains(text(), 'test')]/text()").getall()
print("Parágrafos que contêm 'teste':", test_paragraphs)
```
O Xpath `p[contains(text(), 'test')]/text()` se encarrega de consultar o parágrafo que contém apenas “test”. O resultado será:
```none
Parágrafos que contêm 'teste': ['Este é um parágrafo de teste.', 'Outro parágrafo de teste.']
```
Mas e se você quiser interceptar o texto que começa com um valor específico de uma string? Bem, você pode usar a função `starts-with()`! Considere este HTML:
```none
Comece aqui.
Comece novamente.
Termine aqui.
```
Para recuperar o texto dos parágrafos que começam com a palavra “começar”, use `p[starts-with(text(), 'Começar')]/text()` da seguinte maneira:
```none
from parsel import Selector
# html = """..."""
selector = Selector(text=html)
# Extraia os parágrafos cujo texto começa com “Comece”
start_paragraphs = selector.xpath("//p[starts-with(text(), 'Comece')]/text()").getall()
print("Parágrafos que começam com 'Comece':", start_paragraphs)
```
O trecho acima produz:
```none
Parágrafos que começam com 'Iniciar': ['Inicie aqui.', 'Inicie novamente.']
```
Saiba mais sobre [seletores CSS vs. XPath](/blog/web-data/xpath-vs-css-selectors).
### Usando expressões regulares
O Parsel permite recuperar texto para condições avançadas usando [expressões regulares](https://parsel.readthedocs.io/en/latest/usage.html#regular-expressions) com a função `re:test()`.
Considere este HTML:
```none
Item 12345
Item ABCDE
Um parágrafo
2026 é o ano atual
```
Para extrair o texto dos parágrafos que contêm apenas valores numéricos, você pode usar `re:test()` da seguinte maneira:
```none
from parsel import Selector
# html = """..."""
selector = Selector(text=html)
# Extraia os parágrafos cujo texto corresponda a um padrão numérico
numeric_items = selector.xpath("//p[re:test(text(), 'd+')]/text()").getall()
print("Itens numéricos:", numeric_items)
```
O resultado é:
```none
Itens numéricos: ['Item 12345', '2026 é o ano atual']
```
Outro uso típico de expressões regulares é interceptar endereços de e-mail. Isso pode ser usado para extrair texto de parágrafos que contêm apenas endereços de e-mail. Por exemplo, considere o seguinte HTML:
```none
Contate-nos em [email protected]
Envie um e-mail para [email protected]
Não há e-mail aqui.
```
Veja abaixo como você pode usar `re:test()` para selecionar nós que contêm endereços de e-mail:
```none
from parsel import Selector
selector = Selector(text=html)
# Extrair parágrafos que contêm endereços de e-mail
emails = selector.xpath("//p[re:test(text(), '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}')]/text()").getall()
print("Correspondências de e-mail:", emails)
```
Isso resulta em:
```none
Correspondências de e-mail: ['Contate-nos em ` desta forma:
```none
from parsel import Selector
selector = Selector(text=html)
# Selecione o pai da tag