Extração de dados na Web com Jupyter notebooks

Neste guia, você vai aprender:

• O que são Jupyter notebooks
• Por que você deve usar Jupyter notebooks para web scraping
• Como usá-los em um tutorial passo a passo
• Casos de uso de Jupyter notebooks para extrair dados on-line

Vamos lá!

O que são os Jupyter notebooks?

No contexto do Jupyter, um  notebook é “um documento compartilhável que combina código de computador, descrições em linguagem simples, dados, tabelas, gráficos, figuras e controles interativos”.

Os notebooks oferecem ambientes interativos para prototipagem e explicação de código, exploração e visualização de dados e compartilhamento de ideias. Em particular, os notebooks produzidos pelo aplicativo Jupyter Notebook são chamados de Jupyter Notebooks.

O aplicativo Jupyter Notebook é um aplicativo servidor-cliente que permite editar e executar documentos do notebook por meio de um navegador da web. Ele pode ser executado em um desktop local ou instalado em um servidor remoto.

O Jupyter Notebooks fornece o chamado “kernel”, que é um “mecanismo computacional” que executa o código contido em um documento do Notebook. Em detalhes, o kernel ipython executa o código Python (mas existem kernels em outras linguagens):

O aplicativo Jupyter Notebook apresenta um painel que suporta operações típicas, como mostrar arquivos locais, abrir documentos existentes do notebook, gerenciar kernels de documentos e muito mais:

Por que usar o Jupyter Notebooks para extração de dados na web?

Os Jupyter Notebooks são projetados especificamente para fins de análise de dados e P&D e são úteis para fins de extração na web devido a:

• Desenvolvimento interativo: Escreva e execute código em pequenos blocos gerenciáveis chamados células. Cada célula pode funcionar independentemente das outras. Isso garante testes e depuração simplificados.
• Organização: Use markdown em suas células para documentar o código, explicar a lógica e adicionar notas ou instruções.
• Integração com ferramentas de análise de dados: após a extração, você pode limpar, processar e analisar imediatamente os dados em Python, pois o Jupyter Notebooks se integra a bibliotecas como pandas, matplotlib, seaborne muitas outras.
• Reprodutibilidade e compartilhamento: O Jupyter Notebooks pode ser facilmente compartilhado com outras pessoas como arquivos .ipynb (seu formato padrão) ou convertidos em outros formatos como reST, Markdown e muitos outros.

Prós e contras

Estes são os prós e os contras de usar o Jupyter Notebooks para extração de dados:

👍 Prós:

• Depuração passo a passo: Como cada célula pode ser executada de forma independente, você pode subdividir seu código de extração de dados em células diferentes e executá-las. Isso permite que você depure pequenos trechos de código executando as células e interceptando bugs no nível da célula.
• Documentação: Use o Markdown nas células para criar arquivos nos quais você possa documentar como seu código de extração funciona, bem como descrever a lógica por trás das escolhas que você fez.
• Flexibilidade: No Jupyter Notebooks, você pode combinar extração na web, limpeza de dados e análise em um único ambiente. Isso permite alternar entre ambientes diferentes, como escrever o script de extração em uma IDE e analisar dados em outro lugar.

👎Contras:

• Não é ideal para projetos de grande escala: o Jupyter Notebooks tende a gerar documentos longos. Isso faz com que eles não sejam a escolha ideal para projetos de extração de dados em grande escala.
• Limitações de desempenho: Os notebooks tendem a ficar lentos ou sem resposta quando trabalham com grandes conjuntos de dados ou executam scripts longos. Saiba mais sobre como tornar a extração na web mais rápida.
• Não é ideal para automação: Se você precisar executar seu extrator de acordo com um cronograma ou implantá-lo como parte de um sistema maior, o Jupyter Notebooks não é a melhor escolha. A razão é que eles são projetados principalmente para execução manual e interativa de células.

Como usar o Jupyter Notebooks para extração na Web: tutorial passo a passo

Agora você sabe por que deve usar o Jupyter Notebooks para extração na web. Assim, você está pronto para ver como usá-los em um cenário de extração no mundo real!

Pré-requisitos

Para replicar este tutorial, seu sistema deve atender aos seguintes pré-requisitos:

• Python 3.6 ou superior: Qualquer versão do Python superior à 3.6 serve. Especificamente, instalaremos as dependências via pip, que já está instalada com qualquer versão do Python superior à 3.4.

Etapa 1: Configurando o ambiente e instalando dependências

Suponha que você chame a pasta principal do seu projeto de scraper/. Ao final dessa etapa, a pasta terá a seguinte estrutura:

scraper/
    ├── analysis.ipynb
    └── venv/

Onde:

• analysis.ipynb é o Jupyter Notebook que contém todo o código.
• venv/ contém o ambiente virtual.

Você pode criar a pasta venv/ virtual environment assim:

python -m venv venv

Para ativá-lo, no Windows, execute:

venv\Scripts\activate

Equivalentemente, no macOS/Linux, execute:

source venv/bin/activate

No ambiente virtual ativado, instale todas as bibliotecas necessárias para este tutorial:

pip install requests beautifulsoup4 pandas jupyter seaborn

Essas bibliotecas servem aos seguintes propósitos:

• requests: Para realizar solicitações HTTP.
• beautifulSoup4: Para conversão de documentos HTML e XML.
• pandas: Uma poderosa biblioteca de manipulação e análise de dados, ideal para trabalhar com dados estruturados, como arquivos CSV ou tabelas.
• jupyter: Um ambiente de desenvolvimento interativo baseado na web para executar e compartilhar código Python, ótimo para análise e visualização.
• seaborn: Uma biblioteca de visualização de dados em Python baseada em Matplotlib.

Para criar o arquivo analysis.ipynb , primeiro você precisa entrar na pasta scraper/ :

cd scraper

Em seguida, inicialize um novo Jupyter Notebook com este comando:

jupyter notebook

Agora você pode acessar seu aplicativo Jupyter Notebook por meio do locahost8888.

Crie um novo arquivo clicando na opção “Novo > Python 3”:

O novo arquivo será automaticamente chamado de untitled.ipynb. Você pode renomeá-lo no painel:

Ótimo! Agora você está totalmente configurado para extração na web com o Jupyter Notebooks.

Etapa 2: Definir a página de destino

Neste tutorial, você extrairá os dados do site worldometer. Em particular, a página alvo é aquela relacionada às emissões de CO2 nos Estados Unidos por ano, que fornece dados tabulares como:

Etapa 3: Recuperar os dados

Você pode recuperar os dados da página de destino e salvá-los em um arquivo CSV da seguinte forma:

import requests
from bs4 import BeautifulSoup
import csv

# URL of the website
url = "https://www.worldometers.info/co2-emissions/us-co2-emissions/"

# Send a GET request to the website
response = requests.get(url)
response.raise_for_status() 

# Parse the HTML content
soup = BeautifulSoup(response.text, "html.parser")

# Locate the table
table = soup.find("table") 

# Extract table headers
headers = [header.text.strip() for header in table.find_all("th")]

# Extract table rows
rows = []
for row in table.find_all("tr")[1:]:  # Skip the header row
    cells = row.find_all("td")
    row_data = [cell.text.strip() for cell in cells]
    rows.append(row_data)

# Save the data to a CSV file
csv_file = "emissions.csv"
with open(csv_file, mode="w", newline="", encoding="utf-8") as file:
    writer = csv.writer(file)
    writer.writerow(headers)  # Write headers
    writer.writerows(rows)    # Write rows

print(f"Data has been saved to {csv_file}")

Aqui está o que esse código faz:

• Ele usa a bibliotecarequests para enviar uma solicitação GET para a página de destino por meio do método requests.get()e verifica se há erros de solicitação por meio do método response.raise_for_status().
• Ele usa o BeautifulSoup para converter o conteúdo HTML instanciando a classe BeautifulSoup() e encontrando o seletor table com o método soup.find(). Em particular, esse método é útil para localizar a tabela que contém os dados. Se você não estiver familiarizado com essa sintaxe, leia nosso guia sobre Extração da web com BeautifulSoup.
• Ele usa uma compreensão de lista para extrair o cabeçalho da tabela.
• Ele usa um loop for para recuperar todos os dados da tabela, pulando a linha do cabeçalho.
• Por fim, ele abre um novo arquivo CSV e anexa lá todos os dados recuperados.

Você pode colar esse código em uma célula e executá-lo pressionando SHIFT+ENTER.

Outra forma de executar a célula é selecioná-la e pressionar o botão “Executar” no painel:

Surpreendente, veja como a mensagem “Os dados foram salvos em emissions.csv” notifica você sobre a operação bem-sucedida de extração de dados.

Etapa 4: garantir que os dados estejam corretos

Agora que você salvou os dados em um arquivo CSV. Abra o CSV e veja se tudo correu bem. Às vezes, você pode enfrentar problemas com conversões. Para fazer isso, você pode digitar o seguinte código em uma nova célula:

import pandas as pd

# Load the CSV file into a pandas DataFrame
csv_file = "emissions.csv"
df = pd.read_csv(csv_file)

# Print the DataFrame
df.head()

Esse código faz o seguinte:

• Abre o arquivo CSV como um quadro de dados, graças à pandas, com o método pd.read_csv().
• Imprime as primeiras cinco linhas do quadro de dados com o método df.head().

Aqui está o resultado esperado:

Perfeito! Só resta representar os dados extraídos.

Etapa 5: visualizar os dados

Agora você pode fazer qualquer análise de dados que preferir. Por exemplo, você pode usar seaborn para criar um gráfico de linhas que mostre a tendência das emissões de C02 ao longo dos anos. Faça o seguinte:

import seaborn as sns
import matplotlib.pyplot as plt

# Load the CSV file into a pandas DataFrame
csv_file = "emissions.csv"
df = pd.read_csv(csv_file)

# Clean column names be removing extra spaces
df.columns = df.columns.str.strip().str.replace('  ', ' ')

# Convert 'Fossil CO2 Emissions (tons)' to numeric
df['Fossil CO2 Emissions (tons)'] = df['Fossil CO2 Emissions (tons)'].str.replace(',', '').astype(float)

# Ensure the 'Year' column is numeric
df['Year'] = pd.to_numeric(df['Year'], errors='coerce')
df = df.sort_values(by='Year')

# Create the line plot
plt.figure(figsize=(10, 6))
sns.lineplot(data=df, x='Year', y='Fossil CO2 Emissions (tons)', marker='o')

# Add labels and title
plt.title('Trend of Fossil CO2 Emissions Over the Years', fontsize=16)
plt.xlabel('Year', fontsize=12)
plt.ylabel('Fossil CO2 Emissions (tons)', fontsize=12)
plt.grid(True)
plt.show()

Aqui está o que esse código faz:

• Ele usa a pandas para:
  • Abra o arquivo CSV.
  • Limpa os nomes das colunas removendo espaços extras com o método df.columns.str.strip().str.replace(' ', ' ') (se você não usar isso, receberá erros em seu código neste exemplo).
  • Acessa a coluna “Emissões de CO2 fóssil (toneladas)” e converte dados em números com o método df['Emissões de CO2 fóssil (toneladas)'].str.replace.(',', '').astype(float).
  • Acessa a coluna “Anos”, converte os valores em números com o método pd.to_numeric()e classifica os valores em ordem ascendente com o método df.sort_values().
• Ele usa as bibliotecas matplotlib e seaborn (que é construído com base na matplotlib, então ele é instalado quando você instala o seaborn) para criar o gráfico real.

Aqui está o resultado esperado:

Uau! Isso mostra o quão poderosa é a extração do Jupyter Notebook.

Etapa 6: Juntar tudo

Esta é a aparência do documento final de extração da web com o Jupyter Notebook:

Note a presença de blocos diferentes, cada um com sua saída.

Casos de uso de Extração da Web com o Jupyter Notebook

É hora de discutir os casos de uso do Jupyter Notebooks durante a extração na web!

Tutoriais

Não se esqueça de que cada célula em um Jupyter Notebook pode ser executada de forma independente. Com o suporte adicional para Markdown, a biblioteca se torna uma excelente ferramenta para criar tutoriais passo a passo.

Por exemplo, você pode alternar entre células que contêm código e aquelas que explicam a lógica e o raciocínio por trás dele. No caso de extração da web, os Jupyter Notebooks são particularmente úteis. Eles podem ser usados para criar tutoriais para desenvolvedores juniores, orientando-os em cada etapa do processo.

Ciência e Pesquisa (P&D)

Devido à sua natureza interativa e à capacidade de serem facilmente exportados para colaboração, os Jupyter Notebooks são ideais para fins de pesquisa e P&D. Isso é especialmente verdadeiro para extração da web. Por exemplo, ao copiar sites que exigem várias rodadas de tentativa e erro, você pode manter todos os seus testes em um único Notebook e usar o Markdown para destacar os testes bem-sucedidos.

Exploração de dados

A biblioteca Jupyter foi projetada especificamente para exploração e análise de dados. Isso também o torna uma ferramenta perfeita para extração da web para aprendizado de máquina.

Esse caso de uso se aplica diretamente ao exemplo que você codificou acima. Você recuperou os dados do site e os analisou imediatamente, tudo dentro do mesmo ambiente de codificação.

Conclusão

Nesta publicação, você aprendeu como os Jupyter Notebooks podem ser uma ferramenta poderosa para extração da web, oferecendo um ambiente interativo e flexível para extração e análise de dados. No entanto, quando se trata de escalar suas operações de extração da web ou automatizar tarefas, os Jupyter Notebooks podem não ser a solução mais eficiente.

É aí que entram nossos Web Scrapers . Se você é um desenvolvedor em busca de soluções baseadas em API ou alguém que busca uma opção sem código, nossos Web Scrapers foram projetados para simplificar e aprimorar seus esforços de coleta de dados. Com recursos como endpoints dedicados para mais de 100 domínios, tratamento de solicitações em massa, rotação automática de IPe resolução de CAPTCHA, você pode extrair dados estruturados sem esforço e em grande escala. Crie uma conta gratuita da Bright Data hoje mesmo para experimentar nossas soluções de raspagem e teste nossos proxies!